Tag: Programming

• Ethereum protocol developers plan a new upgrade, called MEV-Burn.
• MEV-Burn will solve the Miner Extractable Value (MEV).
• As a bonus, MEV-Burn will reduce ETH supply on top of the normal burn from EIP-1559 (“The Merge”)
• Developers anticipate a surge in ETH price due to the deflationary shock.

Disclaimer: The author holds securities mentioned in this article.

I just listened to a great podcast on the MEV-burn upgrade, so I thought to contribute a blog post on the topic.

This upgrade addresses the Maximum Extractable Value (MEV) issue and enhances the overall Ethereum ecosystem. The presence of MEV in Ethereum can lead to negative consequences for user experience and network finality. But don’t worry, there’s hope on the horizon with the upcoming MEV-burn upgrade.

In the expanding world of DeFi, MEV has become a growing force in the Ethereum ecosystem, resulting in toxic forms like frontrunning and sandwich attacks, which can be detrimental to transaction originators. The MEV-burn upgrade promises to mitigate these issues and further reduce Ethereum’s circulating supply, ensuring a better experience for users like yourself.

As Ethereum has completed its much-anticipated transition to Proof-of-Stake (PoS) consensus, the MEV issue becomes even more critical to address. The potential risks include validator centralization and other unforeseen challenges. Thankfully, the MEV-burn upgrade could play a crucial role in safeguarding the network, providing you and the rest of the Ethereum community with more confidence in its security and long-term stability.

Let’s start with a quick overview of the proposal — don’t worry if you don’t get it yet but keep reading. You’ll be smarter afterward!

High-Level Overview

The MEV-Burn proposal aims to reduce proposer centralization, make validator rewards smoother, and enable MEV smoothing for all ETH holders. It allows Ether to capture on-chain value and enhances its economic attributes by making ETH the currency for block building and protecting its monetary premium. MEV burning results in ETH burn of equivalent value for any extracted opportunity, regardless of the assets involved.

In this system, each validator has a chance to become an eligible proposer for a slot. The average number of eligible proposers per slot can bid to propose the next block. These bids determine how much ETH must be burned by the chosen execution block.

Proposers will likely bid up to the MEV amount, resulting in most MEV being burned. The protocol doesn’t measure MEV directly but allows a burn auction to occur every slot.

The proposal involves increasing slot time to 16 seconds, with the first 4 seconds as a “bidding period.” During this time, eligible proposers submit bids, committing to an execution block hash that must burn ETH equal to their bid.

After bidding ends, the slot proceeds, and the highest bidder reveals their block. Other bidders can also reveal blocks, but higher bidders’ blocks will be prioritized.

ETH protocol developer Justin Drake argues that the MEV Burn will have a significant impact on the number of ETH burned. It could essentially double the deflationary rate, i.e., burning 200k-400k ETH more per year on a current supply of roughly 120M ETH. This could add an additional deflationary “yield” of 0.2% per year!

For a scarce asset like ETH, the MEV-Burn could mean an absolute supply shock. In a bull market with lots of demand that would lead to exploding prices.

Wen MEV Burn?

If you’re wondering when the MEV burn will be hard-forked into the Ethereum chain, here’s my best guess based on people more credible than me:

In a recent bankless podcast interview, the Ethereum protocol researcher Justin Drake estimated that the MEV-Burn upgrade will take three to five years. If you take the average and adjust for unforeseen protocol issues, you should not expect MEV burn to come into effect before May 2027.

Understanding MEV and Ethereum

Ethereum Ecosystem

In the Ethereum ecosystem, a key concept you should know is MEV, or Maximal Extractable Value.

MEV is the amount of profit that miners, validators, and block builders can extract from a block by rearranging or including certain transactions. This can impact transaction costs, causing higher gas fees and delays for regular users like yourself.

Recommended: Introduction to Ethereum’s Gas in Solidity Development

MEV in Decentralized Finance

The concept of MEV has become more prominent with the explosion of DeFi (Decentralized Finance) in 2020 — and particularly with the merge, i.e., the move towards proof-of-stake consensus.

Recommended: Common Consensus Mechanisms in Blockchains

In DeFi, various financial applications are built on top of blockchain networks like Ethereum. MEV plays a crucial role in these applications, as it can affect transaction costs and user processing times.

Toxic forms of MEV, such as frontrunning and sandwich attacks, can result in negative settlements, which means you, the transaction originator, may face disadvantages when trading on DeFi platforms such as Uniswap.

I highly recommend you check out our academy course on Uniswap and DeFi if you plan to get a job in crypto — it’s fun and very profitable!

Academy Course: Uniswap Automated Finance for Blockchain Engineers

MEV Participants and Opportunities

The main participants involved with MEV are validators and block builders. These entities are responsible for securing the Ethereum network, validating transactions, and building new blocks. By leveraging MEV opportunities, these participants can increase their revenue.

For example:

• Miners: They
• Validators: Validators can reorder, include, or exclude transactions in a block to maximize their profits, i.e., rearranging transactions to benefit from MEV.
• Block builders: In a PoS (Proof of Stake) model, block builders can also extract value from MEV by optimizing transaction ordering.

Transaction Frontrunning Example (MEV)

An example of Ethereum MEV is when a validator reorders transactions to make a profit. For instance, a validator can extract MEV by reordering transactions in a way that benefits them financially.

Suppose a user wants to trade 1 ETH for 100 DAI, and another user wants to trade 1 ETH for 200 DAI. The validator can re-order the transactions so that the second user’s trade is executed first, and then the first user’s trade.

By doing so, the validator can extract the price difference between the two trades, which is 100 DAI, as a profit.

This practice is known as “transaction frontrunning” and is a common way for validators to extract MEV (source: CoinDesk).

Impact of MEV on Gas Prices and Transactions

EIP-1559 and Gas Prices

With the introduction of EIP-1559, Ethereum aimed to make gas price estimation more predictable for users. However, it is essential to consider MEV’s influence on gas prices. When MEV bots attempt to extract value from transactions, they can drive up the gas prices in two ways:

1. MEV bots pay higher gas fees to prioritize their transactions, creating a competitive market for the limited block space.
2. Non-MEV users also pay higher fees to place their transactions above MEV-extracted transactions, leading to a chain reaction.

This situation might result in an unexpected spike in transaction fees for Ethereum users, even with EIP-1559 in place.

MEV Bots and Network Congestion

MEV bots compete with each other to extract value from user transactions. In times of high network activity, they can contribute to network congestion. MEV bots flood the network with transactions, hoping to exploit profitable opportunities.

In turn, this creates the following scenarios:

• Longer transaction confirmation times
• An increase in the number of pending or dropped transactions
• Overall decline in the network’s performance

These factors affect the user experience for all Ethereum users, making it less predictable and, potentially, less efficient.

But it seems like MEV is a phenomenon that just comes with any complex monetary system and we just have to accept it. MEV burning at least attempts to use the energy to fuel the economic value of the ETH token.

Transaction Discrimination in MEV

One significant concern related to MEV is transaction discrimination.

MEV bots often target high-value transactions, such as those involving DeFi protocols or large trades. As a result, if your transaction falls into this category, it might be targeted and front-run by MEV bots. Also, MEV bots might sandwich your transaction, potentially causing you to receive a worse deal.

If your transaction is not considered valuable by MEV bots, they might still impact your experience indirectly.

For example, because of the increased gas prices and network congestion caused by MEV bots, your transaction might still be delayed or require higher transaction fees.

MEV-Burn: A Solution to MEV Issues

MEV-Smoothing Concept

As you dive into Ethereum, you’ll come across the concept of Maximal Extractable Value (MEV). Again, MEV refers to the profits derived from exploiting the ordering of transactions on the blockchain. The MEV-Smoothing concept aims to distribute these profits more fairly across the Ethereum ecosystem.

This innovative idea introduces mechanisms to “smooth” the revenues generated from MEV, ensuring that all participants, including ETH holders and mining pools, can benefit from the value being extracted from the network. It takes a collective approach to address the negative impacts of MEV and creates a more equitable environment for everyone involved.

Proposer-Builder Separation

As Ethereum transitions towards proof-of-stake (PoS) and staking, the proposer-builder separation is one of the key concepts introduced to help mitigate MEV-related issues.

Currently, miners have the power to both create and validate blocks, often leading to frontrunning and other malicious practices that exploit MEV.

With the proposer-builder separation, these roles are effectively split. Proposers become responsible for aggregating transactions and proposing blocks, while builders focus on executing and validating them. This separation reduces the ability of miners to exploit MEV, increasing fairness and trust in the Ethereum ecosystem.

Reducing MEV Profits and Sell Pressure

The introduction of MEV-burn aims to further align the incentives of individual miners with the rest of the Ethereum ecosystem. This innovative upgrade creates a mechanism to burn the MEV profits extracted by miners, reducing the sell pressure on ETH’s price and ultimately benefiting ETH holders.

As mining pools and stakers see their MEV profits channeled back into the system, they can expect a more equitable distribution of rewards. This process, in turn, helps strengthen the entire Ethereum ecosystem by curbing the negative effects of MEV and enabling a more sustainable growth trajectory for the network.

In conclusion, the implementation of MEV-burn, proposer-builder separation, and Mev-Smoothing concepts contribute significantly to addressing the MEV issue in Ethereum. By fostering a more equitable distribution of profits and reducing the ability of miners to exploit MEV, these solutions help ensure a brighter future for the Ethereum ecosystem and its participants.

Exploring Front-Running and Back-Running in MEV

In Ethereum and blockchain technology, front-running and back-running are common issues. As you delve into these topics, it’s important to understand how they can affect users and developers within the ecosystem.

Flashbots and Front-Running Attacks

Front-running occurs when someone—such as a miner or a node—takes advantage of their position within the network to exploit transaction orderings for their own benefit.

Flashbots are a recent development that aims to address this issue by introducing a fairer environment for all participants. These bots work by transparently allowing searchers to compete for MEV rewards through order flow auctions.

To avoid being a victim of front-running attacks, familiarize yourself with the concept of MEV activity and consider using tools that safeguard your transactions. Keep in mind that Ethereum developers are already addressing this issue through various mempool design improvements.

Back-Running and Chain Reorgs

Back-running, on the other hand, involves the execution of concurrent transactions that aim to capitalize on another user’s desired transaction. It poses a similar threat as front-running and is often tied to chain reorgs where multiple transactions are reorganized within the blockchain.

Knowledge about back-running can help you stay aware of potential risks associated with certain transactions, and may encourage you to engage with projects that actively combat these issues.

The expansion of Flash Boys 2.0 and other efforts focusing on the mitigation of front-running and back-running risks indicates that the Ethereum community is dedicated to addressing these concerns.

Addressing MEV Challenges

The Merge

The Merge has offered new opportunities to address MEV challenges. Ethereum researchers are working on the proposer-builder separation, which separates the role of validators into two distinct functions:

• Proposers: Responsible for creating blocks and providing transaction ordering
• Builders: Responsible for collecting and packaging transactions into block candidates

Separating these roles reduces the risk of validator centralization, and the incentives for harmful actions like eclipse attacks and DDoS attacks are minimized. This new structure will provide a level playing field for all validators, ensuring a healthier network for you and other Ethereum users.

Alternative Solutions to MEV Problems

Ethereum researchers are exploring alternative approaches to address MEV-related problems. One such solution is MEV smoothing.

MEV smoothing involves evenly distributing the MEV revenue to a larger group of participants, preventing any single validator from receiving a disproportionately high reward. This can help reduce validator centralization further and enhance the security of the Ethereum network.

For example, Rocketpool has already distributed a decentralized staking mechanism with smoothing pool for MEV.

Another solution currently under development is the MEV-burn upgrade, which aims to redistribute extracted value to Ethereum users by burning a portion of the MEV rather than passing it to validators. This upgrade is conceptually similar to EIP-1559 and aims to make the Ethereum network more equitable for its users.

