Deep Engineering

Bite-sized actionable content, practical tutorials, and resources for programmers#71:Nullable Reference Types in C#, Prompty for VS Code, Python Packaging Tools, and Rust Error HandlingHi ,Welcome to this week’s edition of ProgrammingPro!In today’sExpert Insight, we bring you an excerpt from the recently published book, Functional Programming with C#, which discusses the implementation of Nullable Reference Types (NRTs) in C#, as a tool for developers to handle null references more safely and transparentlyNews Highlights: OSI releases latest draft of Open Source AI Definition; Microsoft releases Prompty, a new VS Code extension for integrating LLMs into .NET development; JetBrains Workspaces offers monorepo benefits exclusively in IntelliJ IDEA; and Survey shows game engines like Godot gaining traction in non-game projects.My top 5 picks from today’s learning resources:What's the deal with setuptools, setup.py, pyproject.toml, and wheels?🛠️Supercharge your testing experience with MSTest.Analyzers⚡The definitive guide to error handling in Rust🛡️Simplicity, Speed, and Re-Use. Shipping Threads in 5 Months🚀Best practices for event logging and threat detection🛑But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefPS:We have finished covering all requests made by you so far through the August survey. We did receive some specific and comprehensive requests around Java and are therefore planning to take out a Collector's Edition on Java sometime next month. If you have any more Java specific requests you would like covered in the special issue, reply to this email and let me know.Sign Up|Advertise🗞️News and Analysis🔎OSI releases latest draft of Open Source AI Definition: The draft clarifies that all components of an AI system must meet open source standards, excludes training data from classification, and updates key terminologies.Kotlin update shines on garbage collector:The update also includes bug fixes, support for newer Gradle versions, and improvements in Kotlin Multiplatform development.The slow evolution of enterprise tech: argues that despite the rapid hype cycles around technologies like cloud computing and gen AI, enterprise tech evolves slowly, with core programming languages and databases remaining largely unchanged over the past decade.JDK 24 preps for restrictions on JNI use: This feature will introduce warnings to prepare for future restrictions, aligning JNI usage with the Foreign Function and Memory (FFM) API.Microsoft Releases Prompty - New VS Code Extension for Integrating LLMs into .NET DevelopmentLike: This free tool simplifies adding AI-driven capabilities to applications, such as generating content or creating chatbots, directly within the development environment.JetBrains Workspaces aims for benefits of monorepos without the downside – but only in IntelliJ IDEA: The plugin addresses issues like monorepo fragility and performance problems by keeping projects independent.Survey finds game engines used equally by non-game projects, rise of interest in open source Godot: The survey also noted the increasing use of JetBrains Rider and VS Code, and challenges in collaboration due to the handling of large files in game development.🎓Tutorials and Learning Resources💡PythonWhat's the deal with setuptools, setup.py, pyproject.toml, and wheels?:Provides a detailed explanation of Python packaging tools and practices, offering insights and recommendations for how to approach packaging in modern projects.Debugging and Profiling in Python: Discusses debugging and profiling tools for Python, highlighting key libraries like pdb, faulthandler, cProfile, and tracemalloc.For more Python resources, go to PythonProC# and .NET🎓Tutorial | Introducing the Pinecone .NET SDK: Provides a step-by-step guide on setting up the SDK, creating an index, adding records, and querying data.Supercharge your testing experience with MSTest.Analyzers: Showcases specific examples of how MSTest.Analyzers help catch common mistakes, and provides recommendations for best practices in test writing.The C# type system: Explains built-in and custom types, the common type system (CTS), and how types influence memory allocation, type safety, and program behavior.C and C++C++ unwind exception metadata - A hidden reverse engineering bonanza: Discusses how C++ unwind exception metadata can aid reverse engineering by revealing hidden details about data structures in C++ programs, particularly those using MSVC/x64 targets.An Overview of C++26 - Core Language: Highlights key features such as reflection, which enhances compile-time programming, and contracts, which allow precise and checkable interface specifications.How to run valgrind on a CGI program in C: Explains how to use Valgrind to debug a memory corruption issue in a CGI program that only manifests during a POST request.Java🎓Tutorial | Better than reflection: Using method handles and variable handles in Java: Discusses replacing Java reflection with MethodHandle and VarHandle for accessing methods and fields programmatically.🎓Tutorial | Method overloading in the JVM: Focuses on techniques like widening, boxing, and varargs. Read to learn about the advantages of method overloading for cleaner code and common pitfalls to avoid.WebAssembly, the Safer Alternative to Integrating Native Code in Java: Highlights the use of Chicory, a pure JVM Wasm runtime, to integrate Wasm-compiled code, such as SQLite, into Java applications, providing strong security guarantees.JavaScript and TypeScriptCompilation of JavaScript to Wasm, Part 2 - Ahead-of-Time vs. JIT: Discusses the challenges of compiling JavaScript due to its dynamic typing and the limitations of traditional JIT (just-in-time) compilation in Wasm-first platforms.Frontend Strategies - Frameworks or Pure JavaScript?: Clarifies when to use frameworks versus pure JavaScript, along with the advantages of modular code, reusable components, and integration with modern development tools.Announcing TypeScript 5.6 RC: Details new features like disallowed nullish and truthy checks, iterator helper methods, and improved built-in iterator checks.GoC# (.NET) vs. Go (Golang): Performance Benchmark in Kubernetes: Focuses on metrics like CPU and memory usage, request handling capacity, and end-user latency. Read to learn how Golang generally performed better.The 4-chan Go programmer: Humorously explores the complexities of using channels in Go by demonstrating a convoluted example of sending channels over channels, inspired by the concept of "4-star programmers" from C.Rust💼Case Study | MiniJinja - Learnings from Building a Template Engine in Rust: Discusses the author's experience and technical challenges in creating MiniJinja, a Jinja2-compatible template engine in Rust.🎓Tutorial | The definitive guide to error handling in Rust: Covers the use of Result, dynamic errors like Box<dyn Error>, and structured errors. Read to also learn about downcasting errors, using the anyhowcrate.SwiftSwift Macros at scale: Introduces Tuist, a tool for managing Xcode projects, which supports caching for Swift Macros, improving build times for developers.Designing Apps: 5 Methods to improve your workflow: Highlights techniques such as using the Golden Ratio, proper spacing for visual hierarchy, designing directly with SwiftUI, gradually enhancing app visuals from basic to vibrant, and more.PHP🎓Tutorial | How to build a game engine in a CMS, in PHP:While acknowledging that it's not an ideal approach, the author details creating a rendering system, implementing game logic, handling collisions, adding animations, and more.SQLEfficient Data Cleanup in Partitioned PostgreSQL Tables using Common Table Expressions: Demonstrates using CTEs to identify deletable data, optimizing the deletion process through batch processing, and maintaining database consistency.Scala and Spark"Domain Modeling" in the Scala 3 - Book: Covers the tools available in Scala, such as classes, traits, and enums, to build models. Read to learn how to effectively represent attributes and behaviors within each paradigm.Spark — debugging a slow Application: Outlines common reasons why Apache Spark applications may run slowly, highlighting issues such as input/source inefficiencies, uneven or excessive partitioning, and slow transformations.[Solution] Spark — debugging a slow Application: Covers techniques such as partitioning, bucketing, and file compaction, and advises on managing partition sizes, leveraging adaptive query execution, avoiding slow transformations, and more.KotlinKotlin's Type System is (Also) Unsound: Presents a proof that Kotlin's type system can allow operations that should not be permissible at runtime. Read to learn about the specific language features involved, and potential solutions.🌟Best Practices and Advice🚀Podcast: Misconceptions around Agile in an AI world: Featuring insights from David Ross, Agile evangelist for Miro, highlights how Agile practices have evolved, moving away from rigid frameworks towards more adaptive and pragmatic approaches.Simplicity, Speed, and Re-Use. Shipping Threads in 5 Months: Describes how despite technical debt and challenges, such as scaling issues on launch day, the team prioritized simplicity and leveraged a battle-tested codebase to meet tight deadlines.Best practices for event logging and threat detection: Developed by the Australian Cyber Security Centre in collaboration with international cybersecurity agencies, this document emphasizes creating an enterprise-approved logging policy, ensuring log quality, centralizing log collection, and implementing secure storage.The Terralith: Monolithic Architecture of Terraform & Infrastructure as Code: Argues for breaking down monolithic structures into smaller, more manageable modules to enhance scalability, maintainability, and reduce risk.🧠Expert Insight📚Here’s an excerpt from “Chapter 4: Honest Functions, Null, and Option” in the book, Functional Programming with C# by Alex Yagur, published in July 2024.Embracing honesty with nullable reference typesHandling null in C# has alwaysbeen quite a challenge. Many software developers (me included) advocate doing a check for NullReferenceExceptions as a mandatory task in a code review checklist. In most cases, it is really easy to check for possible null values just by looking at the pull request, even without an IDE. Recently, we received help when Microsoft introduced nullable reference types. So, now, the compiler will join us in the search of possible disasters causedby null.What are nullable reference types?In the simplest terms,Nullable Reference Types(orNRTsfor short) are a feature in C# that allows developers to clearly indicate whether a reference type can be null or not. With this, C# gives us a tool to make our intentions clear right from the start. Think of it as a signpost, guiding other developers (and even our future selves) about what to expect fromour code.Without NRTs, every reference type in C# could potentially benull. This would create a guessing game. Is this variable going to have a value or is it going to benull? Now, with NRTs, we don’t have to guess anymore. The code itself tellsthe story.Let’s look at a basic example to graspthe concept:string notNullable = "Hello, World!";string? nullable = null;In the preceding snippet, thenotNullablevariable is a regular string that can’t be assignednull(if you try, the compiler will warn you). On the other hand, since C# 8.0, nullable is explicitly marked with?, indicating that it canbenull.In some cases, you might want to assignnullto a variable that is not marked as nullable. In this case, to suppress warnings, you can use the! sign to let the compiler know that you are aware of what you are doing and everything is going according to plan:string notNullable = "Hello, World!";notNullable = null!;One of the biggest advantages of NRTs is that the C# compiler will warn you if you’re potentially doing something risky with null values. It’s like having a friendly guide always looking over your shoulder, ensuring you don’t fall into the common traps ofnull misuse.For instance, if you try to access properties or methods on a nullable reference without checking fornull, the compiler will give you a heads-up.Transitioning to NRTsFor those with existing C# projects, you might be wondering:Will my project be littered with warnings if I enable NRTs?The answer is no. By default, NRTs are turned off. You can opt into this feature, file by file, allowing for asmooth transition.NRTs are a good answer to the long-standing challenge posed by null references. By making the potential presence of null explicit in our code, we take a giant leap toward clarity, safety, and functional honesty. In the end, embracing NRTs not only makes ourcode more resilient but also ensures that our intentions, as developers,are transparent.Enabling nullable reference typesTo enable NRTs, we need to tell the C# compiler that we’re ready for its guidance. This is done using a simple directive:#nullable enable.Place this at the start of your.csfile:#nullable enableFrom this point onward in the file, the compiler creates a specific nullable context and assumes that all reference types are non-nullable by default. If you want a type to be nullable, you’ll have to mark it explicitlywith?.With NRTs enabled, the C# compiler becomes your safety net, pointing out potential issues with nulls in your code. Whenever you try to assign null to a reference type without the?marker or when you attempt to access a potentially null variable without checking it, the compiler willwarn you.Here’san example:string name = null; // This will trigger a warningstring? maybeName = null; // This is okayDisabling nullable reference typesWhile transitioning a project to use NRTs, there may be sections of your code where you’d prefer to delay the transition. You can turn off NRTs for those specific sections using the #nullable disabledirective:#nullable disableThis tells the compiler to revert to the old behavior, treating all reference types aspotentially nullable.You might wonder why C# chose to use directives for this feature. The reason is flexibility. By using directives, developers can gradually introduce NRTs into their projects, one file or even one section of code at a time. This phased approach makes it easier to adaptexisting projects.Warnings and annotations optionsSpeaking of a phased approach, there are two more options to set our nullable contexts:warningsandannotations. You can use them by writingthe following:#nullable enable warningsOr, you canwrite this:#nullable enable annotationsThe main purpose of these options is to ease the migration of your existing code from a fully disabled null context to a fully enabled one. In short, we want to start with thewarningsoption in order to get dereference warnings. When all warnings are fixed, we can switch toannotations. This option will not give us any warnings, but it will start to treat our variables as non-nullable unless declared with the?mark.To get more information about these options and nullable context in generated files, and to find out more about three nullabilities – oblivious, nullable, and non-nullable, I recommend you read the article "Nullable reference types". You might also want to read the article “Update a codebase with nullable reference types to improve null diagnostic warnings”.Functional Programming with C# was published in July 2024. Packt library subscribers can continue readingthe entire book for free or you can buy the bookhere!Get the eBook for $38.99$26.99🛠️Useful Tools⚒️teable: a no-code database platform that combines the ease of a spreadsheet interface with the performance of a database, enabling users to create and manage applications without coding.RealtimeSanitizer (a.k.a. RTSan): a real-time safety testing tool for C and C++ projects that detects and raises errors when non-deterministic functions are called within real-time contexts.Rspack 1.0: a Rust-based JavaScript bundler, fully compatible with the webpack API, offering much faster performance than webpack while supporting modern web standards and improving build efficiency.awesome-decentralized-autonomous-organizations: a curated list of resources and projects for decentralized autonomous organizations (DAOs) to help users start and participate in their own DAOs.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 usefulhere. Complete ProgrammingPro archives can be foundhere. Complete PythonPro archives arehere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any comments or feedback, just respond to this email.*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{line-height:0;font-size:75%}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}.reverse{display:table;width: 100%;

