Learn coding in Python, Go and Rust from Serdar Yegulalp, software dev specialist and senior writer at InfoWorld.
Python programs aren't easy to bundle up into click-to-run installable packages. No native way to do this exists, and the various third-party solutions like PyInstaller have major shortcomings and quirks. The PyApp project, written in Rust, aims to make it easy to build standalone executables for Python apps, although you need to be familiar with the Rust toolchain to use it. This video shows a simple example of PyApp in action, and details some of its features and limitations.
AWS's Kiro IDE uses an agent-powered workflow to iteratively transform user prompts into working code with test suites. Watch a hands-on demo of Kiro, as we take a simple prompt and make a full program from it — and see close-up both the power and the limitations of code-generating AI.
Astral's uv utility simplifies and speeds up working with Python virtual environments. But it has some other superpowers, too: it lets you run Python packages and programs without having to formally install them, all by way of one simple command. This video shows off how this can work for anything from a simple one-file program to a full project with a pyproject.toml file. Featuring Serdar Yegulalp: https://www.linkedin.com/in/serdar-yegulalp-136a483/
Cutting-edge AI systems, like generative AI, use models trained on immense amounts of data. But is that also the path to general artificial intelligence? There are good reasons to believe it isn't. In this video I talk about why data-model generative-AI systems are built on top of assumptions about intelligence and thinking that may not hold — and what other approaches might lie beyond them.
Microsoft has outfitted the Visual Studio Code editor with many extensions to make it a prime place to write Python code. The latest, albeit experimental, extension in this vein helps you manage the virtual environments you create for Python projects. In this video we'll walk through how it works in its early incarnation, and note some pitfalls you want to know about if you intend to try it on your own projects.
With the new free-threaded or "no-GIL" versions of Python, it's now possible to run Python code with full parallelism on multiple CPU cores. It also means "data race" bugs are easier than ever to create, where it's hard to guarantee the sequence in which a given object will be altered by code in different threads. One of the discussions at the recent Python Language Summit confronted this problem, and in this video I unpack their proposed solution in detail, and what implications it has for the rest of the language. For details about the talk itself: https://pyfound.blogspot.com/2025/06/python-language-summit-2025-fearless-concurrency.html
When we say something is "deterministic", we mean it delivers the same outputs for the same inputs. In theory LLMs should do that, as they're just mathematical models. But we don't get consistent results from LLMs even with the same inputs — and there's a slew of reasons for that. In this video I dive into why LLMs are designed to introduce randomness into the results, and why even without that feature it's hard to get them to deliver the exact same results from the exact same prompts.
Up until now, Python type annotations were evaluated "eagerly" - you needed to have an object defined before you could use it as an annotation. With Python 3.14, the default behavior has changed: Type annotations are now evaluated "lazily", as needed, for better performance and more flexibility. This video compares 3.14's new behavior with the way Python's handled annotations in previous versions, with recommendations for how to adapt to the new behavior.
AI agents are LLM-powered interfaces designed to help people accomplish specific tasks. Creating and deploying them can be complex. Google's newly released Agent Development Kit for Python (and Java) takes the boilerplate and heavy lifting out of writing AI agents, and gives you frameworks to write many common workflows used with such agents. InfoWorld article references: /article/3988205/google-i-o-2025-news-and-analysis.html /article/3818503/google-rolls-out-cheaper-ai-model-as-industry-scrutinizes-costs.html
Python has long had the "f-string" feature, for creating formatted strings from variable data. Now, with Python 3.14, there's a "template string" type — an f-string-like construction which gives you far more control over how the data is formatted and outputted. In this example we show how t-strings (as they're called) can be used to create templates that safely format text for HTML output.
Python 3.14 has rolled out a new official tool for adding, removing, and maintaining various versions of Python on Microsoft Windows. It also eclipses the existing \\\\\\\"py\\\\\\\" tool on that platform. This video explores how it works, how it replaces existing tooling, and what to expect when using it with pre-existing Python installations.
The Jupyter notebook system gives Python users a visual, interactive way to run code, display the results, and share the source with others. But Jupyter notebooks have limited interactivity. Marimo, a new competitor for Jupyter notebooks, lets you create notebooks that are more interactive, more powerful, and even easier to share with others.
Console apps are, by default, pretty plain-looking, but modern consoles offer powerful color and text stylization features. The trick is knowing how to use them. The \\\"rich\\\" library in Python gives you tools to easily add striking text stylization to console text output, including advanced interactive features like progress bars or elaborate layouts like tree views.
The Poetry and UV projects both give you high-level tools for creating and managing Python projects, including tracking dependencies and creating lockfiles from them. But their workflows, and the demands they make on the user and on your project, are very different. This video lays out how those differences affect you, and where it makes sense to opt for one solution over the other.
WebAssembly gives you a way to run code across platforms, including in a web browser, at near-native speeds, and by way of a broad range of languages. Google's Go language compiles directly to WebAssembly with minimal changes to one's code. In this video we show how a simple WASM module can be created in Go, and how to use Go's standard library to interact with JavaScript objects (for instance, to read form data or change DOM elements). /article/2264559/webassembly-tutorial-get-started-with-webassembly.html /article/2255892/what-is-webassembly-the-next-generation-web-platform-explained.html
Python packages can be installed in an "editable" or "in-place" installation mode, where instead of copying the package's code into a virtual environment, there's a pointer to the source directory instead. This allows any changes made to the package source to be reflected instantly in every virtual environment where the package is installed this way. This video demonstrates how useful and powerful this can be for Python developers, as it becomes far easier to evaluate changes made to a package without having to reinstall it each time you change it.
WebAssembly gives you a way to run code across platforms, including in a web browser, at near-native speeds, and by way of a broad range of languages. Rust has first-class support for WebAssembly as a compilation target. This video demonstrates how to create a simple WASM module for the web in Rust, which includes all the components you need to have your WASM module work in a web application.
WebAssembly apps can run at near-machine-native speeds in a browser — and outside of it, too, with the Wasmer runtime. In this video you'll see how Wasmer can run WebAssembly apps from the command line, download pre-packaged apps from the wasm.io online package registry, and work with local WebAssembly binaries you've already downloaded or built. What is WebAssembly? The next-generation web platform explained | InfoWorld /article/2255892/what-is-webassembly-the-next-generation-web-platform-explained.html Wasmer takes WebAssembly server-side | InfoWorld /article/2262266/wasmer-takes-webassembly-server-side.html Wasmer melds WebAssembly, Posix with WASIX spec | InfoWorld /article/2338550/wasmer-melds-webassembly-posix-with-wasix-spec.html
Dioxus is a relatively new library for building cross-platform applications with Rust, using web frontends. Everything in your app, including the web interface, is created declaratively with Rist code. This video shows how a basic Dioxus app can be created, and also compares and contrasts Dioxus's approach with Tauri, another cross-platform library that works with Rust and other languages. Tauri, a Rust-powered Electron alternative | InfoWorld /video/2156953/tauri-a-rust-powered-electron-alternative.html Intro to Tauri: The Electron alternative | InfoWorld /article/2338125/intro-to-tauri-the-electron-alternative.html
Python 3.14 now features changes to the interpreter to make Python applications run faster with no changes to your code. This video graphically demonstrates how much of a speedup to expect with a benchmark we've used before — and how these new changes to 3.14 also work with the "free-threaded" or "no-GIL" builds of Python.
The LLVM compiler infrastructure project lives at the heart of the Clang C/C++ compiler, and the compilers for languages like Rust and Zig. This video shows in detail the concepts behind LLVM, such as how code in one language is translated into LLVM's own internal language.
A software bill of materials, or SBOM, describes the contents of a given software package for allowing enforcement of software licenses and conducting security audits for known vulnerabilities. This video demonstrates what SBOMs look like, how they're compiled, and what tools are used to generate them, both from source code and from binary artifacts.
A relatively new language in the systems-programming space has been drawing more attention over the past few years. The Zig language is intended to compete with, and also complement, the C language. It's also potential competition for some of the same use cases as Rust and C++, as this video shows.
Ever committed sensitive information to a git repository and realized it all too late? You can always erase the repo and start over, but there are other, more elegant solutions. In this video we explore a few options for deleting confidential data from git repositories, both built into the git tool and available as third-party solutions.
Testing web apps is tedious, time-consuming work, even when you have an automation framework to handle the heaviest of the lifting. Playwright, a web app test system originally developed by folks at Microsoft, simplifies many common web-app testing tasks by way of its intuitive syntax and object model. This video demonstrates using Playwright in Python to test a simple web app (although many other languages are supported for test suites, too).
Cython converts ordinary Python programs into C by way of type hints and other special syntax. In this video we'll show how the newest version in development, Cython 3.1, offers some powerful new type hinting features for declaring pointers or working with "volatile" values, and adds forward compatibility for Python's forthcoming free-threaded or "no-GIL" bulds.
A common problem: you have a directory full of files and want to take some action every time something changes in it. The "Watchdog" library for Python gives you tools to observe changes in a directory structure and take action based on any generated events. Learn how to set up and work with Watchdog in this simple demonstration.
Python's "abstract base class" system gives you a way to create types that serve as the abstract foundation for another, more concrete type. This example shows how an abstract base class from the Python standard library can be used as the basis for a custom dictionary type, one where the entries expire after a given length of time, and where the implementation is less clumsy and unpredictable than just subclassing the built-in dict type.
Python's Pillow library, for image manipulation, has features above and beyond merely resizing, rotating, cropping, or recoloring images. In this video we'll see how Pillow can be used to add text captions to image, take snapshots of the screen, or work with image data copied to the system clipboard.
Python packages are typically things you pip install and run by importing into your code. But you can make packages runnable from the Python command line using the \"-m\" option — and by configuring your package with a \"__main__\" module. This video steps you through the basics of using \"__main__\" in a package, and how it differs from \"__init__\" in a package (and elsewhere, too).
The "wheel" format in Python lets you bundle up and redistribute a Python package you've created. Others can then use the "pip" tool to install your program from your wheel file, which can include binary components (like Python extension modules written in C). This video walks through the basics of how to build wheels with a "pip install"-able project.
It's not hard to write a Python package that can be installed into an interpreter or virtual environment with pip. This video shows a simple example of how to lay out a project's source code and set up its pyproject.toml file to allow pip to use it as an installation source. (In future videos we'll explore actions like creating Python wheels or uploading such projects to PyPi, too.)
If you use Python for accessing API endpoints or web scraping, odds are you're using either Python's native http libraries or a third-party module like requests. In this video, we take a look at the httpx library — an easy, powerful, and future-proof way to make HTTP requests. It provides tools for everything from sending form data to handling multipart file uploads, and works with both synchronous and async code.
Python can interface with C code using the built-in ctypes library, but ctypes is notoriously clunky. The third-party CFFI project offers a more streamlined way to build interfaces between Python programs and C libraries. This video shows the basics of using CFFI, including how talking to a C library can be as easy as copying and pasting a C library header into your Python code.
Everyone uses the .zip archive format to compress and store files, but sometimes you need more flexibility and power than a command-line or GUI archiving tool gives you — or you want to create archives programmatically. Python's got built-in functions for creating and working with zip files, by way of its standard library's zipfile module. This video walks through the basics of using zipfile to create new archives, load files into them, extract files from them, and do other operations.
In software development, there's the concept of a "mode" – a distinct set of behaviors for a program that changes the way it receives user input. In this video we'll demonstrate a simple video game (using the PyGame framework) that uses three distinct modes of behavior, and use it as an example for how to implement modal behaviors in a program. The code shown in this video is available at https://gist.github.com/syegulalp/ab5ccf257381344ea6c3f29bf36936bc - you are free to use it as you see fit.
Python's "ast" module transforms the text of Python source code into an object stream. It's a more powerful way to walk through Python code, analyze its components, and make changes than working manually with code as text. This video shows some basic "ast" techniques, like selectively replacing imports and performing other targeted modifications to code.
The \\\"enum\\\" type in Python lets you create variables constrained to a predefined range of values. Learn how this built-in Python type can be used to express the state of something, whether as a string, an integer, or some other type – and how to ensure the values you create remain consistent both inside and outside your program.
Python comes with many things, but by default it does not have tools for manipulating images. The third-party Pillow library, formerly known as PIL (the Python Imaging Library), provides a slew of modules for reading various image formats, processing image data, performing common manipulations like thumbnailing, and saving images back to files. In this video we'll walk through the basics of using Pillow, and also single out some of the caveats of working with it, such as its internal inconsistencies and quirks.
Sometimes with a program you just need a quick and dirty way to persist values across to disk. The dbm module in Python provides a native way to do this across platforms, with no more effort than you'd need to save values in a dictionary. Learn in this video the basics of how it works, and how it's been updated to use SQLite as a storage backend.
Python's type hinting system makes it easier to check your programs for correctness and consistency, but adding type hints to an existing code base can be grueling work. MonkeyType, created by Instagram, runs your code and automatically generates type hints for code, which you can apply directly to your source or list alongside it as type stubs. This video shows a simple example of MonkeyType in action, along with some use cases and caveats.
Python programs can use a web frontend with HTML to create GUIs conveniently. In many cases you don't even have to know HTML, CSS, or JS: you can use a Python framework that generates your interactive frontend programmatically. With NiceGUI, HTML apps with complex web controls aren't hard to implement in a few lines of Python. This video walks through the basics of how NiceGUI apps work, and compares and contrasts with similar frameworks like Streamlit.
Python 3.13 provides early access to some groundbreaking new features in CPython, the default Python interpreter. A new JIT can enable speedups in "hot spots" in Python code, by selectively replacing generic instructions with specialized versions and by using a new second-stage bytecode – without having to rewrite any existing Python code. And the new "free-threaded", or "no-GIL" build, lets Python threads run with true parallelism. However, none of these features are enabled by default yet. To use them, you need to build a custom edition of the Python interpreter. In this video, we've done just that, and we show some examples of where both of these new features add real value to Python. Twitter: @syegulalp LinkedIn: https://www.linkedin.com/in/serdar-yegulalp-136a483/
In previous videos we covered Cython (for translating Python into C for speed), Numpy (for working with numerical arrays at scale), and parallelism in Cython (for doing work in multiple threads). In this video we look at how all three of these things can be used at once: writing Cython that runs in parallel for operating on Numpy arrays. We'll also cover how to ensure Cython uses Numpy arrays correclty, and why parallelism with Numpy arrays doesn't always result in linear speedups.
Many different data libraries in Python work with dataframes – Polars, Pandas, DuckDB, and so on. But they all sport highly dissimilar APIs and feature sets, and some have features the others don't. Ibis provides a common, unified front end for over a dozen Python dataframe libraries – a common way to read data, query it, pass dataframes between different processing engines, and report the results. This video shows an example of how this works using a single common dataframe derived from a CSV, using DuckDB, Polars, and Ibis's native dataframe processing.
Asynchronous programming in any language can be tricky, and Python is no exception. The AnyIO library simplifies many common patterns in async programming in Python, such as how to start async tasks or manage them. AsyncIO also adds many behaviors and features for async not found in Python's standard library, like performing asynchronous work with files.
Analytics databases, or column-oriented DBs, speed up analytics jobs on big datasets. But most such DBs are big products with a lot of setup and management overhead. DuckDB bucks that trend: it's a single, self-contained executable and library that brings SQL-query-powered analytics DB functionality to most any programming language, workflow, or data trove. This video shows how you can use DuckDB with Python to work with big, multi-megabyte JSON or CSV datasets, and query the data using conventional SQL syntax.
As WebAssembly gains in popularity, one possible application is to embed a WASM runtime into applications to extend the app's functionality. Extism lets you write WASM extensions for your own applications, creating in effect a WASM-powered plugin system for your apps without the overhead of embedding a full language runtime like Lua. This video shows the basics of how to write a WASM add-on in AssemblyScript, and add it to a Python application, all in a few lines of code.
Cython's used to take existing Python code and translate it to C for speed. It can also be used to make some operations on C types faster by performing them in parallel, and without using the overhead of Python's threading or multiprocessing mechanisms. Instead, you can write Cython code that makes use of the industry-standard OpenMP interface for writing parallel-processing code. This video goes through the basics of using OpenMP in Cython, using the "prange" object, and gives you an idea of what's involved to make operations parallel.
If you've ever needed to compile something from C/C++ source in Microsoft Windows, odds are you've also been aggravated by how complex it can be to set up the Visual Studio C++ Build Tools. Turns out there's a simple, one-command way to do it using the Winget package manager, with minimal babysitting and fuss. Watch this video to learn how to install the Build Tools from the command line, and how to customize the setup to include more than the basic components if needed.