Chain reorgs are another MEV-related concern. However, with the Proof-of-Stake model and the proposer-builder separation, the potential for chain reorgs should be significantly reduced. This will help maintain the integrity of the Ethereum network and protect your transactions from being manipulated.

In conclusion, addressing MEV challenges is a priority for Ethereum researchers, and various solutions are being developed to safeguard the network and improve your experience as an Ethereum user.

Recommended: Ethereum – Top 10 Articles to Get Started

I wrote this in my coding, tech, career, and artificial intelligence newsletter. Join us, we’re hundreds of thousands of ambitious techies!

If you’ve read this newsletter for some time, you know that I don’t take the disruptive power of ChatGPT lightly. Some Finxter readers asked me whether freelancing is still the future of work. 

While I don’t have a crystal ball, I’ll give you my best answer below. But first, let’s look at the answer of somebody more credible than me: Upwork’s CEO Hayden Brown.

Hayden spills the beans on the future of freelancing in the age of AI-driven communication and whether ChatGPT is a friend or foe in the gig economy.

[Blog] Will ChatGPT Kill Freelancing? No They’re Allies Not Enemys, Says Upwork CEO

The article shows many interesting stats and facts and glimpses into Upwork’s vast internal datasets. If you want to learn the secrets only known to large freelancing marketplaces, check out the full article on the blog.

In short, Hayden argues that brand-new job roles such as prompt engineers elicit explosive demand at the same time as virtually every single job role is now expected to integrate LLM-based generative AI tools into their own work. 

Hayden also argues that the demand for skilled labor has only increased through the advent of strong AI with ChatGPT and other LLMs. 

Great news!  

My take is that, like the pandemic, the emergence of AGI in the upcoming years will catapult most companies out of their traditional ways and into new ways of organizing talent. Freelancing as a way to organize labor will be winning.

Change is inevitable in the years to come, and the most flexible one has a significant advantage. I’d rather be a freelancer with a diversified business selling my specialized knowledge to companies worldwide, as compared to an employee selling my skills to a single organization/company/government.

Recommended: Should I Become a Freelance Developer?

The sovereign individual needs a high degree of mobility and independence that is only possible with a remote or online-based business.

Legions of freelancers already leverage AI tools to generate large amounts of value for their clients — and income for themselves. Income that flows independently of the prosperity of a single nation, industry, or organization.

But here’s the catch: freelancer or employee, we’ll all be disrupted eventually. And it will be sooner than many of us expect. So, even as freelancers, we’re not protected against the emergence of strong AI. 

What we should do, however, is shift our minds to become investors rather than freelancers or employees so we can get our hands on some of the newly-created wealth. Because this wealth will flow to the owners first. 

Recommended: The Math of Becoming a Millionaire in 13 Years

A sensible approach following these considerations is to work harder, add a new income stream via freelancing (whether you already have a primary income source as an employee or not), and invest the additional proceeds. Where? In companies that benefit from AI’s emergence or in scarce assets like Bitcoin or gold.

I’m not an investment advisor though – just a random dude from the Internet.

Tomorrow, I’ll send you more exciting LLM content – stay tuned!

To your success!

Chris

---

Join our free email newsletter by downloading your Python cheat sheet here:

Schau dir das folgende Erklärungsvideo von AutoGPT an (Videoquelle):

Artikel auf Englisch

Über AutoGPT

AutoGPT ist eine experimentelle Open-Source-Anwendung, die die Fähigkeiten des GPT-4-Sprachmodells demonstriert. Es entwickelt und verwaltet Unternehmen autonom mit dem Ziel, ihren Nettovermögenswert zu erhöhen . Als eines der ersten Beispiele für GPT-4, das vollständig autonom arbeitet, erweitert AutoGPT die Grenzen dessen, was mit KI möglich ist Quelle.

Mit AutoGPT können Sie die Leistungsfähigkeit künstlicher Intelligenz nutzen, um groß angelegte Projekte in kürzester Zeit zu erstellen und dabei viel Zeit und Geld zu sparen . Beispielsweise kann es die SEO Ihrer Website erheblich verbessern und sie aktiver und professioneller erscheinen lassen Quelle.

So sieht es aus, wenn AutoGPT auf meinem Computer läuft – es öffnet automatisch den Browser, besucht Websites, führt webbasierte Recherchen durch und schreibt Dateien auf meinem Computer:

Mit AutoGPT zu beginnen ist einfach! Befolgen Sie einfach diese Schritte:

Schritt 1: Besuchen Sie das Auto-GPT-Repository auf GitHub, wo Sie alle notwendigen Dateien und Anweisungen finden .

Schritt 2: Treten Sie der Auto-GPT-Discord-Community bei, um Fragen zu stellen und sich mit Gleichgesinnten auszutauschen .

Schritt 3: Folgen Sie dem Projekt-Ersteller, Torantulino, auf Twitter, um über die neuesten Entwicklungen und Fortschritte auf dem Laufenden zu bleiben .

Denken Sie daran, dass die anfängliche Einrichtung zwar etwas Zeit in Anspruch nehmen kann, es sich jedoch lohnt, wenn Sie die fantastischen Vorteile sehen, die AutoGPT für Ihren Content-Erstellungsprozess bieten kann .

Viel Spaß beim Experimentieren!

Einführung in AutoGPT

AutoGPT ist ein fortschrittliches Sprachmodell, das auf der GPT-3.5-Architektur basiert und darauf ausgelegt ist, hochwertigen Text mit minimalem Benutzereingriff zu generieren .

In diesem Abschnitt führen wir Sie durch den Prozess der Einführung in AutoGPT, einschließlich der Voraussetzungen und Vorbereitung sowie der Installation und Konfiguration. Lasst uns eintauchen!

Voraussetzungen und Vorbereitung

Bevor Sie mit der Installation beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

• Ein Computer mit Internetzugang
• Python installiert (neueste stabile Version)
• Zugang zu GitHub zum Herunterladen des AutoGPT-Repositorys

Sobald Sie all diese Voraussetzungen erfüllt haben, ist es an der Zeit, Ihren Computer für die Installation vorzubereiten. Beginnen Sie, indem Sie zu dem Verzeichnis navigieren, in dem Sie AutoGPT herunterladen möchten.

Wenn Sie eine virtuelle Umgebung für Python-Projekte bevorzugen, aktivieren Sie diese. Mit eingerichteter Umgebung sind Sie bereit, AutoGPT zu installieren.

Installation und Konfiguration

Das Installieren von AutoGPT ist ein Kinderspiel ! Um zu beginnen, klonen Sie das AutoGPT-Repository von GitHub:

git clone https://github.com/Torantulino/Auto-GPT.git

Navigieren Sie anschließend zum neu erstellten Auto-GPT-Verzeichnis und installieren Sie die erforderlichen Abhängigkeiten. Dies kann normalerweise mit einem einzigen Befehl erledigt werden, wie zum Beispiel:

pip install -r requirements.txt

Sobald die Abhängigkeiten installiert sind, sind Sie bereit, AutoGPT zu verwenden ! Denken Sie daran, auf die AutoGPT-GitHub-Seite für zusätzliche Informationen und Dokumentationen zu verweisen, die Ihnen helfen, das Beste aus diesem leistungsstarken Tool herauszuholen . Von GitHub:

5 Schritte zur einfachen Installation

Um Auto-GPT zu installieren, befolgen Sie diese fünf grundlegenden Schritte:

Schritt 1: Stellen Sie sicher, dass Sie alle oben genannten Anforderungen erfüllen. Wenn nicht, installieren/besorgen Sie sie.

Die folgenden Befehle sollten in einem CMD-, Bash- oder PowerShell-Fenster ausgeführt werden. Um dies zu tun, gehen Sie zu einem Ordner auf Ihrem Computer, klicken Sie oben in den Ordnerpfad und geben Sie CMD ein, dann drücken Sie die Eingabetaste.

Ich verwende PowerShell unter Windows anstelle von CMD für eine einfachere Navigation.

Schritt 2: Klonen Sie das Repository. Sie benötigen Git installiert, aber Sie können stattdessen einfach die ZIP-Datei herunterladen, indem Sie auf die Schaltfläche oben auf der GitHub-Seite klicken.

git clone https://github.com/Torantulino/Auto-GPT.git

Schritt 3: Navigieren Sie zum Projektverzeichnis: Geben Sie dies in Ihr CMD-Fenster ein, Sie möchten das CMD-Fenster zum Repository navigieren, das Sie gerade heruntergeladen haben.

cd 'Auto-GPT'

Schritt 4: Installieren Sie die erforderlichen Abhängigkeiten: Geben Sie dies erneut in Ihr CMD-Fenster ein

pip install -r requirements.txt

Schritt 5: Benennen Sie .env.template in .env um und füllen Sie Ihren OPENAI_API_KEY aus. Wenn Sie den Sprachmodus verwenden möchten, füllen Sie auch Ihren ELEVEN_LABS_API_KEY aus. Besorgen Sie sich Ihren OpenAI-API-Schlüssel von: https://platform.openai.com/account/api-keys.

Das war’s! Sie haben AutoGPT erfolgreich auf Ihrem Computer eingerichtet. Jetzt können Sie das erstaunliche Potenzial dieses KI-gesteuerten Sprachmodells erkunden .

10 Anwendungen und Anwendungsfälle aus der Praxis

AutoGPT bietet eine Vielzahl praktischer Anwendungen, die Ihre täglichen Aufgaben vereinfachen und Ihre Projekte verbessern können. Hier sind zehn Anwendungsfälle aus der Praxis, bei denen Sie die Möglichkeiten von AutoGPT nutzen können:

• Internetrecherche : AutoGPT kann Ihnen helfen, das Internet zu durchsuchen und Suchvorgänge durchzuführen, um relevante Informationen zu finden und Ihnen Zeit und Energie zu sparen.
• Autonomes Programmieren und Debuggen : Nutzen Sie die Leistungsfähigkeit der KI, um schneller und effizienter als je zuvor Code zu schreiben und zu debuggen.
• Social Media Management : Setzen Sie AutoGPT als Twitter-Bot ein, der autonom ansprechende Inhalte generiert und veröffentlicht, um Ihre Online-Präsenz auszubauen.
• Inhalte erstellen : Verbessern Sie Ihre Schreibfähigkeiten, indem Sie AutoGPT für kreative Aufgaben wie Geschichtenerzählen, Artikelverfassen oder sogar Dichten verwenden.
• Bessere Entscheidungsfindung : Nutzen Sie die fundierten Vorhersagen und Erkenntnisse von AutoGPT, um Sie bei persönlichen und beruflichen Entscheidungen zu unterstützen.
• Individuelle Chatbots : Erstellen Sie intelligente Chatbots, die mit Benutzern interagieren und informative Antworten an ihre Bedürfnisse anpassen können.
• Sprachübersetzung : Überwinden Sie Sprachbarrieren, indem Sie AutoGPT nutzen, um Texte mühelos in mehreren Sprachen zu übersetzen.
• Online-Nachhilfe : Unterstützen und helfen Sie Schülern bei ihren Studien, indem Sie AutoGPT als virtuellen Lernbegleiter einsetzen.
• E-Mail-Verwaltung : Rationalisieren Sie Ihren Posteingang, indem Sie AutoGPT beauftragen, E-Mails zu sortieren, wichtige Nachrichten zu kennzeichnen und automatisch auf Routineanfragen zu antworten.
• Simulation und Modellierung : Verbessern Sie Ihr Verständnis komplexer Systeme, indem Sie die Fähigkeit von AutoGPT nutzen, verschiedene Szenarien zu simulieren und zu analysieren.

Indem Sie AutoGPT in Ihre Arbeit integrieren, können Sie neue Möglichkeiten erschließen und Ihre Projekte auf die nächste Stufe heben. Legen Sie noch heute los und entdecken Sie die erstaunlichen Vorteile, die auf Sie warten!

Empfohlen (Englisch): The Evolution of Large Language Models (LLMs): Insights from GPT-4 and Beyond