Bite-sized actionable content, practical tutorials, and resources for programmers#84TypeScript 5.7's Never-Initialized Checks, Angular v19's Server Performance, and Cython 3.1's 'No-GIL' BuildsHi ,Welcome to this week’s edition of ProgrammingPro andHappy Thanksgiving if you celebrate! We're grateful for your continued support and passion for learning.In today’sExpert Insight, we bring you an excerpt from the recently published book, Mastering Angular Test-Driven Development, which explains the concept of code smells in Angular applications—indicators of potential issues in code that hinder maintainability and scalability.News Highlights: TypeScript 5.7 adds never-initialized checks and ECMAScript 2024 support; Vite 6.0 debuts with modern Sass API and asset updates; Cython 3.1 supports Python's "no-GIL" builds for better parallelism; and USPTO petitioned to cancel Oracle's JavaScript trademark over alleged abandonment.My top 5 picks from today’s learning resources:Top 65+ Data Science Projects with Source Code📊Replaying Kafka messages: Practical guide with sample code🔄Concepts in C++20💡Architectural Intelligence – The Next AI🏛️The top 25 weaknesses in software in 2024🚨But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefP.S.:Thank you all who participated in this month's survey. With this issue, we have fulfilled all content requests made this month.Sign Up|Advertise🗞️News and Analysis🔎Announcing TypeScript 5.7: The version introduces new features like checks for never-initialized variables, path rewriting for relative imports, support for ECMAScript 2024, and validated JSON imports in Node.js.Release Vite 6.0: Updates include an Experimental Environment API for improved development-production parity, enhanced JSON handling, expanded HTML asset referencing, and modern Sass API as default.Uno Platform Launches Hot Design, a Cross-Platform Visual Designer for .NET Apps: The suite also includesHot Reloadfor code updates andDesign-to-Code, a Figma plugin generating XAML and C# from prototypes.Java News Roundup: OpenJDK and Jakarta EE 11 Updates, Payara Platform, Vert.x, Log4j, JobRunr: Updates also includeMicronaut 4.7.1,JobRunr 7.3.2, and Gradle 8.11.1 maintenance releases.Python to C: What’s new in Cython 3.1: The version introduces significant updates, including experimental support for Python's free-threaded "no-GIL" builds in Python 3.13, enhancing parallelism for CPU-bound threads.USPTO petitioned to cancel Oracle’s JavaScript trademark: Deno Land has petitioned the USPTO to cancel Oracle's ownership of the JavaScript trademark, accusing Oracle of abandonment and fraud, citing no active role since 2009.Kotlin to lose scripting features: JetBrains plans to phase out certain scripting features in Kotlin, including REPL functionality, Java Specification Request 223 support, the KotlinScriptMojo Maven plugin, and kotlin-scripting-ide-services.🎓Tutorials and Learning Resources💡Python💡Top 65+ Data Science Projects with Source Code: Covers diverse areas like machine learning, NLP, deep learning, web scraping, and data visualization with real-world datasets and practical challenges.🎓Tutorial | Speed Up Your Python Program With Concurrency: Explains threading, asynchronous tasks, and multiprocessing, demonstrating how to optimize I/O-bound and CPU-bound tasks for improved performance.For more Python resources, go to PythonProNoSQL and Spark🎓Tutorial | Evolving a NoSQL Database Schema: Covers creating a single-table design, optimizing queries with keys and indexes, handling sharding for scalability, and enabling efficient cross-partition querying.💡Spark structured streaming — Checkpointing: Explains how Checkpointing aids in fault tolerance by maintaining stream state and offsets along with implementation details and surprising behaviors when configuring parameters.C# and .NET🎓Tutorial | Master Cache in C#: Covers IMemoryCache,IDistributedCache, andHybridCache and discusses when to use caching, its benefits, challenges, and patterns, including cache invalidation and metrics.🎓Tutorial | My process for creating API clients: Outlines a structured process for creating API clients in C# using Flurl, balancing automation and control between tools like HttpClient, Refit, and Kiota.💡C# puzzles: Presents two C# puzzles focusing on unconventional behavior: making modifications to StringBuilderobjects through aSecretSaucefunction without unsafe operations or external interference.C and C++🎓Tutorial | Concepts in C++20:Explains how C++20 concepts simplify template constraints, replacing SFINAE with readable, expressive syntax and highlights four ways to apply concepts for enhanced error clarity.🎥💡How Designing Carbon C++ Interop Taught me About C++ Variadics & Bound Members - Chandler Carruth: Introduces Carbon's type-checked variadic functions, enabling safer and more reliable templates.🎓Tutorial | Bubble Sort Implementation Using a Single for Loop in C: Presents an alternative implementation of Bubble Sort in C using a single forloop instead of nested loops.Java🎓Tutorial | Replaying Kafka messages: Practical guide with sample code: Covers three approaches: offset-based replay, mirror topics, and custom replay services and explains use cases with sample Java code.💡How Fast Does Java Compile?: Examines the speed of Java compilation, revealing that the Java compiler (javac)can process over100,000 lines of code per second on a single core when warmed up.Reactive Real-Time Notifications with SSE, Spring Boot, and Redis Pub/Sub: Highlights the advantages of a reactive approach, such as improved scalability and resource utilization, along with practical integration guidance.JavaScript and TypeScriptDevelop AI apps with JavaScript: Includes quickstart guides, libraries, templates, and training for tasks like text generation, image analysis, and NLP, focusing on Azure OpenAI Service and other Azure AI services.🎓Tutorial | JavaScript Sets and Maps: Beyond Arrays and Objects: Discusses Sets and Maps' advantages over arrays and objects, when to use them, and their ability to handle unique values and maintain key types.🎓Tutorial | Almost Perfect tsconfig.json Options for Your Angular Projects: Provides a step-by-step guide to optimizing the tsconfig.json file for Angular 18 projects, covering configurations for TypeScript compiler options.Go🎓Tutorial | Go Production Performance Gotcha - GOMAXPROCS: Discusses a performance issue in a Go-based workload caused by not explicitly setting the GOMAXPROCS parameter, leading to high CPU usage.💼Case Study | Are Golang Generics Simple or Incomplete? A Design Study: Explores the simplicity versus incompleteness of Go's generics by presenting a case study involving Map,MutableMap, andIndextypes in a version-controlled SQL database.Rust🎓Tutorial | Rust for AWS Lambda, the Docker Way: Walks you through using Cargo Lambda for simplified Rust Lambda development and presents two Dockerfile configurations including one supporting cross-compilation.💼Case Study | Making Rust a first-class citizen for Xen: Discusses Vates' efforts to integrate Rust into the Xen Project by developing pure-Rust alternatives to C-based libraries, creating safer, more efficient tools.Swift🎓Tutorial | Calling Hidden Swift Functions: Delves into techniques for calling hidden Swift functions, specifically those within Apple's frameworks, which are not directly accessible due to access level restrictions.🎓Tutorial | Mock Your Remote Config🧑‍💻: Provides a step-by-step guide on using protocols, dependency injection, and mock implementations.PHP🎓Tutorial | Step-by-Step Guide to Installing PHP 8.4 on Ubuntu 24.04 with Nginx & MySQL: Covers system updates, adding the Ondřej PHP repository, installing PHP with necessary extensions and configuring PHP-FPM with Nginx.SQL📜Towards Optimizing SQL Generation via LLM Routing: This paper introduces the first LLM routing approach for Text-to-SQL, dynamically selecting cost-effective LLMs for accurate SQL generation based on query complexity.Ruby💡10 Costly Ruby on Rails Upgrade Mistakes to Avoid in 2025: Identifies common pitfalls and provides actionable strategies to ensure a secure, performant, and seamless transition, reducing costs and enhancing stability.Powershell💡Attacking PowerShell CLIXML Deserialization: Explores vulnerabilities which can lead to remote code execution through untrusted data and recommends including patching systems, limiting third-party PowerShell modules, and more.Kotlin🎓Tutorial | Kotlin for Java developers: Concurrency with coroutines: Covers Kotlin's concurrency model using coroutines, demonstrating key features like scopes, dispatchers, contexts, channels, and flows.🌟Best Practices and Advice🚀Architectural Intelligence – The Next AI: Advocates for using traditional trade-off analysis to evaluate the appropriateness of AI for specific scenarios, distinguishing between suitable, questionable, and inappropriate use cases.What if AI eventually makes programmers smarter, not dumber: Argues that AI, particularly through LLMs, is transforming programming by reducing the time spent on repetitive coding tasks and enabling you to focus on problem-solving.How McDonald Sells Millions of Burgers Per Day With Event-Driven Architecture:Discusses how the architecture facilitates asynchronous operations, transactional processing, and real-time event handling.State of Software Architecture Report — 2024: Discovered widespread use of diagramming tools (96%) and collaborative wikis (79%) for documenting architecture, with microservices (67%) and event-driven patterns (62%) being the most common.The top 25 weaknesses in software in 2024: This year’s list, based on 31,779 CVEs, emphasizes classic weaknesses alongside notable changes, including upward movements for Cross-Site Request Forgery (CSRF) and Code Injection.🧠Expert Insight📚Here’s an excerpt from “Chapter 11: Refactoring and Improving Angular Code through TDD" in the book, Mastering Angular Test-Driven Development by Ezéchiel Amen AGBLA, published in October 2024.Identifying code smells and areas for improvement in Angular applicationsWhile your Angular application might seem functional on the surface, there could be underlying issues waiting to erupt. These issues, known as code smells, don’t necessarily causeimmediate problems but indicate areas in your codebase that could benefit from refactoring. Just like a cluttered room can be stressful and unproductive, smelly code can make it difficult to maintain, understand, and extend your application. This section delves into the world of code smells in Angular applications. We’ll explore what they are, why they matter, and how to identify them proactively. By understanding these code smells, you’ll be equipped to prioritize refactoring efforts using TDD, ultimately leading to a cleaner, more maintainable, and robust code base.What are code smells?Imagine walking into a kitchen where dirty dishes are piled up high in the sink, spices are scattered across the counter, and expired food lingers in the fridge. This unpleasant scene might not prevent you from cooking a basic meal, but it certainly wouldn’t be an enjoyable or efficient experience. Code smells are analogous to this messy kitchen in the softwaredevelopment world.Coined by Martin Fowler in his book,Refactoring: Improving the Design of Existing Code, code smells are indicators of potential problems within your code base. They don’t necessarily represent functional bugs that cause the application to crash. Instead, they signify areas that could be improved for better readability, maintainability, and long-term health ofyour code.Code smells are not bugs, but they can attract bugs in the future. They act like red flags, warning you of potential trouble spots that could become problematic as yourapplication evolves.Why should we care about code smells in Angular?Ignoring a messy kitchen might lead to unpleasant odors, fruit flies, and frustration when you need to cook a meal. Similarly, neglecting code smells in your Angular application can have severalnegative consequences:Decreased maintainability: Smelly code becomes difficult to understand and modify over time. As your application grows and features are added, the complexity of tangled code can make changes cumbersome anderror prone.Increased debugging time: When bugs arise in smelly code, it can be challenging to pinpoint the root cause. The lack of clear structure and organization makes it like searching for a needle in a haystack, wasting valuabledeveloper time.Reduced team productivity: Working with smelly code can be frustrating and demotivating for developers. The cognitive overhead of deciphering tangled logic slows down development andhinders collaboration.Technical debt: Unattended code smells accumulate over time, creating a technical debt that needs to be addressed eventually. This debt can become a significant burden, requiring dedicated resources and potentially delaying newfeature development.By proactively identifying and refactoring code smells, you can dothe following:Improve code readability: Clean and well-structured code is easier to understand for both you and other developers working on the project. This reduces onboarding time for new team members and fostersbetter collaboration.Enhance maintainability: Refactored code is easier to modify and adapt as your application’s requirements evolve. This allows you to introduce new features and bug fixesmore efficiently.Reduce debugging time: Cleaner code with a clear separation of concerns makes it easier to isolate and fix problems whenbugs arise.Boost team productivity: Working with well-structured code improves developer experience and satisfaction. This leads to higher productivity and a more positivedevelopment environment.Minimize technical debt: By addressing code smells early on, you prevent them from accumulating and becoming a significant burden inthe future.In essence, prioritizing code smell refactoring is an investment in the long-term health and maintainability of yourAngular application.Identifying the most common code smells in Angular applicationsNow that we understand the importance of identifying code smells, let’s take a look at some of the most common offenses you might encounter in yourAngular application:The long and winding method: Imagine a method in your service that stretches across dozens of lines, handling various tasks. This is a prime example of a long method, a code smell suggesting a lack of modularity. These methods can be difficult to understand, test, and modify. Refactoring involves breaking down such behemoths into smaller, well-defined functions, each focusing on a specific task. This enhances code readabilityand maintainability.The god component: Have you encountered a component overloaded with responsibilities? This is a “god component,” handling everything from data fetching to complex UI logic. Such components become maintenance nightmares as changes in one area can ripple through the entire component, causing unintended consequences. Refactoring can involvethe following:Creating dedicated services: Extract functionalities related to data access, business logic, or calculations into separate services. These services can be reused by multiple components, promotingbetter organization.Splitting the component: Break down the god component into smaller, more focused components, each handling a specific aspect of the UIor functionality.The code duplication monster: Seeing the same block of code copy-pasted across different parts of your application? This code duplication not only wastes space but also makes maintenance a challenge. Any bug fix in one instance needs to be replicated across all copies. Refactoring involves identifying these repetitive code snippets and creatingthe following:Reusable components: If the duplicated code deals with UI elements, consider creating a reusable component that can be used inmultiple places.Services or utility functions: For duplicated logic unrelated to the UI, extract them into services or utility functions that can be sharedacross components.The magic number mystery: Scattered numeric constants with no clear meaning throughout your code base are like magic tricks; they are confusing and difficult to maintain. Imagine having a constant10used for pagination but its purpose is unclear. Refactoring involves replacing these magic numbers with named variables or constants. For example, useITEMS_PER_PAGEinstead of10, making the code more self-documenting and easierto understand.The spaghetti code maze: Imagine code that winds and twists, lacking clear structure and organization. This is spaghetti code, making it a challenge to navigate, understand, and modify. TDD can be a powerful tool to combat spaghetti code. By writing tests first and then refactoring the code to meet those tests, you can introduce structure and improve the overall organization of yourcode base.Mastering Angular Test-Driven Developmentwas published in October 2024. Packt library subscribers can continue reading the entire book for free or you can buy the bookhere!Get the eBook for $30.99$20.98🛠️Useful Tools⚒️superflex-vscode: AI-driven VSCode tool turning Figma, images, and prompts into production-ready frontend code.jekyll-sqlite: A a plugin enabling SQLite as a data source for dynamic Jekyll sites using SQL queries.lovable: AI-driven full-stack assistant that rapidly converts ideas into production-ready apps, enabling fast prototyping, editing, and deployment.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#81Debugging Linux Scripts, Tabnine's Code Review Agent, and Zed Editor's SSH RemotingHi ,Welcome to this week’s edition of ProgrammingPro!In today’sExpert Insight, we bring you an excerpt from the recently published book, The Ultimate Linux Shell Scripting Guide, which explains how to use -u and set -u in shell scripts to identify uninitialized variables and prevent related errors during debugging.News Highlights:Zed editor adds SSH remoting for faster remote workflows; IBM’s AI agents automate GitHub issue resolution; Java’s JEP 491 boosts concurrency with virtual thread improvements; and Tabnine’s Code Review Agent enforces custom coding standards.My top 5 picks from today’s learning resources:Hidden Python Libraries That Will Blow Your Mind✨The magic of keeping one level of abstraction per function🎩Writing secure Go code🐹Being a Responsible Developer in the Age of AI Hype⚖️Using certifications to level up your development career🏆But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-Chief🚀Join this 3-hour AI Workshop (worth $399) - FREE for ProgrammingPro readers to learn AI strategies & hacks to 10X work output and grow your business.🗓️ Tomorrow | ⏱️ 10 AM ESTClick here to register (FREE for the First 100 people only)!Sign Up|Advertise🗞️News and Analysis🔎Rust-based Zed editor preview adds direct SSH remoting, a key feature for potential VS Code switchers: Zed emphasizes speed, performance, and real-time collaboration, appealing to developers seeking a faster, lighter alternative.Tabnine’s new Code Review Agent validates code based on a dev team’s unique best practices and standards: The agent is an AI tool that validates code, flags issues during code reviews, and offers fixes.IBM releases open AI agents for resolving GitHub issues: IBM’s SWE-Agent 1.0, a set of AI-powered open agents, automates GitHub issue resolution, helping developers by localizing, suggesting fixes, and executing tests.Java Evolves to Tackle Virtual Threads Pinning with JEP 491: The change would improve scalability and performance in highly concurrent applications by allowing threads to unmount from platform threads during synchronization.Apache Tomcat 11.0 Delivers Support for Virtual Threads and Jakarta EE 11: The update enhances concurrency, scalability, and security for modern web applications, with upgrades in WebSocket and Servlet performance.Microsoft Introduces Modern Web App Pattern for .NET: Accelerating App Modernization to the Cloud: The pattern guides developers in transforming monolithic applications to cloud-native architectures with a focus on scalability.Amazon Q Developer is not just for coding and not just for AWS, claims cloud giant:It includes features like multi-file edits, unit testing, and security scanning, and plans to add support for Eclipse IDE.🎓Tutorials and Learning Resources💡PythonHidden Python Libraries That Will Blow Your Mind:Introduces six powerful yet lesser-known Python libraries including Streamlit for quick app-building, PyWhatKit for task automation, and Typer for simplified CLIs.For more Python resources, go to PythonProC# and .NET🎓Tutorial | Unlocking the Power of GitHub Models in .NET with Semantic Kernel: Explains how to set up necessary packages, configure access with GitHub tokens, establish a Semantic Kernel client, and run a chat-based application.🎓Tutorial | eShop infused with AI – a comprehensive intelligent app sample: Demonstrates how to integrate AI functionalities like semantic search, summarization, classification, and sentiment analysis into business applications.🎓Tutorial | How to prevent XSS Attacks in ASP.NET Core Web API: Covers essential practices such as input validation, output encoding, and advanced measures like Content Security Policy (CSP) and secure cookies.C and C++🎓Tutorial | Deep Threads Diving Into The Core Of Concurrent Programming With C: Covers core concepts like threads vs. processes, key functions in POSIX threads (pthreads), and synchronization techniques.📖Open Access Book | Is Parallel Programming Hard, And, If So, What Can You Do About It?: Serves as a guide for programming shared-memory parallel systems, offering foundational techniques to prevent common pitfalls.C++, Complexity, and Compiler Bugs: Explores challenges such as temporary lifetime extension, differences in designated initializers between C++ and C, and inconsistent handling of template disambiguation across compilers.JavaJava-Based No-Code and Low-Code Application Bootstrapping Tools: Reviews four Java-based no-code and low-code platforms: Appsmith, Wavemaker, Openkoda, and JHipster.🎓Tutorial | Building thread-safe abstractions in Java versus Go: Through examples, the author compares Java's synchronized keyword for mutual exclusion with Go’s sync.Mutex and channels, showcasing adaptations needed.🎓Tutorial | Server-Side Rendering with Spring Boot: Explains how to use WebJars for managing client-side dependencies via Maven and Thymeleaf for server-side rendering in Spring Boot.JavaScript and TypeScript🎓Tutorial | The magic of keeping one level of abstraction per function: Advocates for breaking down complex tasks into focused, smaller functions, to achieve cleaner code that is easier to update, reuse, and understand.Summary of the AJAX frameworks comparison: Compares Vue.js, Alpine.js, HTMX, and Vaadin—across frontend skills required, team integration, setup ease, and styling flexibility.20 TypeScript Tips for Cleaner, More Efficient Code in 2024: Tips include NonNullable, Partial, Readonly, Mapped Types, Union Exhaustiveness, and Generics, with practical examples demonstrating each.Go🎓Tutorial | Writing secure Go code: Covers tools like go vet, staticcheck, golangci-lint, govulncheck, and gosec which support code analysis and vulnerability detection, and fuzz testing which helps find security flaws.🎓Tutorial | Ranging over functions in Go 1.23: Introduces Go 1.23’s new feature allowing for-range iteration over functions, enhancing custom container iteration without exposing internal data structures.RustRust's Most Subtle Syntax: Explores how Rust’s pattern-matching rules with constants can introduce subtle bugs, especially if naming conventions aren’t followed consistently.Bringing faster exceptions to Rust: Explores speeding up Rust’s panic handling by optimizing the unwinding mechanism, resulting in a 4.3x speed improvement without changing the Rust compiler or system unwinder.Swift🎓Tutorial | swift-format GitHub Action: Covers setting up swift-format as a GitHub Action to automate linting and formatting for Swift projects, including configuration tips and integration with Xcode 16.🎓Tutorial | How to Use URLSession with Async/Await for Network Requests in Swift: Covers GET and POST methods, adding parameters, and decoding JSON responses into Swift structs.PHP🎥🎓Tutorial | Laravel for Beginners:This video series offers a step-by-step introduction to Laravel, covering essentials like setting up, routing, views, Blade directives, layouts, components, and CSS integration with Tailwind.SQL🎓Tutorial | Advanced SQL for Data Professionals: Covers common table expressions (CTEs) for recursive queries, methods to remove duplicates, ways to identify new records, strategies for filling gaps in data, and more.Ruby🎓Tutorial | Understanding Ruby 3.3 Concurrency: A Comprehensive Guide: Covers Threads, Fibers, and Ractors, explaining each's distinct use cases, performance trade-offs, and resource utilization.Kotlin🎓Tutorial | Serializing SQL: Building Serializable Data Classes in Kotlin: Describes building a system in Kotlin to serialize SQL queries into data classes using JSON, enabling dynamic SQL functions like SUM, and COUNT.🌟Best Practices and Advice🚀Cell-Based Architecture Adoption Guidelines: Outlines guidelines for adopting cell-based architecture, a strategy that enhances system resilience by isolating failures, ideal for high-availability systems.Being a Responsible Developer in the Age of AI Hype: Discusses recognizing that AI models like LLMs generate plausible text rather than true reasoning, questioning claims of AI’s capabilities, and addressing biases and ethical risks.A deep look into our new massive multitenant architecture: Explores the the architectural overhaul undertaken by Glauber Costa's team at Turso, focusing on adopting Deterministic Simulation Testing (DST).Using certifications to level up your development career: Explains how obtaining relevant, vendor-neutral certifications can boost developers' careers by validating their skills, improving job prospects, and potentially increasing pay.🧠Expert Insight📚Here’s an excerpt from “Chapter 21: Debugging Shell Scripts" in the book, The Ultimate Linux Shell Scripting Guide byDonald A. Tevault, published in October 2024.Checking for Undefined VariablesAs I said at the beginning of this chapter, in theUnderstanding Common Scripting Errors section, it’s sometimes desirable to define a variable in a script without assigning an initial value to it. But, sometimes it isn’t. You can track down uninitialized variables by appending a -uto the end of your shebang line.In bashfor example, you can use#!/bin/bash -u, which will turn this feature on for the entire script. Or, you can place aset -u command any place in the script where you’d like to start checking. For example, let’s look at the unassigned_var1.sh script, which has variable checking turned off:#!/bin/bashecho "The uninitialized myvar, without setting -u, looks like this : " $myvarechomyvar=Donnieecho "I've just initialized myvar."echo "The value of myvar is: " $myvarHere’s the output:donnie@fedora:~$ ./unassigned_var1.shThe uninitialized myvar, without setting -u, looks like this :I've just initialized myvar.The value of myvar is: Donniedonnie@fedora:~$As you see, without the-usetting, the script runs to completion. It’s just that trying to echo the value of the uninitializedmyvarjust shows us a blank space. Next, let’s turn on variable checking by adding the-u option, as you see in the unassigned_var2.sh script:#!/bin/bash -uecho "The uninitialized myvar, without setting -u, looks like this : " $myvarechomyvar=Donnieecho "I've just initialized myvar."echo "The value of myvar is: " $myvarLet’s see what this does:donnie@fedora:~$ ./unassigned_var2.sh./unassigned_var2.sh: line 2: myvar: unbound variabledonnie@fedora:~$This time the script failed as soon as it saw the uninitialized variable.You can set the-uoption anywhere in the script you like, by usingset -u, as you see here in theunassigned_var3.shscript:#!/bin/bashecho "The uninitialized myvar, without setting -u, looks like this : " $myvarechoecho "I'm now setting -u."set -umyvar=Donnieecho "I've just initialized myvar."echo "The value of myvar is: " $myvarechoecho "Let's now try another uninitialized variable."echo "Here's the uninitialized " $myvar2So now, I have one uninitialized variable at the top, on line 2. (Let’s just say that for whatever reason, I want this particular variable to be uninitialized.) I then turn on variable checking on line 5. Let’s see how this runs:donnie@fedora:~$ ./unassigned_var3.shThe uninitialized myvar, without setting -u, looks like this :I'm now setting -u.I've just initialized myvar.The value of myvar is: DonnieLet's now try another uninitialized variable../unassigned_var3.sh: line 11: myvar2: unbound variabledonnie@fedora:~$Before I turn on variable checking, the uninitializedmyvarjust shows us a blank space. After I turn on variable checking, I initializedmyvarwith a value ofDonnie, and it prints out normally. But, the uninitializedmyvar2at the end crashes the script.NOTE:If you search the web for shell scripting security tutorials, you’ll find several that tell you to make either -uorset -ua permanent part of your scripts. The authors of these tutorials say that it enhances the security of your scripts, without giving any convincing explanation of why or how. Using-uorset -uis great for debugging, but it should only be used for just that—debugging! So, when you’re through debugging your scripts, be sure to remove the-uor theset -ubefore you place the script into production. Otherwise, your scripts could give you some rather unpredictable results.Also, be aware that using-ucan also help you detect typos in your scripts. For example, if you define a variable asmynum=1, but accidentally call back the value with$mymum, the-uwill detect thatmymumis an unset variable.The Ultimate Linux Shell Scripting Guidewas published in October 2024. Packt library subscribers can continue reading the entire book for free or you can buy the bookhere!Get the eBook for $43.99$29.99🛠️Useful Tools⚒️PipelineDP4j: Google’s open-source JVM library for differential privacy in Java, Kotlin, and Scala, supporting Apache Beam.Whirlwind: A high-performance, asynchronous sharded HashMap in Rust for thread-safe, concurrent data access.Modus: An open-source, serverless framework for fast APIs and AI functions using WebAssembly, with support for AssemblyScript and Go.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#83Unreal Engine 5's AI Perception, Fil-C's Memory Safety for C++, Go's AI Evolution, and Python In-Memory ComputingScale your scrapers with Apify’s Black Friday Boost plan!Get a 30% prepaid usage bonus on Apify this Black Friday. Scrape data for app integrations, performance tracking, competitive research, or custom pipelines. Use pre-built scrapers, build your own from scratch, or use quick-start code templates.The Boost plan ends December 5 - grab it while you can!Claim your bonus now!Hi ,Welcome to this week’s edition of ProgrammingPro!In today’sExpert Insight, we bring you an excerpt from the recently published book, Artificial Intelligence in Unreal Engine 5, which introduces Unreal Engine 5's AI Perception System, detailing its components, predefined sense configurations, and how developers can use or customize it.News Highlights: Fil-C tackles memory safety in C/C++ without requiring a new language; Go advances for AI and hardware efficiency with improved garbage collection; Rust Foundation enhances C++ interoperability with better tools and collaboration; and F# 9 introduces nullable reference types, computation expressions, and library upgrades.My top 5 picks from today’s learning resources:Researchers develop Python code for in-memory computing — in-memory computation comes to Python code🧠Speeding up the Rust edit-build-run cycle⚡C# 13 and .NET 9: Personal Highlights🎯Clean Architecture: The Missing Chapter🏗️How I Used Event-Driven Architecture in the Wrong Way🔄But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefP.S.:This month'ssurvey is still live. Do take the opportunity to leave us your feedback, request a learning resource, and earn your one Packt credit for this month.Sign Up|Advertise🗞️News and Analysis🔎Java News Roundup: Spring Framework 6.2, OpenJDK JEPs, Micronaut 4.7, Gradle 8.11: Other highlights include Project Reactor 2024.0.0, with enhancements spanning dependency upgrades and other new features.Rust haters, unite! Fil-C aims to Make C Great Again: Fil-C, a memory-safe variant of C and C++ developed by Filip Pizlo aims to address memory safety vulnerabilities, without requiring developers to learn a new language.F# 9 adds nullable reference types: The version also introduces empty-bodied computation expressions, and standard library enhancements like random sampling and shuffling functions.Go language evolving for future hardware, AI workloads:The Go team is working on improving garbage collection, introducing hardware-efficient features, and integrating AI SDKs like LangChainGo.Rust Foundation moves forward on C++ and Rust interoperability: The initiative focuses on enhancing tools, building consensus for long-term solutions, and collaborating with the C++ community to address challenges.JetBrains releases IntelliJ IDEA 2024.3 and other IDEs, still struggles to convince devs of benefits of new UI: Updates have been made to PHPStorm, PyCharm, and GoLand. Improvements include Logical code structure view.Uno Hot Design aims to meet demand for a visual designer for modern .NET: Hot Design isa visual design tool in the Uno Platform Studio suite to address the lack of a designer for modern .NET development, including WinUI.🎓Tutorials and Learning Resources💡Python🗞️Researchers develop Python code for in-memory computing — in-memory computation comes to Python code:Technion researchers have developedPyPIM, a tool that translates Python code into machine code for in-memory computing, enabling programmers to use Python without adaptation.For more Python resources, go to PythonProC# and .NET🎓Tutorial | Events and Delegates in C#: Covers the definition, implementation, and practical use of events and delegates in C#, including their benefits, use cases, and challenges, with examples and best practices.💡C# 13 and .NET 9: Personal Highlights: Reviews highlights of C# 13 and .NET 9, including enhanced performance, AI integration, improved params collections, new thread synchronization tools, and implicit index access.🎓Tutorial | Mastering Divide and Conquer (D&C): A Fundamental Algorithmic Paradigm: Explains the paradigm, detailing its practical applications with examples like Merge Sort and curated LeetCode problems.C and C++💼Case Study | Retrofitting spatial safety to hundreds of millions of lines of C++: Outlines Google's efforts to enhance spatial memory safety in its vast C++ codebase by retrofitting hardened libc++ with bounds checking.🎓Tutorial | Non-allocating Circular Buffer in C++: Explains circular buffers in C++, highlighting their fixed capacity and ability to overwrite the oldest data when full.🎓Tutorial | You can use C-Reduce for any language: Demonstrates the versatility of C-Reduce, a tool initially designed to minimize C compiler bug reproducers, with an example involving RustPython.Java🎓Tutorial | A Basic Introduction to the Classfile API: Introduces the Classfile API, providing a basic guide to generating JVM bytecode by constructing class files programmatically.🎓Tutorial | The Ultimate Linked List Guide: Become a Hero with All Methods and Theory in Java (Part-2): Introduces methods for inserting nodes at the start, end, or a specific index in the list to maintain the structure.💼Case Study | Java Backend Observability with OpenTelemetry Traces and Minimal Code: Explores how the MY.GAMES team integrated OpenTelemetry into their Java backend for Rush Royale to improve system observability.JavaScript and TypeScript🎓Tutorial | Importing a frontend Javascript library without a build system: Covers the three main types of JavaScript files (classic, ES Modules, and CommonJS), their characteristics, and methods for importing them.🗞️Meet Angular v19: Key updates include incremental hydration for server-side rendering, event replay stabilization, route-level render modes, and experimental zoneless support.💼Case Study | Adopting Bazel for Web at Scale: details Airbnb's migration of its large-scale web monorepo to Bazel, highlighting challenges, custom solutions, and performance gains in CI processes and developer workflows.Go🎓Tutorial | Constraints in Go: Explores constraints as tools for enhancing type safety and functionality in generic programming by defining permissible operations for types through method sets, unions, and approximations.🎓Tutorial | Testing with Go and PostgreSQL: ephemeral DBs: Explains how to integrate ephemeral PostgreSQL instances into Go testing workflows, optimizing setup for convenience, resource efficiency, and reduced test times.Rust🎓Tutorial | Speeding up the Rust edit-build-run cycle: Showcases steps like using faster linkers (e.g., Mold), minimizing debug information, and creating non-position-independent executables.🎓Tutorial | Build your own SQLite, Part 3: SQL parsing 101: Introduces tokenization and parsing concepts, implements a tokenizer to process SQL strings, defines an AST structure for SQL statements, and more.Swift🎓Tutorial | Syntax Highlighting SwiftUI Code with Swift Syntax: Demonstrates how to implement native SwiftUI syntax highlighting in an app using the swift-syntax library.🎓Tutorial | MainActor usage in Swift explained to dispatch to the main thread: Explains the usage of @MainActor in Swift, a global actor introduced in Swift 5.5 to ensure tasks are executed on the main thread.PHP📜Fuzzing the PHP Interpreter via Dataflow Fusion: Presents FlowFusion, the first automated fuzzing framework, validated by PHP developers, tailored to detect memory errors in the PHP interpreter.🗞️PHP 8.4.0 Released!: The major update introduces property hooks for computed properties, asymmetric visibility for enhanced property access control, the #[\Deprecated] attribute for user-defined deprecation warnings, and more.SQL💼Case Study | Presto® Express: Speeding up Query Processing with Minimal Resources: Delves into Uber's Presto Express which optimizes short-running SQL queries and reduces end-to-end SLA.💡SQL Style Guide: Covers best practices for naming conventions, query syntax, and formatting, aiming to enhance code clarity and facilitate collaboration among developers.Ruby🗞️2024 Ruby on Rails Community Survey Results: Highlights include a growing focus on maintaining applications with the latest Ruby and Rails versions despite challenges like dependency management.💡Elixir-like pipes in Ruby (oh no not again): Explores an experimental implementation of an Elixir-style pipe operator in Ruby, leveraging abstract syntax tree (AST) transformations to enable pipeline-style coding.Kotlin🗞️State of Kotlin Scripting 2024: Highlights that while Kotlin scripting remains a vital part of the Kotlin ecosystem, its adoption has been limited.🎓Tutorial | Understanding Properties in Kotlin: Covers mutable and read-only properties, custom getters and setters, backing fields, compile-time constants, late-initialized properties, and delegated properties.🌟Best Practices and Advice🚀Transforming Legacy Healthcare Systems: A Journey to Cloud-Native Architecture: Examines the challenges of modernizing legacy healthcare systems into cloud-native architectures, using Livi's transformation of its MJog platform as an example.Clean Architecture: The Missing Chapter: Critiques traditional layer-based structures for scattering related components, advocating instead for organizing code by features or components.To Dare or Not to Dare: the MVA Dilemma: Explores the challenges of balancing business and technical risks when developing a Minimum Viable Product (MVP) and its supporting Minimum Viable Architecture (MVA).How I Used Event-Driven Architecture in the Wrong Way: Reflects on the challenges of implementing event-driven architecture, highlighting issues such as managing two-way communication and handling complex event chains.🧠Expert Insight📚Here’s an excerpt from “Chapter 10: Improving Agents with the Perception System" in the book, Artificial Intelligence in Unreal Engine 5 by Marco Secchi, published in October 2024.Presenting the Perception System...One of the key components when creating intelligent and reactive AI agents in Unreal Engine is the AI Perception System; this powerful system allows AI controllers – and, consequently, AI agents – to perceive and respond to different stimuli intheirvirtual environment.At the core of the AI Perception System aresensesandstimuli. A sense – such as sight or hearing – represents a way for an AI agent to perceive its surroundings and is configured to detect specific types of stimuli, which are sources of perception data emanating from other actors in thegame world.As an example,sight senseis preconfigured to detect any visible pawn actors, whiledamage sensetriggers when the associated AI controller’s pawn takes damage from anexternal source.NoteAs a developer, you can create custom senses tailored to your game’s specific needs by extending theAISense class, if you are working with C++, or the AISense_Blueprintclass, if you are workingwith Blueprints.Presenting the Perception SystemThe AI Perception System consists of the followingmain classes:AIPerceptionSystem: This is the core manager that keeps track of all AIstimuli sources.AIPerceptionComponent: This represents the AI agent’s mind and handles processing perceived stimuli. It needs to be attached to an AI controller toproperly work.AIPerceptionStimuliSourceComponent: This component is added to actors that can generate stimuli and is in charge of broadcasting perception data tolistening elements.AIPerceptionSenseConfig: This defines the properties of a specific sense, what actors can be perceived, and how perception decays over timeor distance.When an actor withAIPerceptionStimuliSourceComponentgenerates a stimulus, nearbyAIPerceptionComponentsdetect it through their configured senses. This perceived data is then processed by the AI controller to triggerdesired behaviors.Once you have addedAIPerceptionComponentto an AI controller, you will need to add one or moreAIPerceptionSenseConfigelements in order to give your AI agent dedicated senses.Figure 10.1shows an example where perception is basedon touch:Figure 10.1 – The touch sense configFrom the previous screenshot, you may have noticed aDominant Senseproperty; this property allows you to designate a specific sense that takes priority over others when determining the location of asensed actor.Let’s explore the available sense configs that, as mentioned earlier, define the properties of eachspecific sense:AIPerceptionSenseConfig typesUnreal Engine offers a range of predefinedAIPerceptionSenseConfigclasses that are highly likely to meet your specific requirements. Let’s take a look at theavailable options:AIDamage: Use this configuration if your AI agent needs to respond to damage events such asAny Damage,Point Damage, orRadial DamageAIHearing: Use this configuration if you need to detect sounds generated in thesurrounding environmentAIPrediction: Use this configuration when you need to predict the target actor location in the nextfew momentsAISight: Use this configuration when you want your AI agent to see things inthe levelAITeam: Use this configuration if you want to notify the AI agent that some allyis nearbyAITouch: Use this configuration when the AI agent touches some other actor or, vice versa, when something is touching theAI agentStimuli sourceTheAIPerceptionStimuliSourceComponentclass allows an actor to register itself as a source of stimuli for one or more senses. For instance, you can register an actor as a stimuli source for sight. This registration allows an AI agent to visually perceive the actor in thegame level.A stimuli source can be registered – or unregistered – for a sense, making it detectable – or undetectable – by thePerception System.Artificial Intelligence in Unreal Engine 5was published in October 2024. Packt library subscribers can continue reading the entire book for free or you can buy the bookhere!Get the eBook for $39.99$27.98🛠️Useful Tools⚒️fast-graphrag: Acost-efficient, dynamic, and interpretable framework for building scalable, agent-driven retrieval-augmented generation pipelines.pglite-fusion: A PostgreSQL extension that embeds SQLite databases into table columns, offering streamlined multitenancy and efficient data isolation.fireproof: An open-source live-update database enabling real-time collaboration, seamless integration with any stack, and deployment anywhere.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, take the surveyor just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#93:CMake for Dependency Management, Faster TypeScript, AI Agent Tools, and Rust-Powered NVIDIA DriverHi ,Welcome to a brand new issue of ProgrammingPro.In today’s special edition of Expert Insight, we bring you an original article, "CMake, the one tool you’ll need for dependency management", written by Tom Hulton-Harrop, the author of Minimal CMake. The article discusses CMake's key features for dependency management focusing on FetchContent, ExternalProject, and Generators.News Highlights: TypeScript transitions to a Go-based compiler for a 10x speed increase; OpenAI launches Responses API and Agents SDK to facilitate complex AI agent development; NVIDIA releases a new Rust-written "NOVA" driver for RTX 20 GPUs; and Veracode's report reveals greater security risks in third-party libraries compared to first-party code.My top 5 picks from today’s learning resources:Airgapped Python: Setting up Python without a net(work)🌐Building Modern Web Applications Using Blazor ASP.NET Core🛠️How to Implement a Cosine Similarity Function in TypeScript for Vector Comparison🔢Automated architecture diagrams🏗️Java is the New Python🐍☕But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefOn-Demand Webinar—Your Salesforce Data, Your ResponsibilitySign Up|Advertise🗞️News and Analysis🔎A 10x Faster TypeScript: The language is transitioning to a native compiler port written in Go, targeting a 10x boost in performance for large codebases, with significant reductions in memory usage and editor startup times.OpenAI reveals Responses API, Agents SDK for building agentic experiences: The tools are meant to enhance developers' ability to create AI agents for complex tasks across industries, with features like multi-tool integration and multi-agent workflow orchestration.The New Rust-Written NVIDIA "NOVA" Driver Submitted Ahead Of Linux 6.15: Targeting NVIDIA RTX 20 "Turing" GPUs and newer, NOVA leverages the NVIDIA GSP for firmware support, simplifying the driver development process.Third-party libraries cause more security woes than first-party code, open-source flaws take longer to fix: A new report by Veracode reveals that 70% of applications contain flaws in third-party components compared to 64% in proprietary code.DeepSeek is unsafe for enterprise use, tests reveal: Significant security vulnerabilities, such as susceptibility to jailbreaking, prompt injection, and the ease of malware creation render it unsafe for enterprise use, have been revealed.Fortran, Delphi rise in Tiobe popularity index: Older programming languages are experiencing a resurgence, as shown in the latest Tiobe index, where they're competing for top 10 spots due to their critical roles in maintaining legacy systems.New Programming Language Vine Based on Interaction Nets: The language is designed for parallel and distributed computing, integrates functional and imperative patterns, and compiles to Ivy on the Interaction Virtual Machine.🎓Tutorials and Learning Resources💡Legend:🎓 Tutorial/Course | 💼 Case Study | 💡 Insight/AnalysisPython💡Guarantee a Locked & Reproducible Environment with Every Python Run:Introduces Fetter, a command-line tool designed to enforce locked and reproducible Python environments by validating dependencies before every Python execution.🎓Airgapped Python: Setting up Python without a net(work): Covers downloading the appropriate Python installers and package files on a networked computer and transferring and installing them on the offline system.For more Python resources, go to PythonProC# and .NET🎓TypeScript is Like C#: Outgrowing Node.js?: Addresses common myths and misconceptions about C#, presenting it as a robust alternative for backend development with a strong type system and efficient runtime.🎓Writing a .NET Garbage Collector in C# - Part 5: Explains the GCDesc structure, which stores information about object references for garbage collection and details how GCDesc encodes reference ranges in memory.🎓Building Modern Web Applications Using Blazor ASP.NET Core: Provides a comprehensive guide to building modern web applications using Blazor ASP.NET Core, highlighting its benefits for creating interactive applications with C# and .NET.C++ and C🎓Compiling C++ with the Clang API: Explains how to compile a C++ source file into an object file using the Clang API, simulating a basic version of the Clang executable.💡Understanding Memory Management, Part 3: C++ Smart Pointers: Covershow C++ smart pointers simplify memory management, prevent memory leaks, and facilitate cleaner and safer code by automating resource cleanup and ownership strategies.💡Writing a C Compiler in Clojure: Offers practical strategies for managing program symbols and types, as well as insights into generating assembly code that adheres to calling conventions.Java💡Porting LangGraph to Java in one weekend? (with Claude Code): Describes the author's ambitious weekend project of porting the LangGraph framework from Python to Java using Claude Code, an LLM tool.💡Java is the New Python: Discusses how Java is evolving through Projects Panama, Valhalla, and Babylon to simplify interfacing with other programming languages and potentially positioning it as an alternative to Python.💡New build tool in Java!: Critiques existing Java build tools and introduces the author's own, aimed at simplifying the development process by enhancing dependency management and integration with Java’s built-in tools.JavaScript and TypeScript💡JavaScript best practice: use return await: Demonstrates the importance of using return await in JavaScript to ensure proper error handling within try..catch blocks and to manage resource cleanup in try..finally constructs effectively.💡Let’s Be Serious About Node Dependency Injection.: Promotes the adoption of Object-Oriented Programming and proper dependency injection in Node applications using TypeScript, outlining the benefits of a structured approach.🎓How to Implement a Cosine Similarity Function in TypeScript for Vector Comparison: Explains how to implement a cosine similarity function in TypeScript for comparing vectors, which is essential in AI to understand relationships like "cat" to "kitten."Go💡Slow, flaky, and failing: Discusses strategies for addressing perpetually failing tests by adopting a zero-defects methodology and suggests practical measures to speed up slow test suites.💡An overview of parallel programming (Go edition): Introduces goroutines, a lightweight alternative to threads, and discusses data races, synchronization tools, and performance considerations.Rust💼Training a Rust 1.5B Coder LM with Reinforcement Learning with Group Relative Policy Optimization (GRPO): Discusses the application of the GRPO algorithm in training a small Language Model (LM) for Rust programming.💡Rust trait object layout: Clarifies the distinction between values and references, particularly with dynamically sized types which can't be directly stored due to their unknown size at compile time, but can be referred to by pointers.Swift🎓Picker in SwiftUI explained with code examples: Explains how to implement and customize SwiftUI's Picker and ColorPicker controls, providing code examples and discussing various styles to enhance user interaction in applications.🎓Loops in Swift: Explains for, while, and repeat-while loops, focusing on their uses through practical code examples. Also covers loop control statements like break and continue for loop execution control.PHP🎓Mastering SAML Implementation in PHP (Revised): Covers the benefits, recent advancements, and best practices in SAML implementation, including integration tips for frameworks and tools like Okta, and enhanced security features.SQL💡Life Altering Postgresql Patterns: Shares impactful PostgreSQL practices that have significantly improved operational efficiency, such as using UUIDs for primary keys, automated timestamping, and restrictive foreign key actions.💼Writing a Rust SQL Parser in One Week: Details the development of an in-house SQL parser by the LakeSail Team, written in Rust for their Sail framework, a replacement for Apache Spark.Ruby🎓Caching Strategies for Ultra-High Performance in Ruby on Rails, Part 1: Explains various caching methods like page caching, action caching, fragment caching, and Russian Doll caching.Kotlin🎓Learn Kotlin by Example: Designed to help newcomers familiarize themselves with the language through interactive examples.🧠Expert Insight: CMake, the one tool you’ll need for dependency management📚Three key CMake features for seamless dependency management.By Tom Hulton-Harrop, author of Minimal CMakeCMake can be a tricky technology to explain, because on its own, it isn’t particularly useful. That isn’t really a problem though, because the entire point of CMake, is to connect bits of software together, be that source files on your computer, or libraries from other developers on the internet. CMake is the glue that binds these individual software components together. However, describing CMake as just glue, might actually be doing it a disservice. Making a project compatible with CMake is a bit more like attaching a universal adapter to your code to make connecting it with other software (be that as a library or application) possible, and relatively straightforward too.In this article, we’ll learn about three key CMake features that make CMake an excellent choice for adding to your development tools. We will explore these using a simple application which simulates Conway’s Game of Life. The project is a desktop, windowed application that is fully cross platform, spanning Windows, macOS and Linux (thanks to the help of the excellent SDL 3.0 library). The complete code for the game-of-life-sdl3 project is available on GitHub. The project is an evolution of the application accompanying my book, Minimal CMake, upgraded from SDL2 to SDL3, with improved input handling and some other small changes.We’ll only be focussing on the CMakeLists.txt files at the root of the repository and in the third-party folder (see <root>/CMakeLists.txt and <root>/third-party/CMakeLists.txt). Now let’s look at the three features CMake provides which make building software fast and simple:FetchContent: The first standout feature CMake offers is the FetchContent module. This is a relatively new addition to CMake but is transformational when it comes to quickly composing software together. The key part to focus on here, is the FetchContent_Declare command in the root CMakeLists.txt file:FetchContent_Declare( as GIT_REPOSITORY https://github.com/pr0g/as.git GIT_TAG a47a6deb8b5dbe408137aa4ce5cd556d26dc77c6)FetchContent_MakeAvailable(as)What the snippet above does is inform CMake to download and build this dependency automatically for us as part of our project. There are a wide array of different options for this, but the most common is just specifying a Git repository and a commit (or tag). All that’s then needed is to add the as dependency to our target_link_libraries command and that library will be available for use (this does rely on as itself being CMake compatible, the details of which are covered in “Chapter 3: Using FetchContent with External Dependencies” in Minimal CMake):target_link_libraries( ${PROJECT_NAME} PRIVATE as ...)ExternalProject: This module is closely related to FetchContent but works slightly differently. Instead of building a dependency as part of our project, ExternalProject_Add is used to build dependencies separately, and these dependencies are then referenced using the find_package If you review the CMakeLists.txt file in the third-party folder, you’ll see a string of dependencies listed using ExternalProject_Add:ExternalProject_Add( SDL3 GIT_REPOSITORY https://github.com/libsdl-org/SDL.git GIT_TAG release-3.2.4 GIT_SHALLOW TRUE PREFIX ${PREFIX_DIR}/SDL3 BINARY_DIR ${PREFIX_DIR}/SDL3/build/${build_type_dir} INSTALL_DIR ${CMAKE_CURRENT_SOURCE_DIR}/install CMAKE_ARGS ${build_type_arg} -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>)ExternalProject_Add is incredibly useful for building larger dependencies that we may only want to build once, and then rely on for multiple projects. Having the build artifacts of these third-party dependencies kept separate can also be very convenient when wanting to delete and regenerate our own project’s build files, without then having to rebuild all of our third-party dependencies over again.In the Game of Life project, to make working with ExternalProject_Add even easier, we’ve employed what’s often referred to as a super build. A super build is a way to combine the benefits of ExternalProject_Add with FetchContent, to allow us to build our project and all dependencies with one command (cmake --build <build-folder>). See the bottom of the CMakeLists.txt file in the third-party folder for how this is configured:if(SUPERBUILD AND NOT PROJECT_IS_TOP_LEVEL) set(THIRD_PARTY_BINARY_DIR "${CMAKE_SOURCE_DIR}/build-third-party" CACHE STRING "Third-party build folder") if(NOT IS_ABSOLUTE ${THIRD_PARTY_BINARY_DIR}) set(THIRD_PARTY_BINARY_DIR "${CMAKE_SOURCE_DIR}/${THIRD_PARTY_BINARY_DIR}") endif() set(PREFIX_DIR ${THIRD_PARTY_BINARY_DIR})else() set(PREFIX_DIR ${CMAKE_CURRENT_BINARY_DIR})endif()And the top of the root CMakeLists.txt file for where we check if a super build is enabled or not:option(SUPERBUILD "Perform a superbuild (or not)" OFF)if(SUPERBUILD) add_subdirectory(third-party) return()endif()The great thing is, we can easily disable the super build if we don’t want to use it or switch back and forward whenever is convenient. Providing this option is great for users to make building your project a more straightforward and less painful experience. The super build technique mentioned above is covered in more detail in “Chapter 8: Using Super Builds to Simplify Onboarding” in Minimal CMake.Generators: This feature allows us to do something incredible: we can generate build files for Visual Studio if we’re on Windows, Xcode if we’re on Mac, or Make if we’re on Linux. There’s also an excellent cross platform build system and supported generator called Ninja which works across all three. This flexibility is incredibly useful as it doesn’t constrain what development environment a contributor or team member would like to use; they just pick the generator they prefer.To take advantage of this feature, when first configuring a project (before we actually build anything), we must specify what’s called a generator (using -G, or the system default), and use that to build our project (this is because CMake is technically a ‘build system generator’, and not a ‘build system’ itself; this distinction makes CMake very flexible). Below is an example showing how to specify various generators:cmake -B build # use system default generatorcmake -B build -G “Ninja” # use Ninja generatorcmake -B build -G “VisualStudio172022” # use Visual Studio generatorAnd then to build, we simply run cmake –build build, no matter which generator we picked.We’ve only scratched the surface of what’s possible with CMake, the ease with which you can integrate dependencies once you have a basic understanding of CMake cannot be overstated, and being able to build libraries others can use just as easily is incredibly satisfying. Do have a play around with the accompanying project, and if I’ve piqued your interest and you’d like to learn more, do give Minimal CMake a look. It’s packed full of practical examples, and explains all of this in much more detail, giving you everything you need to know to start building your own libraries and applications using CMake.Author Bio:Tom Hulton-Harrop is a software developer with over 10 years of experience in game and engine development. Tom started his career in 2011 at Electronic Arts working on the Need for Speed series of racing games. In 2014, he joined Fireproof Games where he worked on The Room Three and later joined Amazon as part of the Lumberyard Game Engine team (later becoming Open 3D Engine). During this time, Tom became interested in open source development and started sharing multiple hobby projects on GitHub. It was this experience that led Tom to CMake, where he slowly came to appreciate the power and simplicity of the tool. Tom now works at a start-up called Amutri, helping deliver 3D experiences to engineering, manufacturing, and lighting customers.His book Minimal CMake, was published by Packt in January 2025.Get the eBook for $33.99$29.99🌟Advanced Concepts🚀Automated architecture diagrams: Addresses the challenge of maintaining up-to-date architecture diagrams by implementing an automated system that integrates an extended enterprise architecture framework with interactive, reusable diagrams.Writing terrible code: Argues that writing incorrect functions deliberately can be a powerful way to validate and enhance test effectiveness, ensuring they genuinely verify the correctness of the code.How fast can you open 1000 files?: Compares performance between macOS and Linux using different threading models, revealing that macOS experiences slower file-opening speeds despite having superior hardware.🛠️Useful Tools⚒️iMCP:An open source macOS application that connects AI with users' digital lives by interfacing with Claude Desktop and other clients.ruby_llm: A Ruby library that simplifies AI integration, offering a unified API for services like chat, image analysis, and PDF analysis.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#95:C++98–23 Benchmarks, GitHub AI Secret Scans, Fancy F-Strings in Python, and Hardware-Aware Coding🏎️The ACCU Conference: By Programmers, For ProgrammersRunning since 1997, ACCU is one of the longest-standing dev conferences—originally C/C++ focused, now covering everything from Python and Rust to Kotlin, Go, and more.Use code PACKT2025 for 10% off your ticket.Book Your Spot!Hi ,Welcome to a brand new issue of ProgrammingPro.In today’s Expert Insight, we share an original article by Ferenc-Lajos Deák, coauthor of Debunking C++ Myths, tracing C++ from 98 to 23 with real code and performance benchmarks that reveal how each standard holds up.News Highlights: GitHub launches AI-powered secret scanning to cut false positives; critical Next.js auth bypass patched in v14+; Claude, Gemini, and OpenAI roll out major AI updates; and Oracle’s ML-optimized GraalVM boosts Java microservice performance by 7.9%.My top 5 picks from today’s learning resources:I Want My Own Fancy F-String Format Specifiers… Sure You Can🪡Options Pattern Validation in ASP.NET Core With FluentValidation🧪UI Algorithms: A Tiny Undo Stack⏮️Hardware-Aware Coding: CPU Architecture Concepts Every Developer Should Know🏎️Applying Flow Metrics to Design Resilient Microservices🌊But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefSign Up|Advertise🗞️News and Analysis🔎GitHub Leverages AI for More Accurate Code Secret Scanning: GitHub's AI-powered secret scanning now uses context analysis and multiple LLM techniques to reduce false positives and improve secret detection accuracy in code.Next.js team fixes vuln that allows auth bypass when middleware is used, revises documentation recommending this method: The critical vulnerability allowed easy auth bypass via a specific request header, affecting all versions and is fixed in v14+.Mar 21, 2025: AI updates from the past week: Claude can now browse the web for real-time responses; Google launched Gemini Canvas for collaborative coding; and OpenAI upgraded its audio models for better transcription and speech synthesis.Oracle releases ML-optimized GraalVM for JDK 24: The version introduces GraalNN, an ML-based profiling system delivering 7.9% peak performance gains in microservices..NET 10 Preview 2: Enhanced Reconnection UI, Improved Blazor Features, and Updates across the Stack: Preview 2 also introduces enhanced navigation behavior, OpenAPI metadata generation, and UI updates in .NET MAUI.The future of Scala: Pioneering features are now commonplace so what comes next?: Many features once unique to Scala are now mainstream, and adoption of Scala 3 remains slow due to incompatibility with Scala 2.Microsoft introduces Hyperlight Wasm for WebAssembly workloads: The experimental micro-VM enables secure, low-latency execution of WebAssembly workloads in languages like C, Python, and Rust.🎓Tutorials and Learning Resources💡Legend:🎓 Tutorial/Course | 💼 Case Study | 💡 Insight/Analysis |📖Open Access Book or Comprehensive Resource | 🗞️Something NewPython🎓I Want My Own Fancy F-String Format Specifiers… Sure You Can: Shows you how to implement custom f-string format specifiers in Python by defining the .__format__() method, enabling tailored string output logic within your classes. 💡fastplotlib: driving scientific discovery through data visualization: Introduces fastplotlib, a new Python library for GPU-accelerated, interactive scientific visualization built on modern graphics APIs like WGPU. 💡Defining AI tools in python: compares three approaches to defining AI agent tools in Python: using function docstrings, pydantic models, or supporting both.C# and .NET🎓How To Validate Email Addresses in C#?: Compares regex-based, built-in .NET classes, and simplified logic, ultimately recommending a lightweight custom method that avoids regex complexity and is resilient to malformed inputs.🎓How to Build a 2D Safe Code Breaker Mini-Game in Unity: Walks you through building a 2D “Safe Code Breaker” mini-game in Unity using UI elements, C# scripting, and audio feedback.🎓Options Pattern Validation in ASP.NET Core With FluentValidation: Shows you how to use FluentValidation with ASP.NET Core’s Options Pattern to validate configuration settings at startup, offering a more powerful alternative to Data Annotations.C++ and C💡C++26 Expansion Tricks: Demonstrates advanced compile-time expansion techniques in C++26 using reflection (P2996), structured bindings (P2686), and expansion statements (P1306).🗞️C++ Dynamic Debugging: Full Debuggability for Optimized Builds: The feature introduced in Visual Studio 2022 (v17.14 Preview 2) enables full debugging of optimized C++ code by dynamically deoptimizing breakpoints or stepped-into functions.📖Open Access Book | Beej's Guide to C Programming by Brian "Beej Jorgensen" Hall: A comprehensive resource designed for individuals who have prior experience with other programming languages and wish to learn C.Java🎓Stream Gatherers: The Missing Piece in Java Stream Processing: Explains how to build and apply custom gatherers, including stateful, stateless, and parallel-capable examples.🎓How to query CSV as a database table in Java with esProc: Shows you how to use esProc to query CSV files in Java as if they were database tables, by embedding SPL statements via esProc's JDBC driver.JavaScript and TypeScript🎓UI Algorithms: A Tiny Undo Stack: Explains how to implement a lightweight, robust undo stack for UI actions using two arrays—past and future—instead of index-based stacks.💡JavaScript numbers have an (adoption) problem: Explores how JavaScript’s exclusive use of floating-point numbers causes precision issues, bitwise limitations, and unexpected behavior and recommends using BigInt.💡Speeding up Typescript Go by 100x: Delves into how caching subtlety in TypeScript's type system can dramatically affect compiler performance and how tsgo’s internals diverged from tsc before the fix.Go💼Faster interpreters in Go: Catching up with C++: Explains the design evolution of Vitess’s SQL evaluation engine — from an AST interpreter to a specialized bytecode virtual machine.🗞️Goodbye core types - Hello Go as we know and love it!: Go 1.25 removes the concept of “core types” from the language spec, replacing it with clearer, operation-specific rules.Rust🗞️Rust Additions For GCC 15 Bring Support For if-let Statements, Other Improvements: The version's Rust front-end (gccrs) now also supports Clone, and Copy derives, with upcoming support for PartialOrd and PartialEq.🗞️Fastrace: A Modern Approach to Distributed Tracing in Rust: This high-performance, zero-cost distributed tracing library for Rust integrates seamlessly with standard logging and supports automatic context propagation.Swift🗞️Introducing SwiftMCP: This open-source Swift macro framework turns documented Swift functions into AI-callable tools using Model Context Protocol, generating metadata, wrappers, and server integration with minimal setup.🎓SwiftUI TabView: Explained with Code Examples: Explains how to implement and customize tab-based navigation in SwiftUI using practical examples for both simple and advanced app structures.PHP🗞️Rusty string formatting in PHP: Introduces f, a PHP package inspired by Rust's format!() macros, offering cleaner, {} -based string formatting with support for positional, named, and padded placeholders.SQL🗞️SQLCritic: Correcting Text-to-SQL Generation via Clause-wise Critic: Proposes a novel method to improve text-to-SQL accuracy by evaluating and correcting generated SQL queries clause-by-clause using a critic model.Ruby📖Ruby, Ractors, and Lock-Free Data Structures: A comprehensive online resource authored by Ilya Bylich, focusing on concurrent data structures within the Ruby programming language.💡My Ruby Debugging Tips in 2025: Shares tips focussed on improved workflows using debug.gem, Ruby LSP, and integrations like Code Lens and RSpec support.Kotlin🗞️Kotlin bolsters K2 compiler plugin support, WebAssembly debugging: Kotlin 2.1.20’s enhancements to K2 compiler plugins make kapt default and improve Kotlin/Wasm debugging with DWARF support.💡Migration of an iOS/Android Application to Kotlin Multiplatform: Methodology and Key Steps: Recommends gradually shifting cross-cutting modules, data, business logic, and presentation layers to shared Kotlin code.🧠Expert Insight: From C++98 to C++23: The Arithmetic Mean, Benchmarked and Optimized📚Exploring the evolution of C++ through arithmetic mean calculations and performance analysis.by Ferenc-Lajos Deák, coauthor of Debunking C++ MythsAveraging algorithms are computational techniques used to determine the mean or average value of a set of numbers. They are widely used in machine learning (model optimization), signal processing (noise reduction), finance (trend analysis), and networking (traffic smoothing). Some common averaging algorithms include Arithmetic Mean (Simple Average), Moving Average (Sliding Window Average), Harmonic Mean, and Geometric Mean.In this article we will explore one of the most common averaging algorithms: the Arithmetic Mean, and its implementation in C++. We will explore how to compute the average of a vector using five different approaches, each corresponding to a major C++ standard, from C++98 to C++23. Additionally, we will benchmark these implementations to analyze their performance and efficiency. Finally, we will dig into the code generated by the two most used compilers on Linux platforms, GCC and Clang, and perform a thorough analysis and see which one comes out the winner.Readers will gain a deeper understanding of Practical C++ implementation across different standards: you will see how to compute the arithmetic mean of a vector using various C++ techniques and understand the evolution of the language from C++98 to C++23. You will also gain insights into optimizing code for performance, while keeping Modern C++ coding practices in mind and learn how they can be used to write efficient and readable code...Computing the Average: Five ApproachesLet us now delve into five versions of a function that calculates the average of a vector of random integers. Each version utilizes a different C++ standard, demonstrating how modern C++ simplifies and makes common programming tasks more readable, but before introducing them, here is the code that generates the vector:// Initialize random number generatorstd::random_device rd;std::mt19937 gen(rd());std::uniform_int_distribution<int> value_dist(1, 100);// Generate random vectorstd::vector<int> numbers(50000);std::ranges::generate(numbers, [&]() { return value_dist(gen); });1. C++98: Classic for-loop ApproachIn C++98, we relied on manual iteration using a basicforloop:// C++98: Classic for-loop approachdouble average_cpp98(const std::vector<int>& numbers) { int sum = 0; for (size_t i = 0; i < numbers.size(); ++i) { sum += numbers[i]; } return static_cast<double>(sum) / numbers.size();}This approach was straightforward but lacked modern conveniences like range-based loops or built-in algorithms.2. C++11: Range-based LoopWith C++11, we gained access to range-based loops, making iteration more concise and readable:// C++11: Range-based loopdouble average_cpp11(const std::vector<int>& numbers) { int sum = 0; for (int num : numbers) { sum += num; } return static_cast<double>(sum) / numbers.size();}This improved readability by removing explicit indexing and is one of the many usability improvements introduced in C++11.3. C++14: Using std::accumulateC++14 introduced functional-style algorithms such as std::accumulate, which simplified summing the elements:// C++14: Using std::accumulatedouble average_cpp14(const std::vector<int>& numbers) { auto sum = std::accumulate(numbers.begin(), numbers.end(), 0); return static_cast<double>(sum) / numbers.size();}This approach is more declarative and eliminated the need for a loop. C++14 focused on minor refinements and usability improvements over C++11.4. C++17: Using std::reduceC++17 introducedstd::reduce, which is optimized for parallel execution:// C++17: Using std::reduce (supports parallel execution)double average_cpp17(const std::vector<int>& numbers) { int sum = std::reduce(std::execution::seq, numbers.begin(), numbers.end()); return static_cast<double>(sum) / numbers.size();}std::reduceprovides potential performance gains by allowing parallel execution when used withstd::execution::par. C++17 marked a shift towards greater use of parallelism and optimization in the Standard Library.👉 See the C++23 version, benchmark results, and which compiler comes out ahead in real-world performance tests.[Read the complete article →]Author Bio: Ferenc-Lajos Deák is a seasoned software developer with a strong foundation in mathematics and theoretical computer science, currently based in Trondheim, Norway. His career spans roles across diverse domains, including autonomous vehicles, real-time traffic systems, multimedia, and telecommunications. An avid open-source enthusiast, he maintains several live projectsand has authored more than a dozen articles for various technical publications, focusing on one of his passions: programming.His book Debunking C++ Myths coauthored alongside Alexandru Bolboaca, was published by Packt in December 2024.Get the eBook for $31.99$27.99🌟Advanced Concepts🚀Applying Flow Metrics to Design Resilient Microservices: Explains how flow metrics such as Work-in-Progress (WIP), age, cycle time, and throughput can be applied to microservices to detect and contain system congestion.AI Trends Disrupting Software Teams: Outlines five trends including generative development with code assistants and autonomous agents, AI-powered operations and observability, dynamic documentation, AI-integrated SaaS interfaces, and agentic systems for business automation.Hardware-Aware Coding: CPU Architecture Concepts Every Developer Should Know: Explains instruction pipelining, memory caching, and speculative execution using a drive-through analogy.Timescale architecture for real-time analytics: Explores how to build scalable, high-ingest, low-latency analytics apps using familiar SQL while gaining real-time insights over large time-series datasets.🛠️Useful Tools⚒️Lynx: An open-source framework that lets developers build native mobile and web apps using familiar web technologies, with high performance, Rust-based tooling, and cross-platform flexibility.Unvibe: A Python tool that uses AI to generate and refine code until it passes your unit tests, making it especially effective for large projects with good test coverage.STUMPY: A BSD-licensed, NumFOCUS-affiliated Python library for scalable time series analysis using matrix profiles, with support for docs, testing, and reproducibility.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#89Python 3.14’s 30% Speed Boost, VS Code’s AI Upgrades, Go 1.24 Released, and Building a Rust DriverHi ,Welcome to a brand new issue of ProgrammingPro.In today’sExpert 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🧠We Replaced Our React Frontend with Go and WebAssembly🔄Writing a Simple Driver inRust⚙️Surviving Google’s JavaScript rendering shift: one month later🌍How to Prevent Bugs From Reaching Production🛡️But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefPS: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 aquick 1:1 conversationwith our team.What's in it for you?✅ Abrief 20–30 minute conversationat a time that’s convenient for you✅ An opportunity toshare your experiences and shape the future of learning✅A free credit to redeem any eBook of your choicefrom our library as a thank-youHow to Participate:Schedule a quick call at your convenience using the link provided after the form:https://forms.office.com/e/Bqc7gaDCKqLooking forward to speaking with you soon!Thank you,Team Packt.Sign Up|Advertise🗞️News and Analysis🔎What you need to know about Python 3.14’s faster interpreter: Theinterpreter 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 versionintroduces 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 PythonProC# 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 andcovers 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 using keyword 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: thesatisfies operator: 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 rill concurrency toolkit to improve performance.Rust🎓Writing a Simple Driver inRust: 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_paranoid for 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 librariesIn 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 behindthe scenes. Now that we’re a bit morecomfortable with these concepts, it’s time to remove the tedium of navigating to each individual library folder and running the familiar CMake commandsthat follow:cmake --preset <preset-name>cmake --build <build-folder> --target installWe 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-partyCMakeLists.txtfile 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 ourGame ofLifeapplication.Let’s start by looking atch8/part-1/third-party/CMakeLists.txt. The file is largely the same as before, only underneath our existingExternalProject_Addcommands, we’ve added references to our libraries foundinch8/part-1/lib.Here is an example of themc-arraylibrary: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 inChapter 6,Installing Dependencies and ExternalProject_Add. The only real difference is the reference toSOURCE_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 thesame repository:SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../lib/arrayIt would normally be the case that we’d refer to an external library using aURLorGIT_REPOSITORYlink. 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 usethis 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 inChapter 3,Using FetchContent with External Dependencies, when usingFetchContent. The preceding command will clone the entire repository into the build folder of our third-partyCMakeList.txtfile, and then treat thech8/part-1/lib/arraydirectory as the root of the repository (at least as far asExternalProject_Addis concerned). It’s not often needed but can be useful if a repository holds more than oneCMake project.While we’re making changes tothird-party/CMakeLists.txt, we’ll also make one small improvement to how we handle our bgfx dependency. When bgfx was first introduced inChapter 6,Installing Dependencies and ExternalProject_Add(seech6/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 thedifferences 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 firstExternalProject_Addcall is the same as before; we let it know the repository and specificGIT_TAGto download. However, in the second version, instead of repeating those lines, we first callExternalProject_Get_Property, passing thebgfxttarget and theSOURCE_DIRproperty.SOURCE_DIRwill be populated with the location of thebgfxtsource code once it’s downloaded, and in the second command, we point thebgfxtarget 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 allover again.You might have noticed that we’re usingURL "file://${SOURCE_DIR}"as opposed toSOURCE_DIR ${SOURCE_DIR}. This is because if we tried to useSOURCE_DIR, theExternalProject_Addcommand would fail at configure time becauseSOURCE_DIRis expected to already be present when we configure. As this isn’t the case with our dependency (the source forbgfxtwill only be downloaded and made available at build time), we can use theURLoption with a local file path shown byfile://, which will cause the file path to instead be resolved atbuild time.With the addition of the three newExternalProject_Addcalls referencing our libraries, when building our project, we only need to visit two directories, as opposed to the earlier five. We can navigate toch8/part-1/third-partyand run the followingCMake commands:cmake -B build -G "Ninja Multi-Config"cmake --build build --config ReleaseThis will download, build, and install all our dependencies at once. We then only need to navigate toch8/part-1/appand runthe following:cmake --preset multi-ninjacmake --build build/multi-ninja --config ReleaseThis will build and link our application. We’ve also tidied up ourCMakePresets.jsonfile to haveCMAKE_PREFIX_PATHonly refer to${sourceDir}/../third-party/install, as opposed to the numerous install folders we had for each of our internal dependencies in thelast chapter.Finally, to launch the application, we first need to compile our shaders and then launch the application from our application rootdirectory (ch8/part-1/app):./compile-shader-<platform>.sh/bat./build/multi-ninja/Release/minimal-cmake_game-of-life_windowThis 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 CMakewas 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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers🎄#86🥂Python Debugging Best Practices, Go’s API Surge, Google's Jules Coding Agent, and Netflix's Scalable CountersHi ,"It's the Most Wonderful Time of the Year🌟...It's the hap-happiest season of all" 🎵 - Andy WilliamsWelcome to our very last issue, for the year 2024! We will be taking our usual year end break and return again on the 16th of January 2025. In the meanwhile, do keep any eye out. Packt x Santa🎅 are busy working on some unmissable deals for you to unwrap over the holidays! Now let's get down to business.In today’sExpert Insight, we bring you an excerpt from the recently published book, Learn Python Programming - Fourth Edition, which demonstrates best practices for creating custom debugging functions in Python.News Highlights:Python is set to win Tiobe's "Language of the Year" for its growth in AI and data mining; Go overtakes Node.js in API requests with a 40% rise; Google introduces Gemini 2.0 and AI coding agent Jules; and SQLite is re-implemented in Rust for async I/O and memory safety.My top 5 picks from today’s learning resources:Linear Regression in Python📈How AMD Is Taking Standard C/C++ Code To Run Directly On GPUs🚀Data structures as jigs for Go programmers🧩Inside Netflix’s Distributed Counter: Scalable, Accurate, and Real-Time Counting at Global Scale🌍How to Become a Principal Engineer🏗️But there’s more, so dive right in.Before signing off, I would like to say thank you to all readers who have been on this journey with me this year. A very Merry Christmas and Wonderful New Year 2025 to you all!Don't forget to Stay Awesome!Divya Anne SelvarajEditor-in-ChiefSign Up|Advertise🗞️News and Analysis🔎Python a shoo-in for Tiobe language of the year: Python is expected to win Tiobe’s "Programming Language of the Year" for 2024 due to a significant 10% increase in popularity ratings, driven by its dominance in AI, data mining, and ease of learning.Go eclipses Node.js in web API requests, Cloudflare reports: Go has overtaken Node.js as the leading language for automated API requests, accounting for 11.8% of traffic, with Go's share rising 40% and Node.js declining 30%.Ruby on Rails 8.0 Released, Introduces Kamal 2 for Improved Deployments: Key updates also include SQLite-based adapters, a new asset pipeline, enhanced authentication tools, and deprecated feature removals.Java News Roundup: JDK 24 in Rampdown, JDK 25 Expert Group, Jakarta EE 11 Core Profile, Spring Cloud: Other highlights include updates to frameworks like GlassFish, Open Liberty, Quarkus, Apache Camel, and others.Google announces Gemini 2.0 Flash and new coding agent: Jules, an AI-powered coding agent, is designed to assist with Python and JavaScript tasks, including debugging, modifying multiple files, and creating pull requests.SQLite re-implemented in Rust to achieve asynchronous I/O and other changes: Turso is re-implementing SQLite in Rust as "Limbo" to enable asynchronous I/O, memory safety, and modern architecture while ensuring compatibility with SQLite.OpenSilver 3.1 adds new drag-and-drop XAML designer for VS Code: The designer comes with over 100 controls, cross-platform compatibility, a modern UI theme, expanded WPF feature support, and full .NET 9 compatibility.React 19 is stable, team directs devs towards frameworks – especially Next.js: React 19 is now stable, introducing server components to the main channel, improved pre-rendering APIs, and enhanced suspense features.🎓Tutorials and Learning Resources💡Python🎓Tutorial |Linear Regression in Python:Demonstrates implementing simple, multiple, and polynomial regression in Python using libraries like scikit-learn and statsmodels, covering key concepts such as underfitting and overfitting.For more Python resources, go to PythonProC# and .NET🎓Tutorial | Using vectorization in C# to boost performance: Explains how vectorization in C# was used to optimize the Sum method in .NET 8, leveraging SIMD principles and advanced techniques like loop unrolling.🎓Tutorial | Building a Multi-Tenant Configuration Management System with .NET Core, Redis, and Dependency Injection: Combines local disk caching for quick access, Redis for distributed caching, and a Pub/Sub model.🎓Tutorial | Central Package Management (CPM) in .NET — Simplify NuGet Dependencies: Explains how CPM achieves simplification by centralizing package version control in a single Directory.Packages.props file.C and C++💼Case Study | How AMD Is Taking Standard C/C++ Code To Run Directly On GPUs: AMD is working on porting LLVM's C/C++ run-times to GPUs, bypassing the need for GPU-specific languages like OpenMP or OpenACC.🎓Tutorial | Learning to read C++ compiler errors: Nonsensical errors from a function declaration: Explains how conflicting macros in C++ projects can lead to compiler errors, using the case of a macro named ErrorMessage .🎓Tutorial | Refactoring in C++: Top Techniques and Best Practices: Covers methods such as renaming variables, extracting functions, simplifying conditionals, and reducing duplication, along with best practices.Java💼Case Study | QCon SF 2024: Refactoring Large, Stubborn Codebases: Stripe engineers share strategies for refactoring large, stubborn codebases leveraging centralized teams, tools like Sorbet for Ruby, and more.🗞️Malicious Maven Package Impersonating 'XZ for Java' Library Introduces Backdoor Allowing Remote Code Execution: Socket researchers have uncovered a malicious Maven package, io.github.xz-java:xz-java, impersonating the legitimate XZ for Java library (org.tukaani:xz).🎓Tutorial | Peering through the peephole: build a peephole optimiser using the new Java Class-File API: Demonstrates building an optimizer that removes redundant instructions (e.g., unnecessary zero addition) and more.JavaScript and TypeScript💡What is TypeScript? Strongly typed JavaScript: Introduces TypeScript as a strongly typed superset of JavaScript, highlighting its enterprise-level features, compatibility, and advantages for large-scale application development.💡Everything AboutBarrel ExportsInJavaScript: Examines the benefits, challenges, and best practices of using barrel exports to simplify imports, improve code organization, and balance performance and maintainability.🗞️Malicious npm Package Typosquats Popular TypeScript ESLint Plugin, Exfiltrates Data and Enables Remote Exploitation: A secondary malicious package, @typescript_eslinter/prettier, remains live, escalating the risk.Go🎓Tutorial | Data structures as jigs for programmers: Discusses implementations including basic and dynamic arrays, multidimensional arrays, bitsets, binary heaps, and hash tables, with practical use cases and code examples.🗞️Coming in Go 1.24: testing/synctest experiment for time and concurrency testing: Introduces the experimental testing/synctest package in Go 1.24, designed to improve testing involving time and concurrency.Rust💼Case Study |I spent 2 years rebuilding my algorithmic trading platform in Rust. I have no regrets: Discusses the author's experience transitioning their algorithmic trading platform from Typescript to Rust.💡Thoughts on Rust hashing: Critiques Rust's hashing model, which separates Hash and Hasher traits for flexibility, highlighting inefficiencies in handling block-wise hashing, variable-length inputs, and more.Swift🎓Tutorial | Migrating XCTest to Swift Testing: Provides a migration guide using modern features of Swift Testing, such as concurrency and macros, its improved test setup, teardown processes, and flexible assertion macros.🎓Tutorial | SF Symbol: How to for Swift & SwiftUI: Explains how to use, customize, and animate Apple's SF Symbols in Swift and SwiftUI, leveraging the SF Symbols app for integration and design consistency in apps.PHP🎓Tutorial | Parsing HTML with PHP 8.4: Discusses the new HTML5 parser, CSS selector support, and updated DOM classes in PHP 8.4, which improve HTML parsing, DOM manipulation, and web development efficiency.🎓Tutorial | Implementing Dependency Inversion Principle (DIP) using Laravel: Demonstrates implementing DIP by decoupling UserService from specific repository dependencies through a RepositoryManagerInterface .SQL💡Some useful SQL(ite) tips I've learned: Includes tips such as splitting data into buckets, advanced ordering without additional columns, JSON querying with shorthand operators, string concatenation, and default values for NULLs.🎓Tutorial | A Beginner’s Guide to Procedural Programming Beyond SQL with Toad for Oracle: Covers the fundamentals of PL/SQL, its advantages for database programming, and practical tips for efficient PL/SQL development.Ruby🎓Tutorial | Mastering Ruby Debugging: From puts to Professional Tools: Provides a comprehensive guide to debugging in Ruby, covering basic techniques like puts statements, interactive consoles, and advanced tools.💡Advent of Criminally Bad Ruby Code: Humorously chronicles the author's exploration of unconventional and experimental Ruby coding practices, showcasing creative abuses of Ruby features.Kotlin💡When to Use Retrofit and When to Use Ktor: A Guide for Android Developers: Compares two popular HTTP clients for Android, detailing their strengths and scenarios for use.🎓Tutorial | 5 steps to implement MVI architecture with Jetpack Compose: Covers setting up dependencies, defining the Model, ViewState, and Intent layers, managing the state and events in a ViewModel, and creating a reactive UI layer following MVI principles.🌟Best Practices and Advice🚀Inside Netflix’s Distributed Counter: Scalable, Accurate, and Real-Time Counting at Global Scale: Explains the system which balances performance, accuracy, and cost through configurable modes and event-driven architecture.Beat the Plan: Probabilistic Strategies for Successful Software Delivery at Scale: Advocates for adaptive systems over rigid plans, leveraging continuous processes, prioritization, constraints, and a culture of learning.How to Become a Principal Engineer: Discusses the required technical and leadership skills, strategies for career growth, and how companies can define and support the role for maximum impact.On over-engineering; Architecture Edition: Discusses balancing over-engineering and under-engineering in architectural decisions, using the author’s project, Collecto, as an example.🧠Expert Insight📚Here’s an excerpt from “Chapter 11: Debugging and Profiling" in the book, Learn Python Programming - Fourth Edition by Fabrizio Romano and Heinrich Kruger, published in November 2024.Debugging with a custom functionHaving a custom debugging function saved in a file somewhere that you can quickly grab and paste into the code can be particularly useful. If you are fast, you can also code one on the fly. The important thing is to write it in such away that it will not leave anything behind when you eventually remove the calls and their definitions. Therefore, it is important to code it in a way that is completely self-contained. Another good reason for this requirement is that it will avoid potential name clashes with the rest of the code.Let us see an example of such a function:# custom.pydef debug(*msg, print_separator=True): print(*msg) if print_separator: print("-" * 40)debug("Data is ...")debug("Different", "Strings", "Are not a problem")debug("After while loop", print_separator=False)$ python custom.pyData is ...----------------------------------------Different Strings Are not a problem----------------------------------------After while loopAs you can see, there is no separator after the last line.This is just one easy way to augment a simple call to theprint()function. Let us see how we can calculate a time difference between calls, using one of Python’s tricky features to our advantage:# custom_timestamp.pyfrom time import sleepdef debug(*msg, timestamp=[None]): from time import time # local import print(*msg) if timestamp[0] is None: timestamp[0] = time() # 1 else: now = time() print(f" Time elapsed: {now - timestamp[0]:.3f}s") timestamp[0] = now # 2debug("Entering buggy piece of code...")sleep(0.3)debug("First step done.")sleep(0.5)debug("Second step done.")This is a bit more complicated. First, notice that we used animportstatementinsidethedebug()function to import thetime()function from thetimemodule. This allows us to avoid having to add thatimportoutside the function and risk forgetting to remove it.Look at how we definedtimestamp. It is a function parameter with a list as its default value. InChapter 4,Functions, the Building Blocks of Code, we warned against using mutable defaults for parameters because the default value is initialized when Python parses the function, and the same object persists across different calls to the function. Most of the time, this is not the behavior you want. In this case, however, we are taking advantage of this feature to store a timestamp from the previous call to the function, without having to use an external global variable. We borrowed this trick from our studies onclosures, a technique that we encourage you to read about.After printing the message, we inspect the content of the only item intimestamp. If it isNone, we have no previous timestamp, so we set the value to the current time (#1). On the other hand, if we have a previous timestamp, we can calculate a difference (which we neatly format to three decimal digits), and finally, we put the current time intimestamp(#2).Running this code outputs the following:$ python custom_timestamp.pyEntering buggy piece of code...First step done.Time elapsed: 0.300sSecond step done.Time elapsed: 0.500sUsing a custom debug function solves some of the problems associated with just usingprint(). It reduces duplication of debugging code and makes it easier to remove all your debugging code when you no longer need it. However, it still requires modifying the code and running it in a console where you can inspect the output. Later in this chapter, we will see how we can overcome those difficulties by adding logging to our code.Learn Python Programming - Fourth Editionwas published in Novemver 2024. Packt library subscribers can continue reading the entire book for free or you can buy the book here!Get the eBook for $35.99$24.99🛠️Useful Tools⚒️Holos: A Go CLI tool using CUE to replace YAML templating in Kubernetes, streamlining Helm and Kustomize configurations with type-safe, unified management.cal.com: An open-source, self-hosted alternative to Calendly, offering complete control over scheduling, data, and workflows, with extensive customizability.sqlfluff: A highly configurable, dialect-flexible SQL linter and auto-formatter that supports templating systems like Jinja and dbt, ensuring error-free SQL code.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#88Go Shared Memory Fixes, 100 Common Python Errors, 10 AI-Powered Dev Tools, and a Malicious Go PackageHi ,Welcome to a brand new issue of ProgrammingPro.In today’sExpert Insight, we bring you an excerpt from the recently published book, Go Recipes for Developers, which demonstrates how to manage shared memory in Go by avoiding memory races and using mutexes to synchronize access to shared variables, instead of relying solely on channels.News Highlights: 10 AI tools gain new features, including Amazon Q’s code validation; a malicious Go package evades detection for years; Stack Exchange tests AI answers despite a past ban; and Java updates JDK, frameworks, and tooling.My top 5 picks from today’s learning resources:100 Common Python Mistakes⚠️Build Intelligent Apps with .NET and DeepSeek R1🤖How Databases Work Under the Hood: Building a Key-Value Store in Go🗄️Do Code LLMs Understand Design Patterns?🧠Building a Serverless Fan-Out-Fan-In Mechanism🪭But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefSign Up|Advertise🗞️News and Analysis🔎10 development tools that have recently added new AI capabilities: Covers Amazon Q’s real-time code validation, DeepSeek R1’s availability on Azure AI, JetBrains' Junie coding agent, Sourcegraph’s AI code reviewers, and more.Java News Roundup: Java Operator SDK 5.0, Open Liberty, Quarkus MCP, Vert.x, JBang, TornadoVM: Also covers updates to JDK 24 and 25, Spring Cloud, Infinispan, and JHipster Lite.Malicious package found in the Go ecosystem: The typosquat package mimicking BoltDB contains a backdoor for remote code execution and exploited the Go Module Mirror’s indefinite caching, evading detection for over three years!Rust update fixes ‘forever’ compilation: Rust 1.84.1 fixes regressions from Rust 1.84, including a severe slowdown caused by the next-gen trait solver, errors in overlapping impls, duplicate-crate diagnostics, and missing debug info.TypeScript checks returns for conditional and indexed access types: TypeScript 5.8, now in beta, introduces limited type checking for conditional and indexed access types in return statements, reducing reliance on type assertions.Apple open sources Swift Build: The engine used by Xcode, to unify build systems across Xcode and Swift Package Manager (Swift PM), is now available on GitHub under the Apache 2.0 license and supports multiple platforms.Stack Exchange dabbles with AI answers – despite Stack Overflow banning them in 2022: The experiment, limited to select sites, requires human verification before AI answers become public and aims to boost engagement.🎓Tutorials and Learning Resources💡Python💡100 Common Python Mistakes:Covers logic bugs, inefficient code, non-Pythonic practices, and best practices for readability and performance, using clear examples for each mistake.For more Python resources, go to PythonProC# and .NET💡Top 10 .NET Performance Anti-Patterns You Should Fix Today: Covers excessive object allocation, blocking async calls, inefficient database queries, and overusing reflection, and provides fixes such as using object pooling.🎓Tutorial | Build Intelligent Apps with .NET and DeepSeek R1: Using the Microsoft.Extensions.AI (MEAI) library, it provides a step-by-step guide for connecting to GitHub Models, Azure AI Foundry, or running locally with Ollama.🎓Tutorial | Writing a .NET Garbage Collector in C# - Part 2: Covers defining key interfaces (IGCHeap, IGCHandleManager, IGCHandleStore), handling GC handles, implementing memory allocation, and more.C and C++💡21st Century C++: In this article, Bjarne Stroustrup recommends modern C++ practices for performance, type safety, and maintainability, covering resource management, modularity, generic programming, and more.💡Starflate: Deflate decompression in C++23: Discusses lessons learned from the development of Starflate, a Deflate decompression implementation in C++23, covering the Deflate algorithm, project design, and more.💡I Wrote a Wasm Interpreter in C: Covers the author's experience writing Semblance, a WebAssembly interpreter in C, detailing the WebAssembly specification, interpreter design, and implementation of function calls and host imports.Java🎓Tutorial | How to Compile Java into Native Binaries with Mill and Graal: Explains the setup, build process, benefits like faster startup and lower memory usage, and limitations such as longer build times and restricted reflection support.💡The Java Streams Parallel: Provides an in-depth analysis of Java Streams' parallel execution, including its implementation, concurrency behavior, stream operation characteristics, and internal design in JDK 24.💡Java's synchronized explained: Explains how Java’s synchronized keyword works at the bytecode level, detailing monitorenter and monitorexit instructions, object monitors, and how synchronized methods differ from synchronized blocks.JavaScript and TypeScript💡Is npm Enough? Why Startups are Coming after this JavaScript Package Registry: Examines emerging competition in the JavaScript package management space, focusing on how Deno’s JSR and vlt’s vsr challenge npm’s dominance.🤯Someone got Linux running inside a PDF file, because its users are something else: The project exploits the PDF format’s JavaScript support to enable computation, with user input via a virtual keyboard and text box translating to on-screen actions.🎓Tutorial | Slots: Make your Angular API flexible: Explores how content projection in Angular can make UI components more flexible and reusable, comparing ng-content and ng-template.Go🎓Tutorial |How Databases Work Under the Hood: Building a Key-Value Store in Go: Explains how databases store and retrieve data efficiently by managing query layers and storage engines.🎓Tutorial | Dealing with Golang Data Types: Explains Golang’s data types' memory considerations, practical applications, and syntax, with examples, and concludes with coding exercises.Rust💡No-Panic Rust: A Nice Technique for Systems Programming: Discusses how, by carefully designing APIs and leveraging Rust’s optimizer, developers can write efficient, panic-free Rust code.🎓Tutorial | Making System Calls in Rust: Requesting Services from the Kernel: Explains how to use the libc crate to access low-level kernel services, with examples on file I/O, handling processes via fork() , and more.Swift💡Rethinking Our Color System: A Type-Safe Approach in Swift: Discusses rethinking a color system in Swift using type safety, generics, and property wrappers instead of subclassing UIColor .🎓Tutorial |Parameterized tests in Swift: Reducing boilerplate code: Explains how to improve test clarity, and make debugging easier by running a single test with multiple input values.PHP💡The State of PHP 2024: Reveals that PHP remains a dominant force in web development, with Laravel as the leading framework, PhpStorm as the preferred IDE, increasing AI adoption, and ongoing efforts to enhance PHP’s features.SQL🎓Tutorial | Query Tuning in DBSQL with the new V2 Query Profile: Introduces a streamlined tool for query tuning in DBSQL, helping users quickly identify bottlenecks through execution summaries, detailed scan insights, and the new "Top Operators" feature.Ruby🎓Tutorial | Setting Up a Rails 8 with Vite and Tailwind CSS 4: Covers installation, configuration, and integration of Turbo, Stimulus, and Tailwind with Vite for modern frontend development in Rails.🎓Tutorial | Ruby on Rails on WebAssembly, the full-stack in-browser journey: Details the process of "wasmifying" a Rails app, adapting database storage, leveraging service workers, and the future potential of Rails.Kotlin🎓Tutorial | Kotlin Constants in Android: Top-level vs. Companion-enclosed: Analyzes their effect on APK size, memory usage, and performance through bytecode inspection and R8 optimizations.💡10+ Common Kotlin Coroutine Mistakes Senior Android Developers Should Avoid: Covers blocking the main thread, improper exception handling, misusing coroutine scopes, overusing withContext, and more.🌟Advanced Concepts🚀Do Code LLMs Understand Design Patterns?: Examines whether Code LLMs understand design patterns by evaluating their ability to recognize, comprehend, and generate pattern-compliant code.Comprehensive Guide to AI Workflow Design Patterns with PydanticAI code examples: Covers prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer workflows, and autonomous agents.Building a Serverless Fan-Out-Fan-In Mechanism: Explains how to implement a serverless fan-out-fan-in mechanism using AWS Step Functions, SNS, SQS, and DynamoDB to build scalable and fault-tolerant distributed systems.How has DeepSeek improved the Transformer architecture?: Explains how DeepSeek v3 enhances the Transformer architecture through multi-head latent attention (MLA), mixture-of-experts (MoE) improvements, and multi-token prediction.🧠Expert Insight📚Here’s an excerpt from “Chapter 7: Concurrency" in the book, Go Recipes for Developers, by Burak Serdar, published in December 2024.Sharing memoryOne of the most famous Go idioms is: “Do not communicate by sharing memory, share memory by communicating.” Channels are for sharing memory by communicating. Communicating by sharing memory is done using shared variables in multiple goroutines. Even though it isdiscouraged, there are many use cases where shared memory makes more sense than a channel. If at least one of the goroutines updates a shared variable that is read by other goroutines, you have to ensure that there are no memory races.A memory race happens when a goroutine updates a variable concurrently while another goroutine reads from it or writes to it. When this happens, there is no guarantee that the update to that variable will be seen by other goroutines. A famous example of this situation is thebusy-waitloop:func main() { done:=false go func() { // Wait while done==false for !done {} fmt.Println("Done is true now") }() done=true // Wait indefinitely select{}}This program has a memory race. Thedone=trueassignment is concurrent with thefor !doneloop. That means, even though the main goroutine runsdone=true, the goroutine readingdonemay never see that update, staying in theforloop indefinitely.Updating shared variables concurrentlyThe Go memory model guarantees that the effect of a variable write is visible to instructions that come after that write within that goroutine only. That is, if you update a shared variable, you have to use special tools to make that update visible to other goroutines. A simple way to ensure this is to use a mutex. Mutex stands for “mutual exclusion.” A mutex is a tool you can use to ensurethe following:Only one goroutine updates a variable at anygiven timeOnce that update is done and the mutex is released, all goroutines can seethat updateIn this recipe, we show how thisis done.How to do it...The section of a program that updates shared variables is a “critical section.” You use a mutex to ensure that only a single goroutine can enter itscritical section.Declare a mutex to protect acritical section:// cacheMutex will be used to protect access to cachevar cacheMutex sync.Mutexvar cache map[string]any = map[string]any{}A mutex protects a set of shared variables. For instance, if you have goroutines that update a single integer, you declare a mutex for the critical sections that update that integer. You must use the same mutex every time you read or write thatinteger value.When updating the shared variable(s), first lock the mutex. Then perform the update and unlockthe mutex:cacheMutex.Lock()cache[key]=valuecacheMutex.Unlock()With this pattern, if multiple goroutines attempt to updatecache, they will queue atcacheMutex.Lock()and only one will be allowed. When that goroutine performs the update, it will callcacheMutex.Unlock(), which will enable one of the waiting goroutines to acquire the lock and update thecache again.When reading the shared variable, first lock the mutex. Then perform the read, and then unlockthe mutex:cacheMutex.Lock()cachedValue, cached := cache[key]cacheMutex.Unlock()if cached { // Value found in cache}Go Recipes for Developerswas published in December 2024. Packt library subscribers can continue reading the entire book for free or you can buy the book here!Get the eBook for $31.99$21.99🛠️Useful Tools⚒️lume: Alightweight CLI and local API server for managing macOS and Linux virtual machines with near-native performance on Apple Silicon, using Apple's Virtualization.Framework.klarity: Analyzes uncertainty in generative model outputs using probability entropy and semantic understanding to reveal model behavior and hallucination risks.iterm-mcp: A Model Context Protocol (MCP) server that enables models to inspect, interact with, and control an active iTerm session efficiently.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#90:React 19 Breaks CRA, AI-Powered Testing, Malicious Code Scanner, and Top Python Visualization ToolsJoin Snyk's Fetch the Flag CTF 2025!Snyk’s annual Capture the Flag event, Fetch the Flag 2025, is back! Hosted by Snyk and John Hammond, the event will take place on February 27, 2025, from 9am ET to 9pm ET. Engage in 20+ real-world security challenges, enhance your professional development & earn CPE credits.Register for free!Hi ,Welcome to a brand new issue of ProgrammingPro.In today’sExpert Insight, we bring you an excerpt from the recently published book, Software Architecture with Kotlin, which discusses the You Ain’t Gonna Need It (YAGNI) principle, emphasizing minimalism, avoiding over-engineering, and adapting to change by implementing only necessary features.News Highlights: React deprecates Create React App due to React 19 issues; Apiiro launches PRevent, a PR scanner for malicious code; Meta introduces ACH, an LLM-powered mutation testing tool; and Google introduces Gen AI Toolbox for Databases.My top 5 picks from today’s learning resources:Top Python Data Visualization Libraries of 2025📊From Rust to TypeScript: A New Chapter for Prisma ORM🔄2024 State of Rust Survey Results🦀The Software Event Horizon: Why Your Project Slows to a Crawl and How to Prevent It🐌Stop Conflating CQRS and MediatR📡But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefC++ Online Conference 2025 | 26th – 28th February – 15% Off Main Conference for ProgrammingPro Readers!🚀 Three days. 20+ expert talks. Live Q&A. Interactive sessions. Join the global C++ community from anywhere—no travel, no hassle, just top-tier learning.🎓 What’s in store?✅ Workshops (24th Feb – 7th Mar) – Master embedded systems, concurrency, coroutines, and more. Includes free main conference access.✅ Main Conference (26th – 28th Feb, 12:00 – 22:00 UTC) – Live talks, lightning sessions, interactive posters, and open community discussions.✅ Exclusive Features – Build your own agenda, access slides, join meetups, and network in an interactive virtual venue.💰 Exclusive Offer: ProgrammingPro readers get 15% off the main conference pass with code PACKT2025_15.Register now!Sign Up|Advertise🗞️News and Analysis🔎New open source tools to detect, defend against malicious code: Apiiro has released PRevent, a pull request scanner for detecting malicious code, and a Semgrep-based ruleset to help organizations combat code injection threats.React team formally deprecates Create React App (CRA) following ‘perfect storm of incompatibility’: CRA, introduced in 2016, was widely used but lacked critical features like routing, data fetching, and performance optimizations.Meta Introduces LLM-Powered Tool for Software Testing: Meta has introduced the Automated Compliance Hardening (ACH) tool, an LLM-powered mutation testing system that generates faults in code and creates targeted tests.C# Dev Kit Update: Enhancements to Solution-less Workspace and More: The latest update introduces solution-less workspace mode, .NET Aspire orchestration, and enhanced Razor/Blazor support.Feb 14, 2025: Development tools that have recently added new AI capabilities: Updates include Google’s Gen AI Toolbox for Databases, JetBrains AI Assistant’s local model support, Meta’s Imagen 3 API, and more.GitLab Release Brings Protected Container Repositories; Fixes XSS Vulnerability: GitLab 17.8 introduces protected container repositories, ML experiment tracking, VS Code SAST scanning, and enhanced deployment tracking.Type-safe C-killer Delphi hits 30, but a replacement has risen: The open-source Lazarus IDE with FreePascal has emerged as a powerful, cross-platform alternative with support for Delphi imports, which runs on Windows, Linux, macOS, and BSD.🎓Tutorials and Learning Resources💡PythonTop Python Data Visualization Libraries of 2025:pygwalkerleads as a low-code tool,matplotlib remains foundational with GPU support, and Plotly dominates dashboards. Seaborn,Bokeh, andAltaircater to statistical, streaming, and academic needs.For more Python resources, go to PythonProC# and .NET🎓How to Use Substring in C#: A Detailed Guide:Covers practical examples, edge cases, and common pitfalls, such as ArgumentOutOfRangeException , and offers solutions.🎓Create a Windows Forms app in Visual Studio with C#: Covers setting up a project, adding a button and a label, writing event-handling code, and running the application.💡Understand the .NET Framework requirements for various versions of SQL Server: Provides tables listing required .NET versions, whether they are included in SQL Server setup, and special installation steps for older Windows versions.C++ and C💡0+0 > 0: C++ thread-local storage performance: Explores TLS implementation details, including assembly-level behavior, compiler-generated overhead, and shared library implications.💡Understanding Memory Management, Part 2: C++ and RAII: Explains structs, object-oriented principles, inheritance, constructors, destructors, copy constructors, copy assignment operators, and more.💡Old C dog, new C tricks: NULL != ptr: Discusses a common C programming mistake—accidentally using = instead of == in conditionals—and how writing comparisons in reverse (e.g., if (42 == a)) prevents this error.Java🗞️Introducing the Model Context Protocol Java SDK: Discusses the SDK, explaining its features, integration with Spring AI, and how it enables seamless AI model interoperability.🎓The Hilarious World of Java Event Listeners: Humorously explains Java event listeners using relatable analogies, demonstrating how they handle button clicks, mouse movements, and keyboard inputs through practical examples.💡Deep Dive: Spring Boot with Apache Tomcat — Architecture and Request Handling: Covers architecture, request handling, connection management, thread pooling, scalability considerations, and troubleshooting.JavaScript and TypeScript🎓The Nullish Coalescing Operators: Explains the nullish coalescing operator (??) and nullish coalescing assignment (??=) in JavaScript, highlighting their benefits over || , their role in handling default values, and their applications.🎓How to Generate Insights from PDF Files with Apryse and GPT: Explains how to extract structured data from PDFs using Apryse’s data extraction module and integrate it with GPT-based LLMs to generate financial insights.💼From Rust to TypeScript: A New Chapter for Prisma ORM: Explains the motivations, architectural changes, benefits, and future opportunities for improved compatibility, deployment, and developer experience.Go💡Extensible Wasm Applications with Go: Covers Go 1.24's enhancements to Wasm support, including the go:wasmexport directive for exporting Go functions and the ability to build WASI reactors.💼We switched from Java to Go and don't regret it: Discusses Glasskube's transition from Java to Go, highlighting improved startup times, lower resource consumption, a more lightweight ecosystem, and better suitability for cloud-native applications.Rust🗞️2024 State of Rust Survey Results: Key findings include growing workplace adoption, increasing Rust expertise, concerns over slow compilation and debugging support, and a strong desire for stabilized async features.💡A survey of every iterator variant: Systematically categorizes and examines 17 different iterator variants in Rust, exploring their unique capabilities, challenges, and interactions.Swift🗞️Introducing gRPC Swift 2: The library introduces first-class concurrency support, modern APIs, and improved developer experience for building cross-platform, high-performance services in Swift.🎓Swift – Immediately Invoked Closures (IIC): Explains IIC's benefits, particularly in defining non-trivial properties and lazy initialization while ensuring maintainability and avoiding redundant code.PHP💡Learning from open source PHP projects - Part 1 - Code formatting: Examines best practices in code formatting by analyzing popular open-source PHP projects such as Flowphp, EventSauce, and Tempest.🗞️Accelerating The Adoption of Post-Quantum Cryptography: NIST has released the first Post-Quantum Cryptography (PQC) standards, prompting efforts to integrate these algorithms into PHP.SQL🎓Representing graphs in Postgresql: Explains how to represent and query graph-like data in PostgreSQL using nodes and edges tables, demonstrating simple parent-child lookups, friendship relationships, and recursive CTEs.📜The Impact of Metadata Configurations on Text-to-SQL Performance: A Comprehensive Analysis: Finds that using schema information, column descriptions, foreign keys, primary keys, and common queries yields the highest answer correctness at 84.5%.Ruby💡How I use YARD for Ruby: Introduces a documentation tool for Ruby, explaining its syntax, installation, usage, custom tags, and integration with VSCode.💡Decluttering UI Components in Ruby on Rails with ViewComponent: Explains how ViewComponent’s sidecar pattern helps declutter UI components in Ruby on Rails by consolidating related files, improving modularity, reusability, and maintainability.Kotlin🎓Android Use Cases: From Basic Implementation to Multi-Provider and Multi-Module Systems: Covers single-use cases, multi-provider implementations, and transitioning to multi-module structures.💼Kotlin Multiplatform (KMP) Scalability Challenges on a Large Project: Discusses scaling KMP in a project with over 1000 Gradle modules and 150+ developers, covering KMP migration methods, core library refactoring, and more.🌟Advanced Concepts🚀Google Titans Model Explained: The Future of Memory-Driven AI Architectures: Delves into Google's memory-driven AI model that integrates short-term, long-term, and persistent memory to improve sequence modeling.Architecture Decision Records (ADR): A Tool for Experienced Engineers: Explains ADRs, their purpose, implementation process, and benefits for engineers, highlighting how they improve transparency, and decision-making.Stop Conflating CQRS and MediatR: Clarifies the distinction between the two, explaining that CQRS is a pattern for separating read and write operations, while MediatR is a mediator pattern implementation that facilitates in-process messaging.The Software Event Horizon: Why Your Project Slows to a Crawl and How to Prevent It: Explains how unchecked technical debt, unclear interfaces, poor documentation, and increasing complexity, lead to stalled projects.API Governance: Using Patterns From PayPal, Netflix and More: Discusses different API governance models—centralized, federated, and self-governance—using real-world examples from companies, highlighting their trade-offs.🧠Expert Insight📚Here’s an excerpt from “Chapter 2: Principles of Software Architecture" in the book, Software Architecture with Kotlin, by Jason (Tsz Shun) Chow, published in December 2024.YAGNI and future-proof architectureYou Ain’t Gonna Need It(YAGNI) is a principle that states that functionalities should not be implemented until they are needed. This principle came fromExtreme Programming(XP) as an approach to improve software quality and respond to changing businessrequirements.This principle is also related to the idea of minimalism in software development, which states that we should avoid unnecessary code and complexity in exchange for clean, easy-to-understand, andextensible software.Another way to describe YAGNI is as the imperative to do the simplest thing that works. This is by no means an incomplete design or unfulfilled user requirement. It still promotes complete and functional software that satisfies user requirements with the simplestdesign available.YAGNI aims at a few practices:Simple and lean code base: By implementing only what is necessary now, a lot of complexity can be avoided. As a result, the code base is simple, clean,and maintainable.Prevention of over-engineering: Over-engineering happens when an engineer anticipates future requirements and includes unused features in the system. It not only results in wasted time on unnecessary work but also becomes a dead weight in the code base, which is then made harder to maintain. Over-engineered code also implies a design choice made before there is sufficient information to make that choice, locking in theapproach prematurely.Adaptive and flexible implementation: By delaying the implementation of a feature until it is needed, engineers have more options to adapt to changes when the feature is finally needed. It also encourages a more organic evolution of the system whereby engineers respond more effectively tochanging requirements.Productivity: By focusing on the absolute must-have requirements, engineers can deliver changes more quickly and efficiently. Any unnecessary features can be postponed, saving timeand resources.There is also an opposite idea though:future-proof architecture. It aims at creating systems that are unlikely to be obsolete or to fail in the future. This sounds very appealing. If we can build a system that can fulfill future requirements, we will have saved time and effort that would otherwise be spent continuouslyevolving it.However, there is an assumption behind this. You need to predict the new requirements and you need to be right. That is equivalent to knowing the future. Itrarely happens.If you are certain about requiring a feature in the future, then it is neither a prediction nor a future requirement. It is simply arequirement now.This does not mean that we should build systems based on short-term objectives or take shortcuts. Instead, we should build systems that are ready to adapt to new requirements but not havethese implemented.Capacity planningshould not be mistaken for future-proof architecture. Capacity planning is an operational concern related to deployment and physical resources. For instance, building a road to handle twice the current traffic is different from building a branch of the road that goes nowhere. Leaving headroom for expansion, extra volume, and extra traffic is part of the readiness for evolution. Capacity planning is an NFR, not a future requirement. We would not want the system to run on edges that may collapse in response to a fluctuation in the volumeof requests.This mindset leads to a few outcomes. The software architecture aims for modular, extensible, and flexible components that are ready to make changes when theybecome necessary.It implies that each component is highly cohesive but loosely coupled. It means that interfaces are small and specific. It also means that interactions among components are based on abstract interfaces and not concrete implementations. It further means that subclasses conform to the behaviors of their superclasses and are ready to be extended. Furthermore, it means that each component has only one reason to change. It also means that modifying a component does not require recompiling the entire system. It also means that concerns are separated so that when we want to adjust system quality attributes, we can address the particular concernin isolation.Software Architecture with Kotlinwas published in December 2024. Packt library subscribers can continue reading the entire book for free or you can buy the book here!Get the eBook for $31.99$21.99🛠️Useful Tools⚒️mastra: A TypeScript AI framework with workflows, agents, RAG, and LLM integrations, supporting OpenAI, Anthropic, and Google Gemini.CodeWeaver: A CLI tool that generates a Markdown document of your codebase, outlining its structure and embedding code for easy analysis.OmniParser: A vision-based screen parsing tool from Microsoft that converts UI screenshots into structured data for precise GUI automation with vision models.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}.reverse{display:table;width: 100%;

