ProgrammingPro #89: Python 3.14’s 30% Speed Boost, VS Code’s AI Upgrades, Go 1.24 Released, and Building a Rust Driver
Welcome to a brand new issue of ProgrammingPro.
In today’s Expert Insight, we bring you an excerpt from the recently published book, Minimal CMake, which explains how to simplify project onboarding using ExternalProject_Add to automate dependency management, reducing manual setup and improving build efficiency by consolidating multiple steps into a single command.
News Highlights: Python 3.14’s interpreter boosts performance by 30%; VS Code 1.97 makes Copilot an “out-of-the-box” feature with predictive edits; JetBrains AI Assistant adds local LLM support; Go 1.24 introduces generic type aliases and runtime improvements.
My top 5 picks from today’s learning resources:
How I Built a Deep Learning Library from Scratch Using Only Python, NumPy & Math🧠
Surviving Google’s JavaScript rendering shift: one month later🌍
But there’s more, so dive right in.
Stay Awesome!
Divya Anne Selvaraj
Editor-in-Chief
PS: We're conducting market research to better understand the evolving landscape of software engineering and architecture – including how professionals like you learn, grow and adapt to the impact of AI.
We think your insights would be incredibly valuable, and would love to hear what you have to say in a quick 1:1 conversation with our team.
What's in it for you?
✅ A brief 20–30 minute conversation at a time that’s convenient for you
✅ An opportunity to share your experiences and shape the future of learning
✅ A free credit to redeem any eBook of your choice from our library as a thank-you
How to Participate:
Schedule a quick call at your convenience using the link provided after the form:
https://forms.office.com/e/Bqc7gaDCKq
Looking forward to speaking with you soon!
Thank you,
Team Packt.
🗞️News and Analysis🔎
What you need to know about Python 3.14’s faster interpreter: The interpreter aims to improve performance by up to 30% without requiring code changes and is based on tail call improvements at the C level.
Go 1.24 is released!: The version introduces full support for generic type aliases, runtime performance improvements, a new map implementation, enhanced tool tracking, a test analyzer in
go vet, and more.JetBrains AI Assistant can now use local LLMs: The update allows developers with strict privacy requirements to run models locally and adds support for Claude 3.5 Sonnet, Claude 3.5 Haiku, and OpenAI’s o1, o1-mini, and o3-mini models.
Microsoft Visual Studio and C# DevKit updates bring long-awaited fixes: Microsoft Visual Studio 2022 17.13 introduces setting UTF-8 without a BOM as the default text file encoding, resolving a 2017 issue.
VS Code update treats Copilot as “out-of-the-box” feature: VS Code 1.97 now has a free Copilot plan, and introduces predictive edit suggestions, auto-accept for AI edits, and experimental agent mode for end-to-end tasks.
JDK 24 and JDK 25: What We Know So Far: JDK 24, set for release on March 18, includes 24 new features spanning core libraries, security, and HotSpot; JDK 25, expected September 2025, may finalize structured concurrency and HTTP/3 support.
AWS CodeBuild Now Supports Fastlane to Simplify iOS Deployments: The CI service now includes Fastlane by default, simplifying iOS, iPadOS, watchOS, tvOS, and macOS app deployments. MacOS CodeBuild images also support Xcode and various programming languages.
🎓Tutorials and Learning Resources💡
Python
💼How I Built a Deep Learning Library from Scratch Using Only Python, NumPy & Math: Explains the motivation, abstraction layers, and technical design, and delves into comparisons with PyTorch, covering key components like tensors, autograd, neural network modules, and optimizers.
For more Python resources, go to PythonPro
C# and .NET
🗞️VisualStudio.Extensibility: Managing .NET runtime versions: Explains how the SDK manages .NET runtime version updates, ensuring extensions remain compatible as Visual Studio transitions to newer .NET versions.
💡Integrating AI into Your Existing Applications Using Semantic Kernel and C#: Explores how Microsoft's Semantic Kernel enables AI integration in C# applications, covering its capabilities, use cases, challenges, and strategies.
🎓Integrating Azure Service Bus Emulator in .NET Aspire: Covers setting up the emulator, configuring SQL Server, integrating with .NET Aspire, and managing service connections for local development.
C and C++
🎓Fun with C++26 reflection - Keyword Arguments: Provides a guide on implementing order-independent keyword arguments in C++26 using reflection features, along with alternative approaches, code examples, and explanations.
🎓Creating a Code Obfuscation Program For C: Outlines techniques such as renaming variables and functions, adding junk macros, altering code structure, and formatting manipulations while maintaining functionality.
🎓Write your own C++ unit testing library: Explains how to write a testing library without using existing frameworks like Google Test or Catch2 and covers designing a simple test interface, handling failures with exceptions, and more.
Java
💡Evolution of Java Ecosystem for Integrating AI: Explores how the Java ecosystem is evolving to support AI integration, highlighting frameworks like LangChain4j, Spring AI, and Jlama, alongside Oracle Generative AI for enterprise solutions.
🎓Making Java enums forwards compatible: Explains how to make Java enums forward-compatible in SDKs by using a wrapper class that stores both the raw API value and a safe enum representation, preventing crashes.
🎓Streamline UUID v7 Generation in Spring Boot Entities with Custom Annotations(Hibernate 6.5+ & Spring Boot 3.3+): Explains how to improve database performance with time-ordered unique identifiers by creating a custom annotation and UUID generator.
JavaScript and TypeScript
🎓Clean room tests with JavaScript's `using` keyword: Explains how JavaScript's new
usingkeyword can simplify test isolation by automatically managing resources like test databases and mock servers.🎓JavaScript Decorators & Annotations: A Practical Guide to Metaprogramming: Covers use cases, implementation in TypeScript, integration with the Reflect API for metadata handling, and real-world applications.
🎓TypeScript: the
satisfiesoperator: Explains how the operator enforces type constraints without altering inferred types, its syntax, and practical use cases for validating object properties.
Go
💼We Replaced Our React Frontend with Go and WebAssembly: Explains why Dagger switched to a Go-based WASM UI, detailing the benefits of code unification, performance improvements, memory optimizations, and more.
🎓Fast Listing of Files from Large S3 and GCS Buckets Using Go Concurrency: Covers, optimizing file traversal through parallelization, strategic range-based queries, and the
rillconcurrency toolkit to improve performance.
Rust
🎓Writing a Simple Driver in Rust: Walks you through the process of writing a simple Windows kernel-mode driver in Rust, covering setup, dependencies, device creation, handling requests, and testing the driver with a C++ client.
💡How Does Ada's Memory Safety Compare Against Rust?: Concludes that while Rust enforces strict compile-time guarantees to prevent common memory errors, Ada relies on safer design patterns, runtime checks, and formal verification, making it less prone to such issues.
Swift
🎓How to develop an app for iOS: Covers essential tools like macOS, Xcode, and optional enhancements, along with learning resources, joining Apple's Developer Program, and strategies for releasing and promoting an app.
💡Protocol Extensions in Swift 6.0: New Tricks: Explores enhanced generic constraints that enable more flexible, reusable, and maintainable code in protocol-oriented programming.
PHP
🎓Exploring Concurrent Access Handling: Examines strategies for handling concurrent access in PHP and MySQL, covering issues like race conditions, observability, parallelization, locking mechanisms, and transactions.
🎓Lazy objects in PHP 8.4: Demonstrates how to use lazy objects in PHP 8.4, explaining their benefits, implementation, and practical applications such as deserialization and I/O-bound entity fetching.
SQL
🎓Measuring Cross-Product Adoption Using dbt_set_similarity: Explains how to measure cross-product adoption using the Jaccard Index within dbt workflows, leveraging the dbt_set_similarity package to quantify user overlap.
Ruby
🎓Essential Rails 7 & 8 Commands Guide: Covers project setup, database management, component generation, testing, debugging, and asset management, production deployment, and modern frontend tools.
🎓Rails Soft Delete & Audit Logging Guide: Explains how to implement soft deletion and audit logging in Rails financial applications using
acts_as_paranoidfor data retention and a structured audit log system.
Kotlin
💡Designing Effective UI Components in Jetpack Compose: Covers best practices for modifier usage, theming for consistency, customizability via slots and style classes, and preview compatibility to enhance developer experience.
💡Kotlin Constants in Android: Top-level vs. Companion-enclosed: Examines the constants' differences by analyzing their impact on APK size, performance, and memory usage by decompiling bytecode and testing R8 optimizations.
🌟Best Practices and Advice🚀
🧟♂️Cell-based Architecture Explained, with Zombies: Explains cell-based architecture using a zombie-resistant city analogy, where isolated neighborhoods (cells) prevent failures from spreading.
Automated Accessibility Testing at Slack: Discusses how Slack integrated automated accessibility testing using Axe within their Playwright framework to enhance compliance with WCAG standards.
How to Prevent Bugs From Reaching Production: Outlines six practices used at Outbrain, including CI/CD pipelines, simulator environments, duplicate traffic testing, gradual deployments, A/B testing, and structured postmortems.
Surviving Google’s JavaScript rendering shift: one month later: Reflects on the impact of Google’s new requirement on web scraping, the challenges it created for SEO tools and data collection, and how the industry is adapting with headless browsers, proxy solutions, and advanced scraping techniques.
My DOs and DON’Ts of Software Architecture: Recommends developing clarity, questioning assumptions, and avoiding over-architecture, while warning against ineffective collaboration, poor decision-making, and hybrid Agile-Waterfall approaches.
🧠Expert Insight📚
Here’s an excerpt from “Chapter 8: Using Super Builds to Simplify Onboarding" in the book, Minimal CMake, by Tom Hulton-Harrop, published in January 2025.
Using ExternalProject_Add with your own libraries
In the previous chapter, we stuck largely to manual CMake build and install commands (along with a bit of help from CMake presets) to increase our familiarity with CMake, and to work at a slightly lower level of abstraction to understand what CMake is doing behind
the scenes. Now that we’re a bit more comfortable with these concepts, it’s time to remove the tedium of navigating to each individual library folder and running the familiar CMake commands that follow:
cmake --preset <preset-name>
cmake --build <build-folder> --target install
We can start updating our project to take advantage of the more useful features that CMake provides. To start with, we’re going to update our existing third-party CMakeLists.txt file to bring in not only SDL 2 and bgfx but also the libraries we created and depend on. This will remove the need for us to manually install them and allow us to run a single pair of CMake commands (configure and build/install) to retrieve all the dependencies we need for our Game of Life application.
Let’s start by looking at ch8/part-1/third-party/CMakeLists.txt . The file is largely the same as before, only underneath our existing ExternalProject_Add commands, we’ve added references to our libraries found in ch8/part-1/lib .
Here is an example of the mc-array library:
ExternalProject_Add(
mc-array
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../lib/array
BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/mc-array-build/${build_type_dir}
INSTALL_DIR ${CMAKE_CURRENT_SOURCE_DIR}/install
CMAKE_ARGS ${build_type_arg} -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
CMAKE_CACHE_ARGS -DCMAKE_DEBUG_POSTFIX:STRING=d)
The command should look remarkably similar to those we covered in Chapter 6, Installing Dependencies and ExternalProject_Add. The only real difference is the reference to SOURCE_DIR . Given the slightly unconventional layout of this book’s repository, we can reference the source folder directly, as the library source code is stored in the same repository:
SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../lib/array
It would normally be the case that we’d refer to an external library using a URL or GIT_REPOSITORY link. If we did, for some reason, want to refer to an older version of one of the libraries at a specific moment in the Git history of our project, we could use this approach:
ExternalProject_Add(
mc-array
GIT_REPOSITORY https://github.com/PacktPublishing/Minimal-CMake.git
GIT_TAG 18535c9d140e828895c57dbb39b97a3307f846ab
SOURCE_SUBDIR ch8/part-1/lib/array
...
We did the same thing in Chapter 3, Using FetchContent with External Dependencies, when using FetchContent . The preceding command will clone the entire repository into the build folder of our third-party CMakeList.txt file, and then treat the ch8/part-1/lib/array directory as the root of the repository (at least as far as ExternalProject_Add is concerned). It’s not often needed but can be useful if a repository holds more than one CMake project.
While we’re making changes to third-party/CMakeLists.txt , we’ll also make one small improvement to how we handle our bgfx dependency. When bgfx was first introduced in Chapter 6, Installing Dependencies and ExternalProject_Add (see ch6/part-4 ), we wound up needing to clone the repository twice, once for the static version of the library (needed to build the tools), and again for the shared version of the library that our application linked against. The good news is there’s a handy technique we can apply to download the library once. The following is an extract of the changes with the differences highlighted:
ExternalProject_Add(
bgfxt
GIT_REPOSITORY https://github.com/bkaradzic/bgfx.cmake.git
GIT_TAG v1.127.8710-464
...
ExternalProject_Get_Property(bgfxt SOURCE_DIR)
ExternalProject_Add(
bgfx
URL "file://${SOURCE_DIR}"
DEPENDS bgfxt
...
The first ExternalProject_Add call is the same as before; we let it know the repository and specific GIT_TAG to download. However, in the second version, instead of repeating those lines, we first call ExternalProject_Get_Property , passing the bgfxt target and the SOURCE_DIR property. SOURCE_DIR will be populated with the location of the bgfxt source code once it’s downloaded, and in the second command, we point the bgfx target to reference that source code location. As the code is identical and it’s just how we’re building it that’s different, this saves a bit of time and network bandwidth downloading the same files all over again.
You might have noticed that we’re using URL "file://${SOURCE_DIR}" as opposed to SOURCE_DIR ${SOURCE_DIR} . This is because if we tried to use SOURCE_DIR , the ExternalProject_Add command would fail at configure time because SOURCE_DIR is expected to already be present when we configure. As this isn’t the case with our dependency (the source for bgfxt will only be downloaded and made available at build time), we can use the URL option with a local file path shown by file:// , which will cause the file path to instead be resolved at build time.
With the addition of the three new ExternalProject_Add calls referencing our libraries, when building our project, we only need to visit two directories, as opposed to the earlier five. We can navigate to ch8/part-1/third-party and run the following CMake commands:
cmake -B build -G "Ninja Multi-Config"
cmake --build build --config Release
This will download, build, and install all our dependencies at once. We then only need to navigate to ch8/part-1/app and run the following:
cmake --preset multi-ninja
cmake --build build/multi-ninja --config Release
This will build and link our application. We’ve also tidied up our CMakePresets.json file to have CMAKE_PREFIX_PATH only refer to ${sourceDir}/../third-party/install , as opposed to the numerous install folders we had for each of our internal dependencies in the last chapter.
Finally, to launch the application, we first need to compile our shaders and then launch the application from our application root directory (ch8/part-1/app ):
./compile-shader-<platform>.sh/bat
./build/multi-ninja/Release/minimal-cmake_game-of-life_window
This is a substantial improvement from before, but we can do better. The main build is still split across two stages (dependencies and application), and we still have the annoying issue of needing to remember to compile the shaders (an easy step to overlook). We want to achieve the holy grail of one command to bootstrap everything. Let’s start by seeing how we can solve the first problem by reducing our build steps from two to one...
Minimal CMake was published in January 2025. Packt library subscribers can continue reading the entire book for free or you can buy the book here!
Get the eBook for $33.99 $22.99
🛠️Useful Tools⚒️
OLake: An open-source tool designed for fast, scalable database replication to Apache Iceberg or data lakehouses, starting with MongoDB.
Hanko: An open-source, passwordless authentication and user management solution with passkeys, SSO, and API-first design.
data-formulator: An open-source AI-powered tool from microsoft for transforming data into rich visualizations using UI and natural language inputs.
That’s all for today.
We have an entire range of newsletters with focused content for tech pros. Subscribe to the ones you find the most useful here.
If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want to advertise with us.
If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just leave a comment below!