As a Python developer, you might have encountered the terms async and await, wondering what they are and how to use them in your projects.

Async functions enable you to write concurrent code using the async/await syntax. This powerful duo allows you to perform multiple tasks simultaneously without blocking the execution of your code. Think of it as having multiple browser tabs open; while one page loads, you can continue browsing other tabs. This capability means your Python applications can become faster, more efficient, and capable of handling many I/O operations.

To get started with async functions, you’ll need to get acquainted with Python’s asyncio library, which serves as a foundation for numerous asynchronous frameworks such as high-performance network and web servers, database connection libraries, and distributed task queues.

Mastering async functions can truly elevate your Python programming skills and help you build powerful and responsive applications.

Python Async Function Basics

First, you’ll learn the basics of Python async functions, which can help improve the performance of your asynchronous programming.

We’ll cover

• async functions without await,
• an async function example, async function return, and
• async function call.

Async Function Without Await

You might wonder if it’s possible to create an async function without using the await keyword. Well, it is!

However, without await, the async function becomes somewhat less useful, since you won’t be able to pause its execution and yield control back to the event loop.

This means your async code will not be able to achieve cooperative concurrency, and other coroutines might be stuck waiting for their turn to execute. It’s generally a good idea to use await when working with async functions for more efficient asynchronous programming.

Async Function Example

Let’s dive into a simple example of using an async function in Python with asyncio:

import asyncio async def greet(name: str): print(f"Hello, {name}!") await asyncio.sleep(1) print(f"Nice to meet you, {name}!") async def main(): task1 = asyncio.create_task(greet("Alice")) task2 = asyncio.create_task(greet("Bob")) await task1 await task2 asyncio.run(main())

In this example, an async function greet is declared, which prints a greeting message, waits for 1 second using asyncio.sleep, and then prints another message.

The main asynchronous function creates two tasks to call greet with different names, running them concurrently.

Async Function Return

When you want to return a value from an async function, just use the return statement as you would in regular functions. However, keep in mind that the returned value will be wrapped in an asyncio.Future object, not the actual value.

You’ll need to use await to get the value when calling this async function.

For example:

async def calculate_result(): await asyncio.sleep(1) return "Result!" async def main(): result = await calculate_result() print(result) asyncio.run(main())

Here, calculate_result is an async function that returns a value after asynchronously waiting for 1 second. In the main() function, you can use await to get the actual value and print it.

Async Function Call

To call an async function, you can’t simply use the normal function call syntax, because doing so would just return a coroutine object, not the actual result of the function. Instead, you have to use the await keyword to call the async function, or use asyncio.create_task or similar functions to run it concurrently:

# Using `await` to call async function
result = await async_function() # Using `asyncio.create_task` to run concurrently
task = asyncio.create_task(async_function())

Remember to always use the appropriate method to call your async functions in order to achieve efficient asynchronous programming with Python’s powerful async/await syntax.

Advanced Async Function Concepts

Next, you’ll explore advanced async function concepts to give you a better understanding of how they work in Python. Ready? Let’s dive in!

Async Function Decorator

To create an async function, you’ll use the async def syntax. This means you don’t have to use a decorator, but you can still decorate asynchronous functions with the @some_decorator syntax for better modularity in your programs.

For instance, consider using @asyncio.coroutine with a yield from syntax if you’re working with Python 3.4 or earlier. Or simply upgrade to newer versions!

Async Function Type Hint

Type hints help improve the readability of your async code. Specify the input and output types of your async function using the typing module’s Coroutine and asyncio‘s Future objects.

Here’s an example:

from typing import Coroutine
import asyncio async def some_async_function() -> Coroutine[str]: await asyncio.sleep(1) return "done"

Async Function Returns Coroutine

An async function, also known as a coroutine, returns a coroutine object when called. You can use it as a direct call or pass it to an event loop to run the async function using asyncio.run() or loop.run_until_complete().

Keep in mind coroutine objects aren’t executed until you explicitly use an event loop or an await expression.

Async Function Await

When writing async functions, the await keyword is crucial. It allows you to pause the execution of a coroutine and wait for a result without blocking other coroutines.

You’ll often use await with I/O-bound operations, like reading from files, interacting with network services, or retrieving resources, which can take a significant amount of time.

Recommended: Python __await()__ Magic Method

Async Function Type

An async function’s type is coroutine. So when defining your async function, you’re essentially creating a non-blocking function that allows other functions to run while it waits for results.

To check if an object in Python is a coroutine, you can use inspect.iscoroutine(obj) or inspect.iscoroutinefunction(obj).

Async Function Return Type

Async functions return a coroutine object, but you can also specify the type of the eventual returned value. For instance, if your async function performs some networking tasks and returns JSON data, you can specify the return type as Dict[str, Any].

Here’s how you do that:

from typing import Dict, Any, Coroutine
import asyncio async def fetch_json_data() -> Coroutine[Dict[str, Any]]: # some networking tasks here await asyncio.sleep(2) return {"key": "value"}

Async Function in Different Contexts

In this section, we will explore using async functions in different circumstances, such as within classes, threads, and converting async functions to sync. We will also discuss the concepts of async function sleep and handling functions that were never awaited.

Async Function in Class

When working with classes in Python, you might want to include asynchronous methods. To achieve this, just define your class method with async def. Remember to await your async methods when calling them to ensure proper execution.

Here’s an example:

class MyClass: async def my_async_method(self): await asyncio.sleep(1) async def main(): my_obj = MyClass() await my_obj.my_async_method()

Async Function in Thread

Running async functions in a thread can be tricky due to event loop requirements. Use asyncio.to_thread() for running async functions in threads. This will ensure your async function is executed within the correct thread’s event loop.

For example:

async def my_async_function(): await asyncio.sleep(1) print("Hello from async function!") async def main(): result = await asyncio.to_thread(my_async_function)

Async Function to Sync

If you need to call an async function from synchronous code, you can use asyncio.run() or create an event loop that runs a given coroutine.

Here’s an example of how to run an async function from sync code:

def sync_function(): asyncio.run(my_async_function())

Async Function Sleep

Sometimes, you might want to introduce a delay in your coroutine using asyncio.sleep. This allows other coroutines to run while waiting for IO operations or other events.

Example:

async def delayed_hello(): await asyncio.sleep(1) print("Hello after 1 second!")

Recommended: Time Delay in Python

Async Function Was Never Awaited

In some cases, you may forget to await an async function, which leads to warnings such as "coroutine 'my_async_function' was never awaited."

To prevent these issues, always ensure you’re using await when calling async functions:

async def my_async_function(): await asyncio.sleep(1) async def main(): # Missing 'await' would lead to a warning await my_async_function()

If you got something out of this article, I’m sure you’ll learn something of this one:

Recommended: Python Async With Statement — Simplifying Asynchronous Code

I promise it has more beautiful pics.

If you’re looking for AI assistants that can help you with writing, coding, or even education, you’re in luck!

This article introduces 11 alternative and mostly open-source tools, each offering a unique set of features tailored to a different use case. By diving into these resources, you’ll discover new ways to make the most of AI in your everyday life.

Some noteworthy alternatives include Bard for writing, Codex for coding, and Duolingo Max for language learning.

LLaMA

Are you looking for a ChatGPT alternative? Look no further than Meta’s LLaMA (Language Model Augmented Machine). Initially, LLaMA was designed as a text generator, but it also works well as a chatbot. It is a versatile language model pretrained on billions of texts from the internet and fine-tuned to provide accurate, intelligent responses.

To use this alternative, you need intermediate-level programming skills, and it’s important to have the right hardware setup such as a powerful GPU. You can run a version of LLaMA, the LLaMa-13b model, on your local machine. For details on how to set it up, read this guide.

Regarding performance in natural language processing tasks, LLaMA-13b is highly capable . It tries to produce content like poetry and stories, much like ChatGPT or OpenAI’s GPT-3 and GPT-4 models. How it behaves, though, depends on the specific tuning you apply during its setup.

LLaMA supports multiple languages, providing a bilingual or multilingual experience for users. However, if your focus is on a particular language, there are other ChatGPT alternatives you could consider like Jasper Chat.

Consider trying out LLaMA for your AI chatbot or text generation needs. Remember, though, it may require more coding and technical skills than some other alternatives.

Ressources: Read the paper “LLaMM: Open and Efficient Foundation Language Models” and check out the GitHub

Alpaca

Yeah, the naming has gotten pretty obscure in the open-source large language model (LLM) community.

Short Summary: Instruction-following models like GPT-3.5 and ChatGPT are powerful but have flaws. Academia faces challenges in researching these models due to limited access.

Stanford researchers fine-tuned Alpaca, a language model based on Meta’s LLaMA 7B, using 52K instruction-following demonstrations from text-davinci-003.

Alpaca is small, easy to reproduce, and shows similar behaviors to text-davinci-003. The team is releasing their training recipe and data, with plans to release model weights and an interactive demo for academic research.

Commercial use is prohibited due to licensing restrictions and safety concerns.

Image credit

Alpaca is a remarkable chatbot alternative to ChatGPT that you can explore. Developed by Stanford researchers, it was fine-tuned using Facebook’s LLaMA to deliver impressive language capabilities source.

This chatbot has the potential to enhance your SEO efforts, as it’s able to reason , answer questions, and tell jokes, among other things. By integrating Alpaca into your online projects, you can engage users and attract search engine attention on platforms like Google and Bing .

And it’s free and open-source!

Here’s an example run from the original launch website:

There are also other open-source alternatives to ChatGPT that you may find useful, such as GPT4All, Dolly 2, and Vicuna . You can find Python code to run these models on your system in this tutorial.

Vicuna

Vicuna-13B, an open-source AI chatbot, is among the top ChatGPT alternatives available today. Its impressive feature parity with OpenAI’s ChatGPT and Google’s Bard has made it a popular choice for those seeking a capable language model.

Research Paper: “GPTQ: ACCURATE POST-TRAINING QUANTIZATION FOR GENERATIVE PRE-TRAINED TRANSFORMERS”

What sets Vicuna apart is its ability to write code even though it is very concise and can run on your single-GPU machine (GitHub), which is less common in other open-source LLM chatbots . This unique feature, along with its more than 90% quality rate, makes it stand out among ChatGPT alternatives.

Reference: Original Website

Don’t worry about compatibility, as Vicuna is available for use on your local machine or with cloud services like Microsoft’s Azure, ensuring you can access and collaborate on your writing projects wherever you are.

With Vicuna, you can expect the AI chatbot to deliver text completion tasks such as poetry, stories, and other content similar to what you would find on ChatGPT or Youchat. Thanks to its user-friendly interface and robust feature set, you’ll likely find this open-source alternative quite valuable.

OpenChatKit

OpenChatKit is one of the ChatGPT alternatives worth exploring!

Official OpenChatKit Website (open-source)

Developed by Together Computer, OpenChatKit is an open-source variant of ChatGPT, providing users and developers the flexibility to tailor chatbot behavior to suit their specific needs.

You can use it online here in interactive mode — I tried it myself:

If you’re a coder or developer, you’ll appreciate OpenChatKit’s compatibility with Python, allowing for seamless integration into your projects. You can also use it with GitHub Copilot to enhance your coding experience, thanks to the open-source nature of the project.

OpenChatKit caters to a broader audience since the open-source design allows access to users and groups that might not have the means to use proprietary models. It supports functions such as reasoning and multi-tasking, giving you an extensive range of applications to use within your projects.

It can also code:

GPT4ALL

GPT4ALL is an interesting alternative to ChatGPT that you might want to explore .

It is a community-driven project aimed at offering similar capabilities to those of ChatGPT through the use of open-source resources .

The project is trained on a massive curated collection of written texts, which include assistant interactions, code, stories, descriptions, and multi-turn dialogues (source).

Recommended: GPT4All Quickstart – Offline Chatbot on Your Computer

By choosing GPT4ALL as an alternative, you can access various resources such as:

• Datasets
• Model weights
• Data curation processes

Getting Started with GPT4ALL

To get started, you’ll need to familiarize yourself with the project’s open-source code, model weights, and datasets. Information related to the project can be found through its project link provided in the search results.

Again, check out our detailed article on setting up GPT4ALL:

Recommended: GPT4All Quickstart – Offline Chatbot on Your Computer

What to Expect from GPT4ALL

While GPT4ALL may not match ChatGPT in terms of exact performance, it is a strong contender when it comes to providing a similar experience. Plus, it offloads some of the computational requirements associated with ChatGPT, possibly making it a more efficient option for you.

BlinkDL RWKV

Looking for a faster, more VRAM-efficient alternative to ChatGPT? Raven RWKV is an open-source chatbot that may just suit your needs! Developed by BlinkDL, this chatbot is powered by the RWKV language model which uses Recurrent Neural Networks (RNNs) to achieve high-quality results similar to ChatGPT, but with better processing speed and lower hardware requirements .

“RWKV is an RNN with transformer-level LLM performance. It can be directly trained like a GPT (parallelizable). So it’s combining the best of RNN and transformer – great performance, fast inference, saves VRAM, fast training, “infinite” ctx_len, and free sentence embedding.” (source)

You’ll find that the Raven RWKV model has been fine-tuned on various datasets like Stanford Alpaca, code-alpaca, and more, offering an impressive performance with diverse conversation topics . It has even managed to match the quality and scaling capabilities of transformer models, all while requiring less VRAM .

You can check out an example run here:

If you’re eager to get started with Raven RWKV, head over to its Hugging Face repository for more details and relevant resources . Here, you’ll find different models like RWKV-4-Pile, which have been fine-tuned on diverse data sources to cater to various language preferences .

In short, the Raven RWKV chatbot is an excellent choice if you seek to explore an open-source chatbot alternative that balances performance and resource consumption .

StableLM (Stability-AI)

StableLM is an open-source alternative to ChatGPT developed by Stability AI. With its goal to provide a transparent and scalable AI language model, it’s perfect for anyone looking to explore options outside of proprietary tools.

Based on a dataset called “The Pile,” StableLM aims to offer a powerful language-processing solution. You can access StableLM in its alpha form on GitHub with 3 billion and 7 billion parameter model options. This means you have the flexibility to choose the model that fits your project best.

As you start working with StableLM, you’ll experience:

• A solution that rivals ChatGPT in terms of performance and capabilities
• Alpha access, allowing you to get your hands on the technology early
• A GitHub-based platform for easy use and integration with your projects

When trying it on the Hugging Face interface, however, I experienced that it’s still super slow. This is probably a problem of the server infrastructure though:

Remember, as with any open-source project, StableLM is ever-evolving. This means you have the opportunity to be a part of its development and contribute to the progress of the technology.

KoboldAI

KoboldAI is a fantastic alternative to ChatGPT that you might want to try out . It’s an open-source AI-powered chatbot capable of generating human-like text based on your prompts. You can find the source code and development updates on their GitHub repository.

Here’s an example run:

 Bot : Hey!
💻 You : Hey Boyname, how have you been?
🤖 Bot : Been good! How about you?
💻 You : Been great to, excited to try out KoboldAI
🤖 Bot : KoboldAI is really fun!
💻 You : For sure! What is your favorite game?

When using KoboldAI, you’ll appreciate its easy-to-use interface that keeps things simple and clean . Setting up the program may take a few steps, as you need to follow the instructions on their GitHub page. But worry not, they provide clear guidelines to make it easy for you .

In fact, it’s one of the most comprehensive README pages on an AI GitHub repository I have ever seen.

The AI behind KoboldAI is driven by various pre-trained models, which give you options to find the perfect balance between performance and quality. You can experiment with different models to see which one fits your needs best .

KoboldAI is focused on providing you with a chatbot experience that’s constantly improving. The active community of developers and users helps ensure that updates and bug fixes are addressed swiftly .

Flan-T5-XXL

Meet Flan-T5-XXL, an impressive open-source language model that serves as an alternative to ChatGPT. Developed by Google, Flan-T5-XXL is an enhanced version of the T5 language model and excels in few-shot learning tasks.

Flan-T5-XXL benefits from instruction fine-tuning, a technique that improves model performance and generalization to unseen tasks. By leveraging this technique, you can expect better outcomes from Flan-T5-XXL compared to traditional language models.

This model stands out in applications involving multi-turn dialogues. Thanks to its Baize implementation, which mitigates potential risks by leveraging ChatGPT to facilitate conversations with itself, Flan-T5-XXL offers higher-quality results.

Usage

To get started with Flan-T5-XXL, you can access its model card for details on available features and implementation. Make sure to watch this YouTube video for code examples and optimization tips:

And for further comparison with other language models, you can refer to this SourceForge comparison between ChatGPT, Flan-T5, and Visual ChatGPT.

Keep in mind that the open-source nature of Flan-T5-XXL offers a unique advantage because it is free to use—unlike its proprietary counterpart, ChatGPT. To make an informed decision, compare the functionality of the Flan-T5-XXL and ChatGPT based on your specific needs.

For instance, I found that it’s not too advanced, GPT-4 would have figured this problem out:

By exploring Flan-T5-XXL as an alternative to ChatGPT, you can gain access to a powerful, open-source language model that offers diverse functionalities and improved performance. Happy experimenting!

MiniGPT

MiniGPT is a lighter version of ChatGPT that you can use for various tasks. It’s perfect for those who need a simpler AI chatbot for straightforward tasks . In this section, you’ll discover a few alternatives to MiniGPT.

Recommended: MiniGPT-4: The Latest Breakthrough in Language Generation Technology

This neural network model has been developed to improve vision-language comprehension by incorporating a frozen visual encoder and a frozen large language model (LLM) with a single projection layer.

MiniGPT-4 has demonstrated numerous capabilities similar to GPT-4, like generating detailed image descriptions and creating websites from handwritten drafts.

One of the most impressive features of MiniGPT-4 is its computation efficiency. Despite its advanced capabilities, this model is designed to be lightweight and easy to use. This makes it an ideal choice for developers who need to generate natural language descriptions of images but don’t want to spend hours training a complex neural network.

Image source: https://github.com/Vision-CAIR/MiniGPT-4

Additionally, MiniGPT-4 has been shown to have high generation reliability, meaning that it consistently produces accurate and relevant descriptions of images.

Google Bard

Google Bard is one of the top alternatives to ChatGPT you can try.

Built as Google’s response to ChatGPT, it utilizes a combination of two Language Models for Dialogue (LLMs) to create an engaging conversational experience (source). Offered by the search engine giant, you can expect some powerful AI capabilities from Bard. With Bard, you can enjoy a more dynamic way of searching for answers to various queries (source).

Image Credits: https://blog.google/technology/ai/bard-google-ai-search-updates/

To try Google Bard, visit the following link and sign up for access: Google Bard

Here are some key features of Google Bard:

• It is an experimental AI conversational service, powered by Google’s LAMDA technology (source).
• Ideal for providing quick help with tasks like cover letter writing, event planning, and other needs you might have.(source).
• Google Bard excels in precision and ease of use, making it a reliable alternative for those looking for a powerful AI chatbot.

Some More Resources

First, there’s GitHub Copilot, an LLM-based AI tool specifically designed to help coders increase their productivity.

Another remarkable choice is Character.AI, which focuses on natural language understanding and generation. It’s excellent for creating realistic conversations with virtual characters.

You should also consider YouChat as an alternative. It’s a powerful AI chatbot that helps you automate customer support and social media interactions.

Don’t miss Socratic, as it’s designed to assist you with educational content. You can ask questions and receive detailed explanations in various subjects.

Next up is JasperChat. It’s a valuable tool for businesses looking to simplify their customer service and sales processes using AI chatbot technology.

Finally, WriteSonic is a worthy mention, especially if you need help with content writing tasks. It’s an AI-powered writing assistant that generates text for multiple purposes.

Okay, that’s it. Feel free to also download our free OpenAI cheat sheets such as this OpenAI Glossary:

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

Key Points

• The leaked document is titled “We Have No Moat, And Neither Does OpenAI.”
• It argues that open-source AI development is winning and that Google and other companies have no competitive advantage or “moat” in the field.
• The document suggests that Google and other companies should focus on building tools and infrastructure that support open-source AI development rather than trying to compete with it.
• The document provides a fascinating insight into the state of AI development and the challenges facing companies like Google as they try to stay ahead of the curve.
• Open-source development is unstoppable and has never been more alive!

Diving Into the Document

A leaked Google document titled “We Have No Moat, And Neither Does OpenAI” has recently garnered attention. Shared anonymously on a public Discord server, the document comes from a Google researcher and offers a frank analysis of the AI development landscape.

The document contends that open-source AI development is prevailing, leaving Google and other companies without a competitive edge.

Considering Google’s status as an AI leader and its substantial investments, this is a notable claim.

Quote: “But the uncomfortable truth is, we aren’t positioned to win this arms race and neither is OpenAI. While we’ve been squabbling, a third faction has been quietly eating our lunch.”

Here are some interesting developments in the open-source community:

• Offline Fast LLMs: As reported in a recent Finxter article, many large language models can now be run offline. A Twitter user even shared how he ran a foundation model on a Pixel 6 at 5 tokens per second speed!
• Scalable Personal AI: Projects like Alpaca-Lora allow you to fine-tune a personalized AI on your notebook in a couple of hours.
• Multimodality: Researchers release new multimodal models that are trained in less than one hour and are freely available via GitHub. Here‘s the paper.
• Responsible Release: You can find a list of pre-trained LLMs for textual data generation on myriads of new websites. Other websites now share generative art models, generated by Midjourney or DALL-E, without restrictions. See an example here:

source

The researcher suggests that instead of competing with open-source AI, Google and other companies should concentrate on creating tools and infrastructure to support it. This strategy would ensure rapid AI advancements and widespread benefits.

Check out this wonderful analysis from the article:

Quote: “Many of the new ideas are from ordinary people. The barrier to entry for training and experimentation has dropped from the total output of a major research organization to one person, an evening, and a beefy laptop.”

The leak has sparked significant debate within the AI community, with some criticizing Google for not adequately supporting open-source AI and others lauding the company for recognizing its own limitations.

LoRA – An Innovation Worth Keeping In Mind

Low-Rank Adaptation of Large Language Models (LoRA) is a powerful technique we should focus on more.

LoRA works by simplifying model updates, making them much smaller and faster to process. This allows us to improve a language model quickly on regular computers, which is great for adding new and diverse information in real-time. Even though this technology could help Google’s ambitious projects, it’s not used enough.

Retraining models from scratch is difficult and time-consuming.

LoRA is effective because it can be combined with other improvements, like instruction tuning. These improvements can be added on top of each other to make the model better over time without needing to start from scratch.

This means that when new data or tasks become available, the model can be updated quickly and cheaply. On the other hand, starting from scratch wastes previous improvements and becomes very expensive.

We should think carefully about whether we need a new model for every new idea. If we have major improvements that make reusing old models impossible, we should still try to keep as much of the previous model’s abilities as possible.

I couldn’t resist adding this interesting quote from the article:

Quote: “LoRA updates are very cheap to produce (~$100) for the most popular model sizes. This means that almost anyone with an idea can generate one and distribute it. Training times under a day are the norm. At that pace, it doesn’t take long before the cumulative effect of all of these fine-tunings overcomes starting off at a size disadvantage. Indeed, in terms of engineer-hours, the pace of improvement from these models vastly outstrips what we can do with our largest variants, and the best are already largely indistinguishable from ChatGPT. Focusing on maintaining some of the largest models on the planet actually puts us at a disadvantage.”

Timeline of LLM Developments (Overview)

Feb 24, 2023 – Meta launches LLaMA, an open-source code with various model sizes.

March 3, 2023 – LLaMA is leaked, allowing anyone to experiment with it.