Bite-sized actionable content, practical tutorials, and resources for programmers#92:ByteDance's Trae AI Code Editor, Malicious Go Packages, Building AI Agents, and GPU ArchitectureHi ,Welcome to a brand new issue of ProgrammingPro.In today’sExpert Insight, we bring you an excerpt from the recently published book, TypeScript 5 Design Patterns and Best Practices, Second Edition, which discusses how developers transitioning from Java or Go often bring non-idiomatic patterns—such as Java’s verbose POJOs or Go’s explicit error-checking—both of which TypeScript simplifies with interfaces, factory functions, and exception handling.News Highlights: ByteDance launches Trae, an AI-powered code editor with free DeepSeek R1 and Claude 3.7 Sonnet access; GitHub expands Advanced Security tools to Team subscribers; major AI updates include OpenAI's GPT-4.5 preview and Claude Code; and seven malicious Go packages deploy malware on Linux and macOS.My top 5 picks from today’s learning resources:How to boost Python program performance with Zig⚡The correct way to do type punning in C++🔀Michigan TypeScript Founder Successfully Runs Doom Inside TypeScript's Type System🎮Roadmap: Understanding GPU Architecture🖥️Building AI Agents from Scratch | Full Course🧠But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefSign Up|Advertise🗞️News and Analysis🔎ByteDance Launches New AI Coding Tool Trae with DeepSeek R1 and Claude 3.7 Sonnet Free For All Users: Traesupports Visual Studio Code plugins, and provides Builder and Chat modes for generating applications and assisting with code.GitHub unbundling its GitHub Advanced Security offering starting in April: Previously available only to GitHub Enterprise customers, these tools will now be accessible to GitHub Team subscribers, expanding security options for organizations of all sizes.Feb 28, 2025: 10 AI updates from the past week: Updates include OpenAI's GPT-4.5 preview, Anthropic's Claude 3.7 Sonnet and Claude Code, Google’s Gemini 2.0 Flash-Lite and free Gemini Code Assist, and Microsoft’s Phi-4 models.Seven Malicious Go Packages Found Deploying Malware on Linux and macOS Systems: Although still available on the official package repository, most corresponding GitHub repositories have been taken down.OpenSSF Publishes Security Baseline for Open-Source Projects: The Open Source Project Security Baseline (OSPS) isa tiered security framework designed to help open-source maintainers improve project security by aligning with international cybersecurity standards.TypeScript 5.8 reaches general availability: The version introduces granular checks for branches in return expressions, performance optimizations, and improved ECMAScript module support.C++ creator calls for help to defend programming language from 'serious attacks': As cybersecurity experts advocate for languages with inherent memory safety features, Stroustrup has proposed the Profiles memory safety framework to enhance C++'s safety without a complete overhaul.🎓Tutorials and Learning Resources💡Legend:🎓 Tutorial/Course | 💼 Case Study | 💡 Insight/Analysis | 📜 Academic Paper |📖 Open Source BookPython💡The Secret Life of __init__.py : Why This Tiny File Holds the Key to Python’s Magic: Explains the purpose and functionality of the __init__.py file in Python, highlighting its crucial role in treating directories as packages and organizing modules efficiently within a Python project.🎓How to boost Python program performance with Zig: Covers both C-style shared libraries and native Python extensions, while highlighting tools like Pydust for easier development.For more Python resources, go to PythonProC# and .NET🎓Building Local AI Agents: Semantic Kernel and Ollama in C#: Details setting up the environment, creating a simple non-agentic agent, and running it to handle basic interactions, focusing on integrating Small Language Models.💡Unlock new possibilities for AI Evaluations for .NET: Introduces the Microsoft.Extensions.AI.Evaluations library, now open source, designed to integrate AI evaluation processes into .NET applications.🎓Poisson Regression Using C#: Demonstrates a technique useful for predicting counts in data approximating a Poisson distribution, such as call volumes and explains how to set up a model, train it with synthetic data, and interpret results.C++ and C💡C++26: no more UB in lexing: Discusses the resolution of undefined behaviors in C++ lexing through Corentin Jabot's proposal, P2621R3, which has been accepted to amend issues dating back to C++98.🎓The correct way to do type punning in C++: Explains the proper use of std::bit_cast in C++20 for safe type punning, replacing older methods that risk undefined behavior, in this informative tutorial.🎓Abusing C to implement JSON Parsing with Struct Methods: Covers parsing various JSON components such as atoms, arrays, and objects, and includes tips on managing memory and debugging.Java💡Microbenchmarks: Java Locks vs Atomic: Compares Java concurrency tools—synchronized, ReentrantLock, and AtomicLong—in microbenchmarks, finding that AtomicLong is the fastest.🎓SQL Injection in JDBC: A Technical Deep Dive: Using technical examples, the article explains that PreparedStatement separates SQL commands from data inputs, avoiding direct concatenation that leaves room for injection.💡How Java’s try-finally Blocks Work Without catch: Explains how Java's try-finally blocks ensure cleanup tasks are completed regardless of exceptions, using examples to demonstrate this fundamental behaviorJavaScript and TypeScript💡JavaScript Fatigue StrikesBack: Discusses the evolving JavaScript ecosystem, highlighting the complexity of choosing the right framework amidst rapid developments and new features like server-side rendering.🎓Preventing race conditions: My experience with LockManager in JavaScript: Describes using the LockManager API in JavaScript to effectively prevent race conditions across multiple browser tabs by ensuring exclusive function execution.💡Michigan TypeScript Founder Successfully Runs Doom Inside TypeScript's Type System: Mitropoulos achieved the remarkable feat by using an extensive and optimized codebase that processed 177 terabytes of TypeScript types to render the game.Go💡The cost of Go’s panic and recover: Explains how using Go's panic and recover for control flow is non-idiomatic and can degrade performance due to heavy computational demands and the mechanisms' tendency to prevent compiler optimizations.🎓Tips to debug hanging Go programs: Takes you through a detailed example involving the gokrazy/rsync tool and covers using SIGQUIT to print stack traces, attaching the Delve debugger for deeper analysis, and more.Rust🎓Demystifying monads in Rust through property-based testing: Explores monadic patterns in depth, offering practical Rust code examples and demonstrating how these patterns can significantly slow down the shrinking process.🎓Socrates is a state machine: Explores using Rust's async/await syntax, which de-sugars into a state machine, to write state machines for sans I/O network protocol APIs, demonstrating the process with the 9p protocol example.Swift💡What is Structured Concurrency?: Explains the paradigm's benefits for simplifying asynchronous programming by improving code readability, maintainability, and error handling, contrasting it with previous methods that used closures and Grand Central Dispatch.💡Clean Architecture + Swift 6: Discusses integrating Swift 6 features into an existing Clean Architecture setup for SwiftUI, detailing the transition to async/await for better asynchronous handling, and more.PHP💡The problem with indirections: Discusses the problematic overuse of indirections in programming, such as unnecessary variables, methods, and interfaces that complicate code and reduce maintainability.🎓Selenium in PHP for Web Scraping: A Step-by-Step Guide!: Covers setup, code examples, and best practices for effectively extracting data from dynamic JavaScript-heavy websites.SQL📜Debunking the Myth of Join Ordering: Toward Robust SQL Analytics: Introduces Robust Predicate Transfer (RPT), a new approach to SQL join order optimization that ensures robustness against varying join orders in acyclic queries.💡This Is Probably the Most Perfect Programming for Solving SQL Data Analysis Pain Points: Introduces esProc SPL as a superior alternative to SQL for complex data analysis tasks, highlighting its ability to process local file data directly without a database, and its simpler, procedural syntax.Ruby📖Open Source Book | I Love Ruby: A a comprehensive guide to learning Ruby covering installation, tools, basic to advanced programming concepts, and real-world examples and exercises.💡What's The Deal With Ractors?: Delves into the functionality and practicality of Ractors in Ruby, emphasizing their design for in-process parallelism without fully eliminating the Global VM Lock (GVL).Kotlin💼Kotlin Multiplatform (KMP) Scalability Challenges on a Large Project: Delves into the challenges and benefits of migrating a product feature from native development to KMP, and offers insights into KMP's performance and integration into existing systems.🎓Kotlininlinereifiedto Solve Type Erasure, and a Practical Guide onnoinline,crossinline , and More: Covers inline and reified keywords, explains their combined usage through practical examples, and discusses performance benefits and limitations.🌟Advanced Concepts🚀🎓Roadmap: Understanding GPU Architecture: Aims to explain the key architectural features of GPUs, how they compare to CPUs, and the implications for programming General-Purpose computing on GPUs (GPGPU).🎓Building AI Agents from Scratch | Full Course: Compiles four lessons on agentic design patterns into a single course, covering reflection, tool use, planning (React), and multi-agent patterns. Each pattern is implemented from scratch using Python and Groq as the LLM provider.💼Adopting Arm at Scale: Transitioning to a Multi-Architecture Environment: Details Uber's strategic scale-up from implementing Arm-based hosts in a primarily x86 infrastructure to a multi-architecture system involving thousands of services.💼Implementing a virtual rail architecture: Explains how IBM adapted traditional leaf/spine networking with virtual rail redundancy to balance network performance and reliability, addressing issues like unbalanced queue-pairs, Ethernet port utilization, and redundancy failures.💡Architectures of modern Front-end applications: Compares classical, modular, and Feature Sliced Design (FSD) architectures in modern front-end development, explaining their structures, benefits, and trade-offs.🧠Expert Insight📚Here’s an excerpt from “Chapter 10: Anti-Patterns and Workarounds" in the book, TypeScript 5 Design Patterns and Best Practices, Second Edition, by Theofanis Despoudis, published in February 2025.Using idiomatic code from other languagesWhen developers transition to TypeScript from other languages, they often bring coding patterns and idioms that may not be ideal in TypeScript. Although many programming concepts are shared between many languages,such as control loops, classes, and functions, there are many other concepts particular to one language that cannot be used in adifferent language.In the next subsections, we show some obvious cases where using some idiomatic constructs from other languages will not work well with TypeScript, starting first with theJava language.From the Java languageJava developers often usePlain Old Java Objects(POJOs) orJavaBeans. Let’s look at how this pattern might be inappropriately applied in TypeScript and then how toimprove it.POJO is a naming convention for creating a class that follows some rules, especially in the context of Java EE where object serialization is crucial for some operations. The more standardized version of POJOs is the JavaBean naming convention. When following this convention, you will need to adhere to thefollowing rules:Access levels: We mark all properties asprivateand we only allowgetterandsettermethods for accessor modification.Method names: When defininggetters, you will need to prefix the method withget– for example,getName()orgetEmail(). When definingsetters, you will need to prefix the method withset– for example,setName()orsetEmail().Default constructor: You need to use a constructor with no arguments and it mustbepublic.Serializable: The class needs to implement theSerializableinterface.To understand why using POJOs in TypeScript is not ideal, we’ll show an example class in TypeScript for a typicalEmployeemodel:Idiomatic-code.tsclass Employee { constructor(private id: string, private name: string) {} getName(): string { return this.name } setName(name: string) { this.name = name } getId(): string { return this.id } setId(id: string) { this.id = id }}If you attempt to declare more than one constructor in TypeScript, then you will find that it’s not allowed, so you cannot provide both a no-argument constructor and another one with arguments. Additionally, TypeScript will complain if you provide a no-argument constructor as the property’snameandIDmay have notbeen initialized.You will see thefollowing errors:Figure 10.1 – TypeScript compiler message when it complains when you use a no-argument constructorThe concept of serialization applies to Java only, so it’s not relevant to TypeScript. However, you can serialize plain TypeScript objects using theJSON.stringifymethodas follows:console.log(JSON.stringify(new Employee("Theo", "1")));//{"id":"Theo","name":"1"}You will find that this works only for basic cases and does not handle polymorphism, object identity, or when containing native JavaScript types such asMap,Set, orBigInt. However, in most cases, you can implement a custom object mapper or use a Factory Method to convert an object to JSON andvice versa.The use ofget/setmethods is overly verbose and not needed most of the time. If you want to provide encapsulation, you can only havegettermethods and if you want to modify an existingEmployeeclass method, you just create a newEmployeeinstance with the updated fieldname instead:const theo = new Employee("Theo", "1");new Employee(theo.getName(), "2");Finally, you may opt out of using classes altogether as you can work with types, type assignments, and object de-structuring,as follows:Idiomatic-code.tsinterface Employee { readonly id: string; readonly name: string; readonly department: string;}function createEmployee(id: string, name: string, department: string): Employee { return { id, name, department };}function updateEmployee(employee: Employee, updates: Partial<Employee>): Employee { return { ...employee, ...updates };}const emp = createEmployee('1', 'John Doe', 'IT');console.log(emp.name); // John Doeconst updatedEmp = updateEmployee(emp, { department: 'HR' });console.log(updatedEmp.department); // HRThis approach uses an interface instead of a class for simple data structures and provides factory functions for creation and updates, promoting immutability. This form is more idiomatic TypeScript and is the preferred way to workwith types.Now let’s look at some of the idiomatic constructs from theGo language.TypeScript 5 Design Patterns and Best Practices, Second Edition was published in February 2025. Packt library subscribers can continue reading the entire book for free or you can buy the book here!Get the eBook for $31.99$27.99🛠️Useful Tools⚒️onyx: An open-source Gen-AI and enterprise search platform that integrates with any LLM, connects to 40+ enterprise apps, and enables secure, scalable AI-powered research, chat, and custom agents.globstar: An open-source static analysis tool that lets developers write and run custom checkers using tree-sitter queries or Go in a single binary, integrating easily into CI/CD pipelines.drawdb: A free, browser-based database schema editor and SQL generator that lets you create, customize, and export diagrams effortlessly without an account.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#82Domain-Driven Design for Micro Frontends, .NET 9's JSON Boost, and Python Automation ScriptsHi ,Welcome to this week’s edition of ProgrammingPro!In today’sExpert Insight, we bring you an excerpt from the recently published book, The Art of Micro Frontends - Second Edition, which explains how Domain-Driven Design principles can help define and organize boundaries for micro frontends to ensure modular, isolated, and efficient architecture.News Highlights: .NET 9 launches with major performance boosts, including a 50% JSON processing gain; Java 24 targets memory savings with smaller object headers via Project Lilliput; the US urges developers to move from C and C++ for security; and GitHub Copilot chat adds prompt rewording guidance.My top 5 picks from today’s learning resources:20 Python scripts to automate common daily tasks⚙️Implementing the Repository Pattern with Multiple Databases in C# Clean Architecture🏗️Optimize Database Performance in Ruby on Rails and ActiveRecord🚄Top 50 System Design Terminologies You Must Know📚Netflix’s Distributed Counter Abstraction📊But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefP.S.:This month'ssurveyis now live. Do take the opportunity to leave us your feedback, request a learning resource, and earn your one Packt credit for this month.Sign Up|Advertise🗞️News and Analysis🔎.NET 9 is now available with several performance improvements:The version introduces a 15% increase in requests per second, optimized Server GC, faster LINQ operations, and a 50% boost in System.Text.Jsonprocessing.Java 24 to Reduce Object Header Size and Save Memory: This optimization is part of Project Lilliput and aims to improve memory density, reduce garbage collection pressure, and benefit workloads with small object sizes.Go language rises in Tiobe popularity index: The Google-developed Go language has reached its highest rank, seventh, in November 2024. Go aims to overtake JavaScript (ranked sixth) within three years.OpenJDK News Roundup: Instance Main Methods, Flexible Constructor Bodies, Module Import Declarations: With 19 JEPs targeted so far, JDK 24 is set for release in March 2025, featuring a robust set of updates aimed at performance, security, and language flexibility.The US government wants developers to stop using C and C++: While CISA mandates roadmaps for migration by 2026, widespread adoption is unlikely in the near future due to resistance, cost, and existing industry priorities.GitHub Copilot chat now provides guidance on rewording prompts: The updated chat suggests more specific prompts when a query lacks context, available in Visual Studio 2022 17.12 Preview 3 and aboveCloudflare Advocates for Broader Adoption of security.txt Standard for Vulnerability Reporting: Cloudflare has introduced a dashboard to create and manage security.txt files for vulnerability reporting, aligning with the RFC9116.🎓Tutorials and Learning Resources💡Python💡20 Python scripts to automate common daily tasks:Lists scripts for tasks such as sending emails, scraping news, downloading stock prices, backing up files, posting to social media, fetching weather updates, and resizing images.For more Python resources, go to PythonProC# and .NET🎓Tutorial | Pushed Authorization Requests (PAR) in ASP.NET Core 9: Explains how the new support for PAR enhances security in OAuth and OpenID Connect by moving sensitive data to secure back-channel requests.💡You Probably Don’t Need Those Interfaces: Challenges the common practice of using interfaces for every dependency, arguing that interfaces may be unnecessary for unit testing (due to modern mocking frameworks).🎓Tutorial | Implementing the Repository Pattern with Multiple Databases in C# Clean Architecture: Demonstrates using separate DbContext instances for different data types and a RepositoryFactory .C and C++🗞️A new chapter, and thoughts on a pivotal year for C++: Herb Sutter, the ISO C++ committee chair, has joined Citadel Securities, where he will lead C++ training and strategy while continuing his C++ standards work.🎓Tutorial | Around the World in C++: Exploring Time Zones with std::chrono: Explores time zone handling using C++20’s <chrono> library, demonstrating how to identify unusual time zones with non-hour UTC offsets.🧾The Design of a Self-Compiling C Transpiler Targeting POSIX Shell: Presents pnut, a C-to-POSIX shell transpiler designed to counteract software supply chain risks by enabling reproducible builds without relying on precompiled binaries.Java📖Open Access Book | Modern Java by Ethan McCue: Provides a structured introduction to Java, covering basics like data types, control flow, and methods, then progressing to complex topics such as classes and data structures.🎓Tutorial | How to Handle Errors Cleanly in Java: Principles for Scalable, Maintainable Code: Covers using custom exceptions, avoiding generic catch-all blocks, leveraging checked exceptions, and utilizing Optional to handle nulls.🎓Tutorial | Creating GenAI Apps in Java with SD4J (Stable Diffusion for Java) and the ONNX Runtime — Part 1: Details the setup of prerequisites such as JDK, ONNX Runtime, and Hugging Face tools, followed by step-by-step instructions to generate custom images from text prompts.JavaScript and TypeScript🎓Tutorial | JavaScript's ??= Operator: Default Values Made Simple: Explains the operator'sfunctionality, benefits over previous methods, and practical use cases for retaining meaningful falsy values.🎓Tutorial | Generating Random Mazes with JavaScript: Walks you through building a random maze generator in JavaScript using a three-step process with tips on handling blocked paths and using helper functions to manage grid cells.🎓Tutorial | Exploring Effect in TypeScript: Simplifying Async and Error Handling: Showcases how Effect can replace multiple libraries like Zod and Lodash, improving code readability and robustness in complex applications.Go🎓Tutorial | Functional programming in Go: Focuses on using functions as the primary control structures, enabling operations likemap,filter, andreduceto simplify and streamline data processing tasks.🎓Tutorial | ML in Go with a Python sidecar: Explores using ML in Go applications, focusing on techniques to integrate Python-based ML models, from cloud-based APIs to local sidecar servers.Rust💼Case Study | Why I love Rust for tokenising and parsing: Covers the author’s development experience using Rust to buildsqleibniz , a static analysis tool for SQLite, focusing on Rust’s macro system, testing frameworks, and more.🎓Tutorial | How to rewrite a C++ codebase successfully: Provides a structured guide for incrementally rewriting a legacy C++ codebase in Rust, focusing on real-world challenges such as cross-platform compatibility.Swift🎓Tutorial | Migrating to Swift 6: Provides a comprehensive framework for migration, including strategies for enabling concurrency checking, resolving common compiler errors, and incrementally adopting concurrency features.💡Problematic Swift Concurrency Patterns: Highlights common pitfalls and patterns to avoid when using Swift’s concurrency features, addressing issues like split isolation, excessive reliance on Task.detached , and more.PHP💡New error messages in PHP 8.4: Key updates include stricter handling of nullable parameters, limitations on unsetting hooked properties, and clearer messaging on invalid operations.SQL🎓Tutorial | 8 Steps in Writing Analytical SQL Queries: Steps covered include defining goals in plain language, inspecting and confirming basic data, incrementally adding joins without calculations, and using CTEs for summations.Ruby🎓Tutorial | Optimize Database Performance in Ruby on Rails and ActiveRecord: Covers best practices in ActiveRecord query optimization, indexing, reducing N+1 queries, batching, and caching techniques.💼Case Study | How we made a Ruby method 200x faster: Details how the team at Campsite identified and resolved a specific performance issue in their codebase, providing insights into their debugging process.Kotlin🎓Tutorial | Modeling ViewModel State in Android: A Guide to Clean, Scalable Patterns: Critiques using plain data classes with multiple Boolean flags, as this approach can lead to conflicting states and increased boilerplate.🌟Best Practices and Advice🚀Efficient Resource Management with Small Language Models (SLMs) in Edge Computing: Covers model optimization, latency reduction, and memory efficiency to support AI capabilities on limited hardware.Netflix’s Distributed Counter Abstraction: Delves into Netflix's Distributed Counter Abstraction, a system that enables high-throughput, low-latency counting within distributed applications.Top 50 System Design Terminologies You Must Know: Outlines essential system design terms covering key concepts like scalability, microservices, CAP theorem, sharding, and more.📖Open Access Book | Architectural Metapatterns by Denys Poltorak: Delves into over a hundred architectural patterns and structures, such as monoliths, layers, services, proxies, orchestrators, and more.🧠Expert Insight📚Here’s an excerpt from “Chapter 4: Domain Decomposition" in the book, The Art of Micro Frontends - Second EditionbyFlorian Rappl, published in October 2024.Principles of DDDThe idea of DDD was first popularized by Eric Evans. In his book, he describes the basic pillars that form DDD, according to his vision. While the book certainly has a lot of truth to it, the entire army of ideas was probably rarely—if ever—realized in real-world projects. Let’s try to distill the most importantideas for our use inmicro frontends.When we refer to DDD in the context of micro frontends, we will not include parts such as value objects or the need for a ubiquitous language. Instead, we almost exclusively take DDD as a blueprint to help us with the followingtwo things:Defining micro frontends withclear boundariesComing up with a strategy to establishthese boundariesWhile DDD uses the wordmodules, which was back then an alias forpackages, we will refer to this unit as amicro frontend. The other thing that DDD introduces is a so-called bounded context. Finally, DDD defines a context map to make sense of it. But let’s back off and look at eacharea separately.ModulesAmoduleserves as a container for a specific set of functionalities in your application. For a web application, this could relate to a full page or parts of a page. For instance, a module dealing with the order process could be responsible for showing a cart symbol on the pages of a web shop, such as the product catalog orproduct details.As mentioned, a module in DDD is usually what we will bring to the table in the form of a micro frontend. Nevertheless, keeping to a general notation here makes sense; after all, this helps us to see that good architectures rarely have anything to do with specific implementations but actually would work in multiple variants. In micro frontends, the functionality will be mostly designedaround components.A module is, however, a part of the full problem domain, focused on a specific area (or subdomain). The general design principles for modules are low coupling and high cohesion. As such, a micro frontend should represent a single unit to solve one problem without relying on any other microfrontend directly.In reality, we will be tempted to rely on other micro frontends to simplify the code. The one strong advice here is to avoid doing that, as the immediate simplification will usually backfire in a more complicated and less flexible solution later. When we start looking at the different architectural patterns later inChapter 7onward, we’ll see how to decouple themicro frontends.To help us figure out what could be part of a module, DDD introduces the theoretical concept of abounded context.Bounded contextAbounded contextis used to define the boundaries of the functionality of a subdomain. This is an area where only the functionality from a certain domainmakes sense.While this may initially seem similar to a module, it is actually quite different. Multiple modules live within the same bounded context. The bounded context is an umbrella connecting them and has nothing to do withruntime considerations.Bounded contexts are also broader than modules as they contain both unrelated concepts and shared concepts. Naturally, this will result in some overlap and duplication between differentbounded contexts.The following diagram illustrates the relationship of two bounded contexts within an exampleproblem domain:Figure 4.1 – Relation of two bounded contexts in an example problem domainHow we split a bounded context into modules is up to us. In the end, however, a more critical question is,what are the bounded contexts in our problem domain?There is no blueprint here, but a nice way to visualize and think about contexts generally is in the form of acontext map.Context mapAcontext mapis a useful tool to illustrate the involved contexts of a system, including their connections. Instead of reusing objects from other contexts, a transformation defined by the context map should be used to always createdomain-specific objects.For our design decisions, a context map can be helpful to see where sharing occurs and how to still produce isolated micro frontends. To do this, we need to first identify these self-contained domains. This is where two principal ways come into play: strategic domain design and—as an alternative—tactical design. Let’s lookat both.Strategic domain design versus tactical designWhile strategic domain design helps us to extend knowledge of a problem domain and come up with useful guidelines, tactical design tries to come up with design patterns and building blocks that form a system. In other words, strategic domain design identifies the different domains and the communication between them, while tactical design is all about structuringthese domains.In our micro frontend space, we have the choice of leaving the tactical design to the implementers of the micro frontends, giving them some guidance, or predefining a structure that needs to be followed already. We will see later on how these architectural boundaries can actuallybe decided.In contrast, strategic domain design is helpful for decomposing a full problem domain into smaller (sub) domains. Starting with a full problem domain, we derive the individual subdomains and extract their bounded contexts. The relationship between the contexts is then captured in a context map. The following diagram shows thistheoretical process:Figure 4.2 – The idealized process of deriving a full domain decomposition from a given problem domain, including a working context mapThe Art of Micro Frontends - Second Edition was published in October 2024. Packt library subscribers can continue reading the entire book for free or you can buy the bookhere!Get the eBook for $29.99$20.98🛠️Useful Tools⚒️Aide: An open-source, AI-native IDE that proactively supports developers with context-aware code edits, error fixes, and easy rollbacks.Arch: An open-source prompt gateway that helps build scalable, secure AI apps with prompt safeguards, API triggers, and built-in monitoring.Sulie: An open-source platform for advanced time series forecasting with the Mimosa foundation model, offering zero-shot and fine-tuned predictions.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, take the surveyor just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Bite-sized actionable content, practical tutorials, and resources for programmers#94:Python Developer Tooling, Theia AI & IDE, Java 24’s Big Changes, and Diamond AI Code ReviewerLevel up your coding skills with the Python: From Beginner to Advanced Bundle by Packt. Learn to code and gain amazing insights from books like Learn Python Programming,Building AI Intensive Python Applications,Modern Time Series Forecasting with Python, and more. This library of 20+ programming books are perfect for novice coders and seasoned pros in growing your career. Plus, your purchase helps support the Python Software Foundation. Starting at US$1.Check out the Python Humble BundleHi ,Welcome to a brand new issue of ProgrammingPro.In today’s Expert Insight, we share an excerpt from our conversation with Fabrizio Romano, author of Learn Python Programming, Fourth Edition. He discusses Python’s strengths, limitations, evolving concurrency, AI-powered coding tools, and its future.News Highlights: Eclipse Foundation launches Theia AI and AI-powered Theia IDE; Java 24 launches with 24 new features, including generational GC and 32-bit x86 removal; Google’s Gemma 3, OpenAI’s Responses API, and Visual Studio's GPT-4o code completion debut; and Graphite unveils Diamond AI code reviewer.My top 5 picks from today’s learning resources:Python Developer Tooling Handbook📖Reverse Engineering OpenAI Code Execution to make it run C + JavaScript🔍Speeding up C++ code with template lambdas⚡Were multiple return values Go's biggest mistake?🤔Beyond Trends: A Practical Guide to Choosing the Right Message Broker📡But there’s more, so dive right in.Stay Awesome!Divya Anne SelvarajEditor-in-ChiefSign Up|Advertise🗞️News and Analysis🔎Eclipse Foundation unveils open source AI development tools: Theia AI (a customizable open-source AI integration framework) and an AI-powered Theia IDE (an AI-enhanced development environment), have been launched.Java 24 Delivers New Experimental and Many Final Features:Oracle has released Java 24 with 24 new features, including experimental generational garbage collection, and the removal of the Windows 32-bit x86 port and Security Manager.Mar 14, 2025: 10 AI updates from the past week: Updates include the release of Gemma 3 by google, launch of Responses API by OpenAI, availability of Boomi AI Studio and Visual Studio's GPT-4o code completion, and more.OpenSilver 3.2 Takes WPF Apps to Mobile with .NET MAUI Hybrid Integration: The open-source, WebAssembly-based reimplementation of the deprecated Microsoft Silverlight, now enables applications to run on mobile and desktop platforms while maintaining a single XAML/C# codebase.Graphite debuts Diamond AI code reviewer, insists “AI will never replace human code review”: The AI-powered code review tool detects bugs, style issues, and security vulnerabilities.GCC 15 compilers move toward completion: The version set for release in late April or early May, introduces a Cobol front end, defaults C compilation to C23, and adds C++23 and C++26 features.Oracle reveals five new features coming to Java: These include stable values (JDK 25), enhanced primitive boxing, null-restricted value classes, value classes and objects, and derived record creation.🎓Tutorials and Learning Resources💡Legend:🎓 Tutorial/Course | 💼 Case Study | 💡 Insight/Analysis | 📖Open Access BookPython📖Python Developer Tooling Handbook: A guide to navigating Python's development ecosystem, covering package management, linting, formatting, and dependency tools, structured using the Diátaxis framework with tutorials.💡Which Python GUI library should you use?: Compares Python GUI libraries available in 2025, evaluating their strengths, use cases, and licensing, with recommendations for different project types.For more Python resources, go to last week's PythonProC# and .NET🎓Delegates (C# Programming Guide): Covers the types' characteristics, usage, and related concepts like lambda expressions and multicast delegates.🎓Streamlining .NET 9 Deployment With GitHub Actions and Azure: Explains how to set up a CI/CD pipeline for .NET 9 applications using GitHub Actions and Azure App Service, covering automated builds, and more.🎓Neural Network Quantile Regression Using C#: Presents an end-to-end demonstration of neural network quantile regression in C#, explaining how to train a model that predicts numeric values with quantile-based confidence.C++ and C💡Speeding up C++ code with template lambdas: Explains different approaches, from basic template functions to C++20 template lambdas, and evaluates alternative strategies, including template metaprogramming.💡Polymorphic, Defaulted Equality: Uncovers the pitfalls of defaulted equality in polymorphic hierarchies and how to implement safe, efficient comparisons in C++.💡Stupid Smart Pointers in C: Introduces free_on_exit(), a function that automatically frees memory when a function returns by hijacking the return address using inline assemblyJava🎓Finding Java classes that are only used by tests: Explains how to identify and remove Java classes that are only referenced in tests by analyzing class dependencies, filtering test-only references, and systematically deleting unused code.💡Why Java endures: The foundation of modern enterprise development: Explores Java’s enduring relevance in enterprise development, highlighting its evolution, ecosystem, and adaptability to modern needs like AI.JavaScript and TypeScript💡Reverse Engineering OpenAI Code Execution to make it run C + JavaScript: Covers OpenAI’s code execution environment's secure sandbox structure, prompt injection vulnerabilities, and techniques to run C and JavaScript within the Python-based Jupyter kernel system.🎓Understanding DOM Node Types in JavaScript (With Examples!): ExplainsElement, Attribute, Text, Comment, Document, and Document Fragment nodes, with practical examples of their use.🎓Agentic TDD in Typescript with Minimal Dependencies: Demonstrates using an AI agent to iteratively generate and refine code until all tests pass, leveraging OpenAI’s SDK, Vitest, and Vite while minimizing dependencies.Go💡Were multiple return values Go's biggest mistake?: Critiques Go’s multiple return values, arguing that their lack of tuple support complicates error handling, concurrency, and generic abstractions, leading to unnecessary workarounds.💼My 6 months with the GoTH stack: Building front-ends with Go, HTML and a little duct tape: Reviews the author’s six-month experience using the GoTH stack (Go, Templ, Tailwind, and HTMX) highlighting its benefits and challenges.Rust💡Is Rust a good choice for business apps?: Argues that Rust is a poor choice for business applications due to its complex dependency ecosystem, strict borrow checker, painful async model, and higher development effort.📖The Embedded Rust Book: An introductory book about using the Rust Programming Language on "Bare Metal" embedded systems, such as Microcontrollers.Swift💡Behind the scenes of async functions: Explains how Swift Concurrency works internally, focusing on async functions, tasks, jobs, executors, and the Cooperative Thread Pool.SwiftUI Closures on the Main Thread: Why@MainActor Is a Game-Changer: Explains how @MainActor in SwiftUI ensures UI-related closures run on the main thread automatically, reducing the need for manual dispatching.PHP🎓Monitor HTTP Interactions with Laravel’s New Http::record() Method: Introduces Laravel’s new Http::record() method, which enables monitoring real HTTP requests without blocking them, making debugging, logging, and testing API interactions easier.SQL💡Think About SQL MERGE in Terms of a RIGHT JOIN: Demonstrating howthe SQL MERGE statement updates, inserts, or deletes records based on matching criteria between source and target tables.💡Optimizing Cloud SQL Memory Performance: An SRE’s Guide: Provides an SRE-focused guide to optimizing Cloud SQL memory performance, covering key memory metrics, their interpretation, and mitigation strategies.Ruby💡Ruby Debugging Tips and Recommendations in 2025: Provides updated Ruby debugging best practices for 2025, covering tools like Ruby LSP, debug.gem , and integration with IRB, along with configuration tips.Kotlin💡Using the Android Context and Manifest to Unveil the Android System Mechanics (2025 Edition): Explains how the Android Context and Manifest enable communication between applications and the Android system, manage app components, and facilitate inter-process communication.🧠Expert Insight: Exploring Python with Fabrizio Romano📚An author's insights on Python’s strengths, challenges, and futureExtracted from a converstation with Fabrizio Romano, co-author of Learn Python Programming, Fourth Edition.Fabrizio Romano, a seasoned software developer and author of Learn Python Programming (now in its fourth edition), has spent over a decade teaching Python. He has taught Python to professional software engineers and data students through collaborations with Oxford University and other institutions. In this part of the discussion, he shares his journey with Python, its strengths and limitations, and how the language continues to evolve.Discovering Python: A Journey from C# to SimplicityQ: What originally drew you to Python?Fabrizio: In the early 2000s, I was primarily working with C#, Java, and PHP. I also enjoyed competitive programming challenges in my spare time. On one of these platforms, I noticed another competitor using Python. His solutions were conceptually similar to mine but significantly more concise. That intrigued me—I decided to explore Python and was struck by its readability, indentation-based syntax, and expressive nature. What started as an experiment soon became a long-term professional relationship with the language.One of the platforms I used early on was Project Euler, which is heavily math-oriented. Solving problems with Python allowed me to learn its built-in data structures and understand which were optimal for different algorithms. Through these challenges, I developed a deep appreciation for Python’s efficiency and elegance.The Allure of Python: Why It Stands OutQ: Why would you recommend Python to new developers?Fabrizio: Python has a gentle learning curve, making it accessible to beginners. Its syntax is close to natural language, and its standard library and extensive third-party ecosystem reduce the need to reinvent the wheel. The language is also highly versatile, spanning web development, automation, machine learning, and more.Another key advantage is Python’s expressiveness. Compared to Java or C++, Python code is significantly shorter, allowing developers to focus on solving problems rather than dealing with verbose syntax. It also maintains consistency across different data structures. For example, regardless of the collection type, you can simply use len(collection) to get its size, eliminating inconsistencies found in other languages.Python is also backed by a strong global community, which means there is a vast amount of support available through documentation, tutorials, and open-source contributions. The ecosystem includes a wide range of tools that make development smoother, from testing frameworks to packaging solutions.Navigating Python’s LimitationsQ: Where does Python fall short?Fabrizio: Performance is often a consideration—while Python is flexible, it is not the fastest language. That’s why libraries like NumPy and TensorFlow, which handle computationally intensive tasks, are built in C. Python is also not ideal for mobile development. While frameworks like Kivy and BeeWare exist, native languages like Swift and Kotlin are better suited for mobile applications.Concurrency has traditionally been a challenge due to Python’s Global Interpreter Lock (GIL). However, Python 3.13 introduces an experimental free-threaded mode, signaling improvements in this area. Despite the GIL, many high-performance applications already circumvent these limitations using multiprocessing, async I/O, and JIT-compilation techniques.Additionally, while Python is widely used in back-end development, JavaScript and TypeScript still dominate the front-end space. That said, frameworks exist that allow Python to be used in front-end development by compiling into JavaScript, though it is still a translation layer rather than a native approach.The Role of AI in CodingQ: What are your thoughts on AI-powered coding assistants like GitHub Copilot?Fabrizio: AI tools are changing how developers write code. At Sohonet, we adopted GitHub Copilot across the team, and it has proven valuable in handling repetitive tasks and structuring code efficiently. It also helps developers by intelligently predicting test cases and speeding up refactoring.However, I caution against over-reliance on AI. Programming is not just about writing code—it’s about problem-solving and understanding logic. AI should be used to enhance productivity, not replace fundamental thinking skills. Developers should still challenge themselves with problems to keep their critical thinking skills sharp.Additionally, developers should be mindful of how AI suggestions influence their approach to coding. While AI can generate solutions, understanding why a particular approach is valid remains crucial. Developers should maintain a balance between leveraging AI’s speed and honing their own problem-solving skills.Looking AheadQ: How do you see Python evolving in the coming years?Fabrizio: Python continues to improve in performance, tooling, and concurrency management. The introduction of structural pattern matching, type annotations, and enhanced tooling like Black and Ruff simplifies development. Additionally, efforts to unify package management, such as the UV project, are making Python’s ecosystem more beginner-friendly.Python’s adaptability ensures it remains a dominant force across industries. With AI advancements and optimizations to the core language, it will continue to be a top choice for developers worldwide. The tooling around Python is also evolving—Jupyter Notebooks have revolutionized how we teach and document code, and deployment processes have been transformed by containerization and tools like Docker.Python’s strength lies in its ability to evolve while maintaining its core philosophy of simplicity and readability. As the ecosystem continues to grow, developers can expect even more powerful tools and streamlined workflows to enhance productivity.Author Bio:Fabrizio Romano holds a master’s degree in computer science engineering from the University of Padova and has been working as a professional software developer since 1999 and with Python since 2007. Today, he is the development manager of the Sohonet product development team.He gave talks at Europython (Berlin 2014, Bilbao 2015) and ProgSCon 2016, on the topics of teaching Python programmingto every employee of a whole company, and TDD and testing with Python. In 2022, he also collaborated with Oxford University, teaching Python to professional software engineers, and data science students. In his free time, he mostly enjoys playing the guitar and teaching meditation, maths, and Python programming.His book Learn Python Programming, Fourth Edition was published in November 2024.Buy along with the Humble Bundle for only $25!Get the eBook for $35.99$31.99🌟Advanced Concepts🚀Beyond Trends: A Practical Guide to Choosing the Right Message Broker: Examines key characteristics, such as ordering, throughput, auto-scaling, poison pill handling, and batch processing, and aligns them with common messaging patterns.The Hidden Burden of Architectural Decision Fatigue (And How to Fix It): Explains how to reduce architectural decision fatigue by implementing a structured decision-making process using an Architectural Decision Matrix and ADR.Four kinds of software: Categorizes software into four types—Control, Interactive, Streaming, and Computational—andexplores their architectural styles, design patterns, and implementation details.🛠️Useful Tools⚒️open_deep_research: An open-source AI assistant that automates research and report generation with customizable models, prompts, and search tools.build-your-own-x: A collection of guides for building technologies from scratch, aiding deep learning through hands-on projects.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 usefulhere.If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Curated for software engineers, game developers, and frontend specialistsEssential Guides to C# 13 and .NET 9, AI in Unreal Engine 5, and Angular TDDHi ,This week, we’re bringing you three new books for developers working with today’s most in-demand tools. Master C# 13 and .NET 9 for cross-platform development, create smarter AI-driven games with Unreal Engine 5, or deliver high-quality code with test-driven development in Angular—each now at upto 30% off.Bundle up & save more!Buy 2 eBooks – save an additional 10%Buy 3 eBooks – save an additional 15%Buy 5 eBooks – save an additional 20%Here’s what’s on offer:C# 13 and .NET 9 – Modern Cross-Platform Development Fundamentals - Ninth Edition by Mark J. PriceStart building websites and services with ASP.NET Core 9, Blazor, and EF Core 9>Explore the newest additions to C# 13, the .NET 9 class libraries, and Entity Framework Core 9>Build professional websites and services with ASP.NET Core 9 and Blazor>Enhance your skills with step-by-step code examples and best practices tipsGet the eBook for $35.99$24.99Get the Print book for $44.99Artificial Intelligence in Unreal Engine 5 by Marco SecchiUnleash the power of AI for next-gen game development with UE5 by using Blueprints and C++>Adopt AI techniques for developing immersive gameplay experiences>Learn how to use the Unreal Engine gameplay framework system with C++ and Blueprints>Plan and develop AI behaviors carefully from start to finishGet the eBook for $39.99$27.98Get the Print book for $49.99Mastering Angular Test-Driven DevelopmentbyBuild high-quality Angular apps with step-by-step instructions and practical examples>Implement test-driven development practices in Angular using tools like Jasmine, Karma, and Cypress>Understand end-to-end testing through real-world scenarios and practical examples>Discover best practices for incorporating TDD into continuous integration and deployment (CI/CD) processesGet the eBook for $30.99$20.99Get the Print book for $37.99*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}