March 12, 2023 – Artem Andreenko runs LLaMA on a Raspberry Pi.

March 13, 2023 – Stanford releases Alpaca, enabling low-cost fine-tuning of LLaMA.

March 18, 2023 – Georgi Gerganov runs LLaMA on a MacBook CPU using 4-bit quantization.

March 19, 2023 – Vicuna, a cross-university collaboration, achieves “parity” with Bard at $300 training cost.

March 25, 2023 – Nomic creates GPT4All, an ecosystem for models like Vicuna, at $100 training cost.

March 28, 2023 – Open Source GPT-3 by Cerebras outperforms existing GPT-3 clones.

March 28, 2023 – LLaMA-Adapter introduces instruction tuning and multimodality with just 1.2M learnable parameters.

April 3, 2023 – Berkeley launches Koala, users prefer it or have no preference 50% of the time compared to ChatGPT.

April 15, 2023 – Open Assistant launches a model and dataset for Alignment via RLHF, achieving near-ChatGPT human preference levels.

Recommended: 6 New AI Projects Based on LLMs and OpenAI

Competing with Open-Source is a Losing Game

I strongly believe in the power of open-source software development — we should build Bazaars not Cathedrals!

Open-source AI development is a better approach than closed-source AI development, particularly when considering the potential of Artificial General Intelligence (AGI). The open-source approach fosters collaboration, accessibility, and transparency, while promoting rapid development, preventing monopolies, and ensuring many benefits.

Here are a few reasons why I think open-source AI development should win in the long-term:

Collaboration is key in open-source AI, as researchers and developers from diverse backgrounds work together to innovate, increasing the likelihood of AGI breakthroughs.

Open-source AI is accessible to anyone, regardless of location or financial resources, which encourages a broader range of perspectives and expertise.

Transparency in open-source AI allows researchers to address biases and ethical concerns, fostering responsible AI development.

By building upon existing work, developers can rapidly advance AI technologies, bringing us closer to AGI.

Open-source AI also reduces the risk of single organizations dominating the AI landscape, ensuring that advancements serve the greater good.

Additionally, the benefits of AI are more evenly distributed across society through open-source AI, preventing the concentration of power and wealth.

Lastly, open-source AI development improves the security of AI systems, as potential flaws can be discovered and fixed by a larger community of researchers and developers.

Let’s end this article with another great quote from the article:

Quote: “Google and OpenAI have both gravitated defensively toward release patterns that allow them to retain tight control over how their models are used. But this control is a fiction. Anyone seeking to use LLMs for unsanctioned purposes can simply take their pick of the freely available models.”

Feel free to share this article with your friend and download our OpenAI Python API Cheat Sheet and the following “Glossary” of modern AI terms:

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

Real estate is the largest asset class in the world. The market cap of all real estate is said to be north of $327 trillion (!) USD. Bitcoin, on the other hand, is tiny in comparison and trades at roughly $0.5 trillion USD at the time of writing.

However, many real estate investors buy real estate as a store of value to protect themselves from the inflation produced by the fiat system. However, billionaire investors such as Michael Saylor argue that Bitcoin is a far better and far more scarce store of value than real estate.

There are billions of houses but only 21 million Bitcoin — let that sink in.

	Store of Value	Medium of Exchange	Unit of Account
Bitcoin
Real Estate

• Store of Value: Unlike real estate, Bitcoin is truly scarce — new houses can be built at will, but Bitcoin has a hard supply limit of 21 million.
• Medium of Exchange: Bitcoin can be transferred easily whereas real estate is highly illiquid and has significant friction costs when sold.
• Unit of Account: Bitcoin provides a full ledger system that has perfect predictability and, thereby, it is a much better unit of account than houses.

In this post, I’ll explore Bitcoin’s most crucial, specific advantages over real estate.

Disclaimer: While we consider every point on this list true, we are not financial advisors and this should not be considered financial advice.

Reason #1 – Portability

Bitcoin can be easily transferred anywhere in the world, while real estate is limited to a specific location.

Reason #2 – Liquidity

Bitcoin can be bought and sold in an instant, while selling real estate can take months or even years.

Reason #3 – Accessibility

Bitcoin can be bought with a few clicks on a smartphone, while buying real estate requires significant capital and legal processes.

Reason #4 – Transparency

Bitcoin transactions are recorded on a public ledger, providing transparency and security, while real estate transactions can be opaque and subject to fraud.

Reason #5 – Security

Bitcoin is stored in digital wallets that can be easily secured with encryption, while real estate requires physical security measures. Nobody can take your Bitcoin without your cooperation. But many could take your real estate!

Reason #6 – Divisibility

Bitcoin can be divided into small fractions, making it more accessible to smaller investors, while real estate requires significant capital investment.

Reason #7 – Inflation hedge

Bitcoin has a limited supply, making it a good hedge against inflation, while real estate can be affected by inflation.

Recommended: The Bitcoin Valuation Thesis

Reason #8 – Low transaction fees

Bitcoin transactions have lower fees than real estate transactions, which can have high closing costs.

Reason #9 – No intermediaries

Bitcoin transactions can be done peer-to-peer without intermediaries, while real estate transactions require intermediaries such as real estate agents and lawyers.

Reason #10 – Accessibility to global markets

Bitcoin can be easily traded on global markets, while real estate investment is limited to local markets. For example, Bitcoin is accessible to Nigerian farmers who cannot invest in New York prime real estate.

Reason #11 – No maintenance costs

Bitcoin does not require maintenance costs, while real estate requires ongoing maintenance and repairs.

Reason #12 – No property taxes

Bitcoin does not require property taxes, while real estate is subject to property taxes.

Reason #13 – No zoning restrictions

Bitcoin is not subject to zoning restrictions, while real estate is subject to zoning regulations.

Reason #14 – No mortgage payments

Bitcoin does not require mortgage payments, while real estate requires ongoing mortgage payments.

Reason #15 – No tenant issues

Bitcoin does not require dealing with tenant issues, while real estate investment requires dealing with tenants and property management.

Reason #16 – No depreciation

Bitcoin does not depreciate in value, while real estate can depreciate over time.

Reason #17 – No insurance costs

Bitcoin does not require insurance costs, while real estate requires insurance coverage.

Reason #18 – No legal disputes

Bitcoin transactions are irreversible, reducing the likelihood of legal disputes, while real estate transactions can be subject to legal disputes, such as property disputes and contract disputes.

Reason #19 – No inspection costs

Bitcoin does not require inspection costs, while real estate requires inspection costs before purchase.

Reason #20 – No closing costs

Bitcoin transactions do not require closing costs, while real estate transactions can have significant closing costs.

Reason #21 – No need for physical presence

Bitcoin can be bought and sold remotely, while real estate transactions often require physical presence.

Reason #22 – No need for financing

Bitcoin can be bought with cash, while real estate often requires financing through loans.

Reason #23 – No need for credit checks

Bitcoin transactions do not require credit checks, while real estate transactions often require credit checks for financing.

Reason #24 – No need for appraisals

Bitcoin transactions do not require appraisals, while real estate transactions often require appraisals before purchase.

Reason #25 – No need for property inspections

Bitcoin transactions do not require property inspections, while real estate transactions often require property inspections before purchase.

Reason #26 – No natural disaster risks

Bitcoin is not subject to natural disaster risks, while real estate can be affected by natural disasters such as floods and earthquakes.

Reason #27 – No environmental risks

Bitcoin does not have environmental risks, while real estate can be affected by environmental hazards such as pollution and toxic waste.

Reason #28 – No eminent domain risks

Bitcoin is not subject to eminent domain risks, while real estate can be subject to government seizure for public use.

Reason #29 – No zoning changes

Bitcoin is not subject to zoning changes, while real estate can be affected by changes in zoning regulations.

Reason #30 – No need for property management

Bitcoin does not require property management, while real estate investment requires property management and maintenance.

Recommended: 11 Best Bitcoin Books: Your Ultimate Guide for 2023

Bitcoin is still the king and number one crypto asset and a revolutionary decentralized technology that will outlast all of us and all of our institutions.

One of the best ways to gain insight into the world of bitcoin and cryptocurrencies is by reading books on the subject. These books provide invaluable information, covering everything from the history and mechanics of Bitcoin to investment strategies and future prospects.

I’ve spent countless hours researching and comparing various bitcoin books to help you find the best options that cater to a range of interests and knowledge levels.

No affiliate or sponsored links on this page! So you can trust that the book recommendations are genuine.

So, let’s get started with my top picks — the last book on the list should be much more popular in my opinion! I love it! The first two, however, are my top pics!

Softwar: A Novel Theory on Bitcoin

This book is a must-read for those who want to broaden their perspective on the strategic significance of Bitcoin.

Pros

• Comprehensive insights on Bitcoin’s future potentials
• Engaging writing style
• Carefully structured chapters

Cons

• Some readers might find parts hard to digest
• Not suitable for casual reading
• May require background knowledge

In “Softwar: A Novel Theory on Power Projection and the National Strategic Significance of Bitcoin,” author Jason Lowery combines an engaging writing style with a wealth of thought-provoking insights. As you delve into the content, you’ll appreciate how the chapters build upon themselves to help you better understand Bitcoin’s potential impact on the world stage.

The depth and breadth of the topics covered in this book are truly impressive, as they offer a rare glimpse into the diverse possibilities and implications of Bitcoin’s future development. While reading, you can’t help but feel eager to explore more about this rapidly evolving digital currency.

However, it’s worth noting that “Softwar” may not be for everyone. Some sections may require extra effort to fully digest, and a casual reader might find it challenging to keep up with the dense material. Additionally, the book assumes a certain level of background knowledge about Bitcoin, which might make it harder for newcomers to the subject.

“Softwar: A Novel Theory on Power Projection and the National Strategic Significance of Bitcoin” is an enlightening read for those who truly want to understand the wider implications of this revolutionary digital asset. If you’re prepared to commit time and effort to gain a deeper understanding of Bitcoin’s potential, this book will undoubtedly expand your horizons.

The Bitcoin Standard

This is a must-read for those seeking to learn about bitcoin’s potential to transform traditional financial systems. Evidently, The Bitcoin Standard has “orange-pilled” more people than any other book!

Pros

• Comprehensive understanding of bitcoin and its potential
• Intriguing historical context of money and economics
• Easy to comprehend language for different audiences

Cons

• May contain some factual inaccuracies
• Can seem overly opinionated at times
• Oversimplification of complex monetary systems

The Bitcoin Standard comes off as an insightful resource for understanding the concept of Bitcoin as a decentralized alternative to central banking. The first few paragraphs give a thorough overview of the technology behind Bitcoin, helping you grasp its significance and potential to revolutionize the financial world.

In addition to exploring Bitcoin’s technological aspects, the book delves into the history of money and economics, enhancing your overall knowledge of the subject matter. It allows you to see how Bitcoin fits into the broader narrative of the evolution of money, making connections you never knew existed.

However, it’s important to note that some readers have pointed out minor factual inaccuracies in the book. While these don’t completely undermine the book’s overall message and importance, it’s a good idea to approach it with a discerning mindset, cross-checking facts along the way.

Another hurdle for some readers might be the author’s pronounced opinions about certain topics. Although this adds character to the book, it can occasionally make the content seem one-sided, taking away from the reader’s ability to form their own opinion on Bitcoin and its potential.

Lastly, the book has received criticism for its oversimplification of complex monetary systems. While this can make it more digestible for readers with limited knowledge of the financial world, it can sometimes lead to misunderstandings or misconceptions about certain aspects of money and economics.

The Bitcoin Standard is an engaging and informative read for anyone interested in understanding the world of Bitcoin and its potential to disrupt traditional financial systems. Despite its drawbacks, the book offers valuable insights into the history of money and the role Bitcoin could play in the future of finance.

Bitcoin and Beef: Criticisms, Similarities, and Why Decentralization Matters

This book offers fascinating insight into the interconnectedness of Bitcoin and food systems, making it a compelling read.