Curated for cybersecurity pros, app developers, and DevOps expertsMaster Microsoft’s Best-Kept Secrets in Cybersecurity, DevOps, and App DevelopmentHi ,Whether you’re fortifying cybersecurity, streamlining app management, customizing ERP workflows, or building responsive apps, mastering Microsoft’s ecosystem is crucial. This week, we bring you four new guides that transform Microsoft’s complexity into clear, actionable skills across security, Power Platform, Dynamics 365, and Power Apps—all now at 30% off.Bundle up & save more!Buy 2 eBooks – save an additional 10%Buy 3 eBooks – save an additional 15%Buy 5 eBooks – save an additional 20%Here’s what’s on offer:Microsoft Cybersecurity Architect Exam Ref SC-100 - Second Edition by Abu Zobayer, Graham Gold, and Dwayne NatwickA high-demand certification book for IT pros focused on advancing their cybersecurity skills and passing the SC-100 exam.>Prepare for the SC-100 exam with in-depth coverage, mock tests, and practical examples.>Master zero-trust architecture, encryption standards, and threat intelligence.>Elevate your security expertise by optimizing operations with SIEM and SOAR.Get the eBook for $39.99$27.98Get the Print book for $49.99Microsoft Power Apps Cookbook - Third Edition by Eickhel MendozaAppeals broadly to app developers, IT pros, and non-developers looking to build custom business solutions in a low-code environment.>Create apps with AI-powered Copilot, custom UI components, and advanced automation.>Accelerate development using ready-made recipes for Power Apps.>Expand app functionality with Dataverse, RPA, and Power Pages integration.Get the eBook for $39.99$27.98Get the Print book for $49.99Application Lifecycle Management on Microsoft Power Platform byBenedikt BergmannA valuable resource for developers and DevOps specialists managing app deployments on the Power Platform.>Automate builds and deployments with Azure DevOps and GitHub Actions.>Implement a robust ALM strategy tailored to Power Platform solutions.>Streamline environment management across Power Apps, Power Automate, and Power Virtual Agents.Get the eBook for $35.99$24.99Get the Print book for $44.99Programming Microsoft Dynamics 365 Business Central - Seventh Edition byChristopher D. Studebaker, Natalie Karolak, Marije Brummel, and David StudebakerIdeal for ERP consultants and developers focused on customizing and extending Business Central for complex business needs.>Customize Business Central workflows using AL language and Visual Studio Code.>Integrate external systems with Business Central using API web services.>Optimize business solutions with best practices for scalability and reliability.Get the eBook for$35.99 $24.99Get the Print book for $44.99*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}