Pros

• Provides valuable information on Bitcoin and the food industry
• Easy to understand for beginners
• Reveals the importance of decentralization

Cons

• Might lack depth for advanced readers
• Could be seen as connecting unrelated topics
• Some readers may find the writing style amateurish

“Bitcoin and Beef: Criticisms, Similarities, and Why Decentralization Matters” is an intriguing read that bridges the gap between cryptocurrency and food systems. You’ll find yourself drawn into the world of Bitcoin and beef, learning how they share similarities and why decentralization is essential in both areas.

As you dive into the book, you’ll appreciate the way it simplifies complex concepts, making them accessible even if you’re a novice in these topics. The author does an excellent job presenting factual information while keeping the text engaging and easy to follow.

However, if you’re already well-versed in Bitcoin or the food industry, you might find the book lacking depth in certain areas. Additionally, some readers might feel that connecting Bitcoin and beef is a stretch, making the content appear somewhat disjointed.

That being said, this book is undoubtedly an enlightening read for anyone interested in both the economic and social aspects of Bitcoin and food systems. It combines an easy-to-read style with valuable information that will challenge your preconceptions about these two seemingly unrelated topics.

“Bitcoin and Beef” is a fascinating journey into the world of decentralization that will leave you eager to explore more.

The Basics of Bitcoins and Blockchains

Dive into the world of cryptocurrencies with confidence through this comprehensive and easy-to-understand guide.

Pros

• Comprehensive and clear introduction
• Engaging and informative writing style
• Covers history, technology, and practical uses

Cons

• May seem lengthy for some readers
• Images are occasionally difficult to read
• Lacks an index

As you delve into the pages of “The Basics of Bitcoins and Blockchains,” you’ll find yourself captivated by the approachable and informative writing style that brings clarity to the often complex topics of cryptocurrencies and blockchain technology.

Whether you’re a beginner or already have some knowledge about the subject, this book serves as an excellent resource that will undoubtedly help you grasp essential concepts with ease.

However, it is not for Bitcoin maxis!

The book provides a solid foundation by explaining the history of banking systems and money, which sets the stage for understanding the value and importance of cryptocurrencies in today’s digital world. The author demonstrates expertise in the subject matter while maintaining simplicity and excitement, ensuring that you remain engaged throughout your reading journey.

However, some readers might find the book to be slightly lengthy or find certain images harder to read. Additionally, the lack of an index might be a drawback for those wanting quick reference points. Nevertheless, “The Basics of Bitcoins and Blockchains” merits its 4.5-star rating and its position as an excellent introduction to the world of cryptocurrencies.

If you’re eager to learn about the future of money and the technology driving it, “The Basics of Bitcoins and Blockchains” is a must-read that will leave you more knowledgeable and ready to embrace the world of digital assets.

Catching Up to Crypto: Your Guide to Bitcoin and the New Digital Economy

This comprehensive yet approachable guide is perfect for those looking to explore and understand the world of Bitcoin and its impact on the digital economy.

Pros

• In-depth introduction to Bitcoin and cryptocurrency
• Easy-to-understand explanations for beginners
• Insightful anecdotes and industry history

Cons

• Might be too basic for advanced users
• Limited focus on alternative cryptocurrencies
• No specific investment advice offered

Diving into “Catching Up to Crypto,” you’ll find this book eases your transition into the sometimes intimidating world of cryptocurrency. The author methodically breaks down complex concepts into understandable terms, accompanied by engaging anecdotes and a well-structured history of the industry.

As a beginner, you’ll have an enjoyable and enlightening experience as you explore the fascinating world of digital currencies.

While some prior knowledge of cryptocurrency may be helpful, it’s not essential, as the book covers nearly every aspect you need to understand. From the birth of Bitcoin to the potential future developments in the new digital economy, this guide serves as a comprehensive starting point.

The book delivers the necessary knowledge to participate in conversations and make informed decisions regarding your ventures into the crypto sphere.

However, it’s essential to consider that “Catching Up to Crypto” focuses primarily on Bitcoin and its role in shaping the modern financial landscape.

This may be perfect for newcomers, but experienced investors seeking in-depth information on alternative cryptocurrencies may require additional resources. Although the book provides a wealth of knowledge, direct investment advice is not offered.

If you’re seeking to educate yourself on the basics of Bitcoin and its influence on our digital economy, “Catching Up to Crypto” provides an engaging and accessible introduction. This book will leave you feeling confident about your ability to navigate this rapidly evolving space.

The Only Cryptocurrency Investing Book You’ll Ever Need

This beginner-friendly guide makes understanding and investing in cryptocurrency achievable for anyone seeking to enter the market.

Pros

• Comprehensive yet easy-to-understand
• Addresses various aspects of the crypto market
• Credible author with real-world experience

Cons

• Limited focus on practical applications of cryptocurrencies
• Might be too basic for seasoned investors
• May not cover all aspects of cryptocurrency investing

As a newcomer to the cryptocurrency world, you will benefit immensely from “The Only Cryptocurrency Investing Book You’ll Ever Need.”

The author does a fantastic job of breaking down complex concepts into digestible pieces of information, providing readers with a solid foundation of knowledge on the subject. From learning about the blockchain technology to understanding various digital assets’ value, this guide takes you through the important aspects of the ever-growing crypto space.

Again, this is not for Bitcoin maxis!

One particular advantage of this book is its ability to cater to absolute beginners. The author assumes no prior knowledge of the subject and explains concepts in simple, easy-to-understand language. As you progress through the pages, you’ll gain confidence and insights into how the cryptocurrency market operates, and be better prepared to make informed investment decisions.

However, as informative and engaging as this book is, it may not be suitable for seasoned investors or those with a deeper understanding of cryptocurrencies. The content may come across as too basic for some, but it still serves as a great refresher for anyone looking to brush up on their cryptocurrency knowledge.

“The Only Cryptocurrency Investing Book You’ll Ever Need” is an excellent introductory guide for beginners looking to understand and invest in the rapidly growing world of cryptocurrencies. While it may not cover every nuance of the market, it provides a strong foundation for further exploration and learning, setting you on the path to becoming a successful crypto investor.

Crypto for Beginners: A Simple Non-Technical Guide

An interesting read for crypto beginners who want a simple, non-technical guide to grasp the blockchain revolution and make a wise investment in cryptocurrency.

Pros

• Easy to understand language
• Covers blockchain and crypto investing basics
• Helpful for creating multi-generational wealth

Cons

• Might not cater to advanced crypto investors
• Limited to 204 pages of content
• Independent publication, not by a major publisher

Crypto for Beginners promises a non-technical guide to understanding the blockchain revolution and bolstering your crypto investing knowledge.

The book is written in simple, approachable language that makes it easy for you to grasp the concepts without getting bogged down in technical jargon. The author does a great job of breaking down the history and fundamental aspects of cryptocurrencies, allowing you to make informed decisions about your investments.

Despite being only 204 pages long, this book covers a wide range of topics, including the history of money, the technology behind cryptocurrencies, and practical tips for getting started in crypto investing. The content is engaging and will help you build the foundation you need to create multi-generational wealth through smart cryptocurrency investments.

However, if you’re already an experienced crypto investor, this book might not offer much new or advanced information.

Additionally, the book is published independently, which may raise some concerns about the credibility of the information for some readers.

Nevertheless, with a high rating of 4.8 stars and numerous positive reviews, it is clear that this guide has resonated with many beginners looking to enter the world of cryptocurrency investing.

Crypto for Beginners is a valuable resource for those new to the crypto space or those who want a simplified guide to the blockchain revolution. Although it may not address the needs of advanced investors, it’s worth considering, especially if you’re keen on creating a well-rounded, long-term investment strategy in cryptocurrency.

Blockchain Bubble or Revolution

A must-read for anyone looking to dive into the world of cryptocurrencies and blockchain technology.

Pros

• Easy-to-read for non-technical readers
• Balanced and unbiased approach
• Informative with clear examples

Cons

• Might be too basic for experts
• Limited in-depth technical coverage
• Could benefit from more in-depth case studies

Diving into the world of blockchain and cryptocurrencies can be intimidating, but “Blockchain Bubble or Revolution” manages to make the learning process engaging and accessible. You’ll find that the book breaks down complex concepts into digestible information, which is perfect if you are a beginner or someone without a technical background.

This book exceptionally presents a balanced and unbiased view of blockchain technology, truly exploring its potential while remaining cautious about over-hyped claims. You’ll appreciate the authors’ honesty as they share the pros and cons of using blockchain, and you’ll better understand its place in our modern world.

One downside might be that if you are already quite familiar with blockchain technology, you could find some portions of the book too basic. The book also might leave you wanting more when it comes to detailed technical explanations or in-depth case studies. However, this should not deter you if you are simply looking to familiarize yourself with the fundamentals of blockchain.

“Blockchain Bubble or Revolution” is an excellent starting point for anyone looking to learn about the future of Bitcoin, blockchains, and cryptocurrencies. The combination of non-technical language, engaging writing style, and a balanced perspective make it a must-read in your journey to understand this revolutionary technology.

A Beginner’s Guide To Bitcoin

A concise and informative read to help you kickstart your journey into the world of Bitcoin.

Pros

• Easy to understand
• Covers fundamentals and protection tips
• Written by a reputable author who is also a Bitcoin maxi

Cons

• Limited to 68 pages
• Geared towards a US audience
• Might be too basic for those with some Bitcoin knowledge

As a newcomer to the cryptocurrency scene, you’ll find that “A Beginner’s Guide To Bitcoin” simplifies complex concepts and makes them palatable for you.

The author, Matthew Kratter, has created an engaging guide that covers fundamental information about Bitcoin and how to protect your investment. Trust me, I benefited a lot from this knowledge, especially his YouTube channel “Bitcoin University”.

Although the guide is concise and easy to finish within just a couple of sittings, it’s primarily aimed at a US audience, which might not address some concerns for international readers. However, if you seek clarity and guidance, then this book is worth giving a shot.

“A Beginner’s Guide To Bitcoin” is an excellent starting point for anyone who wants to dip their toes into the world of cryptocurrency. By the time you turn the last page, you’ll be equipped with the essential knowledge and confidence to navigate the often-confusing world of Bitcoin. Happy investing!

Bitcoin Clarity: The Complete Beginners Guide to Understanding

A highly recommended read if you want to dive into the world of Bitcoin and understand its essence.

Pros

• Easy-to-understand language
• Comprehensive coverage of Bitcoin concepts
• Engaging explanations and visuals

Cons

• Some reported typos
• Might be a bit technical for complete beginners
• Physical book suggested for easier reference

Diving into the complex world of Bitcoin, you’ll find that “Bitcoin Clarity” makes the subject approachable and engaging. Written by Kiara Bickers, this audiobook not only provides high-level fundamentals but also helps you make informed decisions when purchasing Bitcoin.

Throughout your journey with this book, you’ll appreciate the variety of examples and visuals that the author employs to break down technical details. The book is aimed at beginners, but some readers might find it helpful to start with a basic understanding of digital currencies, as the content may lean towards the technical side.

One suggestion from readers is to get the hard copy of the book, which makes it easier to reference back to earlier chapters. There have also been mentions of a few typos in the book, but this does not take away from the valuable information it offers.

“Bitcoin Clarity” offers a thorough and engaging entrance into the world of digital currency. If you’re interested in understanding Bitcoin’s technical and practical aspects, this book will serve as a valuable resource.

Bitcoin: Hard Money You Can’t F*ck With: Why Bitcoin Will Be the Next Global Reserve Currency

“Bitcoin: Hard Money You Can’t F*ck With: Why Bitcoin Will Be the Next Global Reserve Currency” by Jason A. Williams is an insightful and thought-provoking book that explores the potential of Bitcoin as a global reserve currency.

The author argues that Bitcoin is “hard money” that cannot be manipulated by governments, central banks, or corporations, making it a safe and secure store of value.

The book provides a comprehensive overview of Bitcoin, including its history, technology, and potential uses. The author explains how Bitcoin emerged out of the 2008 banking crisis, and why money printing slowly destroys wealth. The book also covers the basics of money and currency, and how printing cash has historically led to the death of currency.

One of the strengths of the book is the author’s ability to explain complex concepts in a clear and concise manner. The book is accessible to readers with little or no prior knowledge of Bitcoin, and provides a great introduction to the topic. The author also includes practical advice on how to invest in Bitcoin, and how to store it securely.

“Bitcoin: Hard Money You Can’t F*ck With” is a must-read for anyone interested in the future of money and currency. The book is well-researched, engaging, and provides a compelling argument for why Bitcoin could become the next global reserve currency. I highly recommend this book to anyone looking to learn more about Bitcoin and its potential impact on the world.

We are designing a personal portfolio website using the Django web framework.

In the first part of this series, we learned how to create Django models for our database. We created an admin panel, and added ourselves as a superuser. I expect that by now you have used the admin panel to add your sample projects.

You are required to go through the first part of this series for you to follow along with us if you haven’t already done so. In this series, we will create a view function using the sample projects. By the end of this series, we will have created a fully functioning personal portfolio website.

The View Function

We can choose to use class-based views or function-based views, or both to create our portfolio website.

If you use class-based views, you must subclass it with Django’s ListView class to list all your sample projects. For a full sample project description, you must create another class and subclass it with Django’s DetailView class.

For our portfolio website, we will use function-based views so that you can learn how to query our database. Open the views.py file and write the following code:

from django.shortcuts import render
from .models import Project # Create your views here. def project_list(request): projects = Project.objects.all() context = { 'projects': projects } return render(request, 'index.html', context)

We import the Projects class and perform a query to retrieve all the objects in the table. This is a simple example of querying a database.

The context dictionary that contains the object is sent to the template file using the render() function. The function also renders the template, index.html. This tells us that all information available in the context dictionary will be displayed in the given template file.

This view function will only list all our sample projects. For a full description of the projects, we will have to create another view function.

def full_view(request, pk): project = Project.objects.get(pk=pk) context = { 'project': project } return render(request, 'full_view.html', context)

This view function looks similar to the previous one only that it comes with another parameter, pk. We perform another query to get an object based on its primary key. I will soon explain what is meant by primary key.

Template Files

We have to create two template files for our view functions. Then, a base.html file with Bootstrap added to make it look nice. The template files will inherit everything in the base.html file. Copy the following code and save it inside the templates folder as base.html.

<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous"> <nav class="navbar navbar-expand-lg navbar-light bg-light"> <div class="container"> <a class="navbar-brand" href="{% url 'index' %}">Personal Portfolio</a> <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation"> <span class="navbar-toggler-icon"></span> </button> <div class="collapse navbar-collapse" id="navbarSupportedContent"> <ul class="navbar-nav mr-auto"> <li class="nav-item active"> <a class="nav-link" href="{% url 'index' %}">Home</a> </li> </ul> </div> </div> </nav> <div class="container"> {% block content %}{% endblock %}
</div> <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js" integrity="sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49" crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js" integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy" crossorigin="anonymous"></script>

The a tag has a {% ... %} tag in its href attribute. This is Django’s way of linking to the index.html file. The block content and endblock tags inside the div tag is reserved for any template file inheriting from the base.html file.

As we will see, any template file inheriting from the base.html file must include such tags.

The Bootstrap files are beyond the scope of this article. Check the documentation to learn more.

Create the index.html file inside the template folder as indicated in the view function. Then, write the following script:

{% extends "base.html" %}
{% load static %}
{% block content %}
<h1>Projects Completed</h1>
<div class="row">
{% for project in projects %} <div class="col-md-4"> <div class="card mb-2"> <img class="card-img-top" src="{{ project.image.url }}"> <div class="card-body"> <h5 class="card-title">{{ project.title }}</h5> <p class="card-text">{{ project.description }}</p> <a href="{% url 'full_view' project.pk %}" class="btn btn-primary"> Read More </a> </div> </div> </div> {% endfor %}
</div>
{% endblock %}

The index.html file inherits the base.html as shown in the first line of the code. Imagine all the scripts we have to write to render hundreds or even thousands of sample projects! Once again, Django comes to the rescue with its template engine, for loops.

Using the for loop, we loop through all the projects (no matter how many they are) passed by the context dictionary. Each iteration renders the image (using the img tag), the title, the description and a link to get the full description of the project.

Notice that the a tag is pointing to a given project represented as project.pk. This is the primary key passed as a parameter in the second view function. More on that soon.

Again, notice the block content and the endblock tags. Since the index.html extends the base.html file, it will only display all that is found in the file. Any addition must be written inside the block content and endblock tags. Otherwise, it won’t be displayed.

Finally, the full_view.html file:

{% extends "base.html" %}
{% load static %}
{% block content %}
<h1>{{ project.title }}</h1>
<div class="row"> <div class="col-md-8"> <img src="{% project.image.url %}" alt="" width="100%"> </div> <div class="col-md-4"> <h5>About the project:</h5> <p>{{ project.description }}</p> <br> <h5>Technology used:</h5> <p>{{ project.technology }}</p> </div>
</div>
{% endblock %}

That’s all about our template files. Notice how everything is linked to our database model as we learned in the first part of this series. We retrieve data from the database, pass them to the view function, and render them in the template files.

We haven’t let Django know of an existing templates folder. Go to the settings.py file, under the TEMPLATES section. Register the templates folder there.

TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], #add these 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, },
]

Registering the URLs

We need to hook up our view functions to URLs. First is the project-level URL. Open the urls.py in the project folder, and add these:

from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static urlpatterns = [ path('admin/', admin.site.urls), path('', include('portfolio.urls')),
] if settings.DEBUG: urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

We register the file using the include() method. So, once we start the local server, and go to http://127.0.0.1:8000, we will see our home page which is the index.html file. Then, in the if statement, we tell Django where to find the user-uploaded images.

Next are the app-level URLs. Create a urls.py file in the portfolio folder.

from django.urls import path
from .views import project_list, full_view urlpatterns = [ path('', project_list, name='index'), path('<int:pk>/', full_view, name='full_view'),
]

The full_view URL is hooked up with a primary key. It is the same primary key in the templates file and in the second view function. This is an integer representing the number of each project. For the first project you added in the previous series, the URL will be http://127.0.0.1:8000/1

Hoping that everything is set, start the local server, and you will see everything displayed.

Conclusion

We have successfully come to the end of the second series of this project. The first series is here:

First Part: How I Designed a Personal Portfolio Website with Django

If you encounter errors, be sure to check the full code on my GitHub page. Our app is now running in the local server. In the final series of this project, we will see how we can deploy this to a production server.

Since I frequently handle textual data with Python , I’ve encountered the challenge of converting lists of strings into different data types time and again. This article, originally penned for my own reference, decisively tackles this issue and might just prove useful for you too!

Let’s get started!

Python Convert List of Strings to Ints

This section is for you if you have a list of strings representing numbers and want to convert them to integers.

The first approach is using a for loop to iterate through the list and convert each string to an integer using the int() function.

Here’s a code snippet to help you understand:

string_list = ['1', '2', '3']
int_list = [] for item in string_list: int_list.append(int(item)) print(int_list) # Output: [1, 2, 3]

Another popular method is using list comprehension. It’s a more concise way of achieving the same result as the for loop method.

Here’s an example:

string_list = ['1', '2', '3']
int_list = [int(item) for item in string_list]
print(int_list) # Output: [1, 2, 3]

You can also use the built-in map() function, which applies a specified function (in this case, int()) to each item in the input list. Just make sure to convert the result back to a list using list().

Take a look at this example:

string_list = ['1', '2', '3']
int_list = list(map(int, string_list))
print(int_list) # Output: [1, 2, 3]

For a full guide on the matter, check out our blog tutorial:

Recommended: How to Convert a String List to an Integer List in Python

Python Convert List Of Strings To Floats

If you want to convert a list of strings to floats in Python, you’ve come to the right place. Next, let’s explore a few different ways you can achieve this.

First, one simple and Pythonic way to convert a list of strings to a list of floats is by using list comprehension.

Here’s how you can do it:

strings = ["1.2", "2.3", "3.4"]
floats = [float(x) for x in strings]

In this example, the list comprehension iterates over each element in the strings list, converting each element to a float using the built-in float() function.

Another approach is to use the map() function along with float() to achieve the same result:

strings = ["1.2", "2.3", "3.4"]
floats = list(map(float, strings))

The map() function applies the float() function to each element in the strings list, and then we convert the result back to a list using the list() function.

If your strings contain decimal separators other than the dot (.), like a comma (,), you need to replace them first before converting to floats:

strings = ["1,2", "2,3", "3,4"]
floats = [float(x.replace(',', '.')) for x in strings]

This will ensure that the values are correctly converted to float numbers.

Recommended: How to Convert a String List to a Float List in Python

Python Convert List Of Strings To String

You might need to convert a list of strings into a single string in Python. It’s quite simple! You can use the join() method to combine the elements of your list.

Here’s a quick example:

string_list = ['hello', 'world']
result = ''.join(string_list) # Output: 'helloworld'

You might want to separate the elements with a specific character or pattern, like spaces or commas. Just modify the string used in the join() method:

result_with_spaces = ' '.join(string_list) # Output: 'hello world'
result_with_commas = ', '.join(string_list) # Output: 'hello, world'

If your list contains non-string elements such as integers or floats, you’ll need to convert them to strings first using a list comprehension or a map() function:

integer_list = [1, 2, 3] # Using list comprehension
str_list = [str(x) for x in integer_list]
result = ','.join(str_list) # Output: '1,2,3' # Using map function
str_list = map(str, integer_list)
result = ','.join(str_list) # Output: '1,2,3'

Play around with different separators and methods to find the best suits your needs.

Python Convert List Of Strings To One String

Are you looking for a simple way to convert a list of strings to a single string in Python?

The easiest method to combine a list of strings into one string uses the join() method. Just pass the list of strings as an argument to join(), and it’ll do the magic for you.

Here’s an example:

list_of_strings = ["John", "Charles", "Smith"]
combined_string = " ".join(list_of_strings)
print(combined_string)

Output:

John Charles Smith

You can also change the separator by modifying the string before the join() call. Now let’s say your list has a mix of data types, like integers and strings. No problem! Use the map() function along with join() to handle this situation:

list_of_strings = ["John", 42, "Smith"]
combined_string = " ".join(map(str, list_of_strings))
print(combined_string)

Output:

John 42 Smith

In this case, the map() function converts every element in the list to a string before joining them.

Another solution is using the str.format() method to merge the list elements. This is especially handy when you want to follow a specific template.

For example:

list_of_strings = ["John", "Charles", "Smith"]
result = " {} {} {}".format(*list_of_strings)
print(result)

Output:

John Charles Smith

And that’s it! Now you know multiple ways to convert a list of strings into one string in Python.

Python Convert List of Strings to Comma Separated String

So you’d like to convert a list of strings to a comma-separated string using Python.

Here’s a simple solution that uses the join() function:

string_list = ['apple', 'banana', 'cherry']
comma_separated_string = ','.join(string_list)
print(comma_separated_string)

This code would output:

apple,banana,cherry

Using the join() function is a fantastic and efficient way to concatenate strings in a list, adding your desired delimiter (in this case, a comma) between every element .

In case your list doesn’t only contain strings, don’t sweat! You can still convert it to a comma-separated string, even if it includes integers or other types. Just use list comprehension along with the str() function:

mixed_list = ['apple', 42, 'cherry']
comma_separated_string = ','.join(str(item) for item in mixed_list)
print(comma_separated_string)

And your output would look like:

apple,42,cherry

Now you have a versatile method to handle lists containing different types of elements

Remember, if your list includes strings containing commas, you might want to choose a different delimiter or use quotes to better differentiate between items.

For example:

list_with_commas = ['apple,green', 'banana,yellow', 'cherry,red']
comma_separated_string = '"{}"'.format('", "'.join(list_with_commas))
print(comma_separated_string)

Here’s the output you’d get:

"apple,green", "banana,yellow", "cherry,red"

With these tips and examples, you should be able to easily convert a list of strings (or mixed data types) to comma-separated strings in Python .

Python Convert List Of Strings To Lowercase

Let’s dive into converting a list of strings to lowercase in Python. In this section, you’ll learn three handy methods to achieve this. Don’t worry, they’re easy!

Solution: List Comprehension

Firstly, you can use list comprehension to create a list with all lowercase strings. This is a concise and efficient way to achieve your goal.

Here’s an example:

original_list = ["Hello", "WORLD", "PyThon"]
lowercase_list = [item.lower() for item in original_list]
print(lowercase_list) # Output: ['hello', 'world', 'python']

With this approach, the lower() method is applied to each item in the list, creating a new list with lowercase strings.

Solution: map() Function

Another way to convert a list of strings to lowercase is by using the map() function. This function applies a given function (in our case, str.lower()) to each item in a list.

Here’s an example:

original_list = ["Hello", "WORLD", "PyThon"]
lowercase_list = list(map(str.lower, original_list))
print(lowercase_list) # Output: ['hello', 'world', 'python']

Remember to wrap the map() function with the list() function to get your desired output.

Solution: For Loop

Lastly, you can use a simple for loop. This approach might be more familiar and readable to some, but it’s typically less efficient than the other methods mentioned.

Here’s an example:

original_list = ["Hello", "WORLD", "PyThon"]
lowercase_list = [] for item in original_list: lowercase_list.append(item.lower()) print(lowercase_list) # Output: ['hello', 'world', 'python']

I have written a complete guide on this on the Finxter blog. Check it out!

Recommended: Python Convert String List to Lowercase

Python Convert List of Strings to Datetime

In this section, we’ll guide you through converting a list of strings to datetime objects in Python. It’s a common task when working with date-related data, and can be quite easy to achieve with the right tools!

So, let’s say you have a list of strings representing dates, and you want to convert this into a list of datetime objects. First, you’ll need to import the datetime module to access the essential functions.

from datetime import datetime

Next, you can use the strptime() function from the datetime module to convert each string in your list to a datetime object. To do this, simply iterate over the list of strings and apply the strptime function with the appropriate date format.

For example, if your list contained dates in the "YYYY-MM-DD" format, your code would look like this:

date_strings_list = ["2023-05-01", "2023-05-02", "2023-05-03"]
date_format = "%Y-%m-%d"
datetime_list = [datetime.strptime(date_string, date_format) for date_string in date_strings_list]

By using list comprehension, you’ve efficiently transformed your list of strings into a list of datetime objects!

Keep in mind that you’ll need to adjust the date_format variable according to the format of the dates in your list of strings. Here are some common date format codes you might need:

• %Y: Year with century, as a decimal number (e.g., 2023)
• %m: Month as a zero-padded decimal number (e.g., 05)
• %d: Day of the month as a zero-padded decimal number (e.g., 01)
• %H: Hour (24-hour clock) as a zero-padded decimal number (e.g., 17)
• %M: Minute as a zero-padded decimal number (e.g., 43)
• %S: Second as a zero-padded decimal number (e.g., 08)

Python Convert List Of Strings To Bytes

So you want to convert a list of strings to bytes in Python? No worries, I’ve got your back. This brief section will guide you through the process.

First things first, serialize your list of strings as a JSON string, and then convert it to bytes. You can easily do this using Python’s built-in json module.

Here’s a quick example:

import json your_list = ['hello', 'world']
list_str = json.dumps(your_list)
list_bytes = list_str.encode('utf-8')

Now, list_bytes is the byte representation of your original list.

But hey, what if you want to get back the original list from those bytes? Simple! Just do the reverse:

reconstructed_list = json.loads(list_bytes.decode('utf-8'))

And voilà! You’ve successfully converted a list of strings to bytes and back again in Python.

Remember that this method works well for lists containing strings. If your list includes other data types, you may need to convert them to strings first.

Python Convert List of Strings to Dictionary

Next, you’ll learn how to convert a list of strings to a dictionary. This can come in handy when you want to extract meaningful data from a list of key-value pairs represented as strings.

To get started, let’s say you have a list of strings that look like this:

data_list = ["Name: John", "Age: 30", "City: New York"]

You can convert this list into a dictionary using a simple loop and the split() method.

Here’s the recipe:

data_dict = {} for item in data_list: key, value = item.split(": ") data_dict[key] = value print(data_dict) # Output: {"Name": "John", "Age": "30", "City": "New York"}

Sweet, you just converted your list to a dictionary! But, what if you want to make it more concise? Python offers an elegant solution with dictionary comprehension.

Check this out:

data_dict = {item.split(": ")[0]: item.split(": ")[1] for item in data_list}
print(data_dict) # Output: {"Name": "John", "Age": "30", "City": "New York"}

With just one line of code, you achieved the same result. High five!

When dealing with more complex lists that contain strings in various formats or nested structures, it’s essential to use additional tools like the json.loads() method or the ast.literal_eval() function. But for simple cases like the example above, the loop and dictionary comprehension should be more than enough.

Python Convert List Of Strings To Bytes-Like Object

How to convert a list of strings into a bytes-like object in Python? It’s quite simple and can be done easily using the json library and the utf-8 encoding.

Firstly, let’s tackle encoding your list of strings as a JSON string . You can use the json.dumps() function to achieve this.

Here’s an example:

import json your_list = ['hello', 'world']
json_string = json.dumps(your_list)

Now that you have the JSON string, you can convert it to a bytes-like object using the encode() method of the string .

Simply specify the encoding you’d like to use, which in this case is 'utf-8':

bytes_object = json_string.encode('utf-8')

And that’s it! Your list of strings has been successfully transformed into a bytes-like object. To recap, here’s the complete code snippet:

import json your_list = ['hello', 'world']
json_string = json.dumps(your_list)
bytes_object = json_string.encode('utf-8')

If you ever need to decode the bytes-like object back into a list of strings, just use the decode() method followed by the json.loads() function like so:

decoded_string = bytes_object.decode('utf-8')
original_list = json.loads(decoded_string)

Python Convert List Of Strings To Array

Converting a list of strings to an array in Python is a piece of cake .

One simple approach is using the NumPy library, which offers powerful tools for working with arrays. To start, make sure you have NumPy installed. Afterward, you can create an array using the numpy.array() function.

Like so:

import numpy as np string_list = ['apple', 'banana', 'cherry']
string_array = np.array(string_list)

Now your list is enjoying its new life as an array!

But sometimes, you may need to convert a list of strings into a specific data structure, like a NumPy character array. For this purpose, numpy.char.array() comes to the rescue:

char_array = np.char.array(string_list)

Now you have a character array! Easy as pie, right?

If you want to explore more options, check out the built-in split() method that lets you convert a string into a list, and subsequently into an array. This method is especially handy when you need to split a string based on a separator or a regular expression.

Python Convert List Of Strings To JSON

You’ve probably encountered a situation where you need to convert a list of strings to JSON format in Python. Don’t worry! We’ve got you covered. In this section, we’ll discuss a simple and efficient method to convert a list of strings to JSON using the json module in Python.

First things first, let’s import the necessary module:

import json

Now that you’ve imported the json module, you can use the json.dumps() function to convert your list of strings to a JSON string.

Here’s an example:

string_list = ["apple", "banana", "cherry"]
json_string = json.dumps(string_list)
print(json_string)

This will output the following JSON string:

["apple", "banana", "cherry"]

Great job! You’ve successfully converted a list of strings to JSON. But what if your list contains strings that are already in JSON format?

In this case, you can use the json.loads() function:

string_list = ['{"name": "apple", "color": "red"}', '{"name": "banana", "color": "yellow"}']
json_list = [json.loads(string) for string in string_list]
print(json_list)

The output will be:

[{"name": "apple", "color": "red"}, {"name": "banana", "color": "yellow"}]

And that’s it! Now you know how to convert a list of strings to JSON in Python, whether it’s a simple list of strings or a list of strings already in JSON format.

Python Convert List Of Strings To Numpy Array

Are you looking to convert a list of strings to a numpy array in Python? Next, we will briefly discuss how to achieve this using NumPy.

First things first, you need to import numpy. If you don’t have it installed, simply run pip install numpy in your terminal or command prompt.

Once you’ve done that, you can import numpy in your Python script as follows:

import numpy as np

Now that numpy is imported, let’s say you have a list of strings with numbers that you want to convert to a numpy array, like this:

A = ['33.33', '33.33', '33.33', '33.37']

To convert this list of strings into a NumPy array, you can use a simple list comprehension to first convert the strings to floats and then use the numpy array() function to create the numpy array:

floats = [float(e) for e in A]
array_A = np.array(floats)

Congratulations! You’ve successfully converted your list of strings to a numpy array! Now that you have your numpy array, you can perform various operations on it. Some common operations include:

• Finding the mean, min, and max:

mean, min, max = np.mean(array_A), np.min(array_A), np.max(array_A)

• Reshaping the array:

reshaped_array = array_A.reshape(2, 2)

• Performing element-wise operations (e.g., adding):

array_B = np.array([1.0, 2.0, 3.0, 4.0])
result = array_A + array_B

Now you know how to convert a list of strings to a numpy array and perform various operations on it.

Python Convert List of Strings to Numbers

To convert a list of strings to numbers in Python, Python’s map function can be your best friend. It applies a given function to each item in an iterable. To convert a list of strings into a list of numbers, you can use map with either the int or float function.

Here’s an example:

string_list = ["1", "2", "3", "4", "5"]
numbers_int = list(map(int, string_list))
numbers_float = list(map(float, string_list))

Alternatively, using list comprehension is another great approach. Just loop through your list of strings and convert each element accordingly.

Here’s what it looks like:

numbers_int = [int(x) for x in string_list]
numbers_float = [float(x) for x in string_list]

Maybe you’re working with a list that contains a mix of strings representing integers and floats. In that case, you can implement a conditional list comprehension like this:

mixed_list = ["1", "2.5", "3", "4.2", "5"]
numbers_mixed = [int(x) if "." not in x else float(x) for x in mixed_list]

And that’s it! Now you know how to convert a list of strings to a list of numbers using Python, using different techniques like the map function and list comprehension.

Python Convert List Of Strings To Array Of Floats

Starting out, you might have a list of strings containing numbers, like ['1.2', '3.4', '5.6'], and you want to convert these strings to an array of floats in Python.

Here’s how you can achieve this seamlessly:

Using List Comprehension

List comprehension is a concise way to create lists in Python. To convert the list of strings to a list of floats, you can use the following code:

list_of_strings = ['1.2', '3.4', '5.6']
list_of_floats = [float(x) for x in list_of_strings]

This will give you a new list list_of_floats containing [1.2, 3.4, 5.6].

Using numpy.

If you have numpy installed or are working with larger arrays, you might want to convert the list of strings to a numpy array of floats.

Here’s how you can do that:

import numpy as np list_of_strings = ['1.2', '3.4', '5.6']
numpy_array = np.array(list_of_strings, dtype=float)

Now you have a numpy array of floats: array([1.2, 3.4, 5.6]).

Converting Nested Lists

If you’re working with a nested list of strings representing numbers, like:

nested_list_of_strings = [['1.2', '3.4'], ['5.6', '7.8']]

You can use the following list comprehension:

nested_list_of_floats = [[float(x) for x in inner] for inner in nested_list_of_strings]

This will result in a nested list of floats like [[1.2, 3.4], [5.6, 7.8]].

---

Pheww! Hope this article helped you solve your conversion problems.

Free Cheat Sheets!

If you want to keep learning Python and improving your skills, feel free to check out our Python cheat sheets (100% free):