Advertise with Us|Sign Up to the Newsletter

Join us on July 19 for a 150-minute interactive MCP Workshop. Go beyond theory and learn how to build and ship real-world MCP solutions. Limited spots available! Reserve your seat today.

Hi ,

Bugfixes, AI upgrades, security alarms and one privacy blunder that has everyone talking. From core tooling like Django, Spring, and Python getting critical fixes, to OpenAI's smoother GPT-4o and a major misstep in Meta’s AI app design, this week’s webdev round-up is packed with updates that may not make the front page, but absolutely belong in your workflow.

Here’s your quick brief:

In the Expert corner, devs debate the value of Rust compiler speed, explore the rise of passkeys in Spring Security, and unpack how prompt-first AI design could reshape tooling entirely. Read Benj Edward’s o3-pro take or see how David Crawshaw wrestles with AI agents in real workflows.

📘 This week’s book pick: Practical Serverless and Microservices with C#.
Whether you’re scaling with Azure Functions or simplifying microservices with .NET Aspire, this guide hits both breadth and depth. Grab your copy today!

Got a tip or take? Send it our way and you might see it featured in WebDevPro!

Advertise with us
Interested in reaching our audience? Reply to this email or write to kinnaric@packt.com.
Learn more about our sponsorship opportunities here.

From framework fixes to AI feature upgrades (and one major privacy red flag), this week’s updates span the tools and topics shaping modern development. Whether you're deep in Python, Spring, or just keeping an eye on AI evolutions, here’s what’s worth your attention.

Your code has a rhythm. Your focus should too. This week, we’re tuning into music that powers better dev sessions:

Because sometimes the best productivity tool... is a good pair of headphones.

What are developers really talking about right now? Whether it’s speculative AI, secure auth, or the eternal love-hate with compilers, this week’s community picks capture the pulse.

📘 Practical Serverless and Microservices with C# by Gabriel Baptista and Francesco Abbruzzese

Learn how to build secure, scalable apps using Azure Functions, Container Apps, and .NET Aspire. This book shows you when to use microservices and serverless and when not to, while guiding you through real-world scenarios, cost planning, and best practices for cloud-native development.

Meet Gabriel...

Gabriel Baptista is a tech leader with 20+ years in software development. He heads a team building retail and industrial apps, serves on a tech advisory board, teaches computer engineering, and co-founded start-ups in automation and logistics. He’s also taught software and IT at multiple institutions.

Francesco Abbruzzese, author of the MVC and Blazor Controls Toolkits, has championed the Microsoft web stack since ASP.NET MVC's inception. His company, Mvcct Team, builds web apps, tools, and services. He began with AI-based financial decision systems and later contributed to top-10 games like Puma Street Soccer.

If you’ve worked with Kubernetes for local microservices testing, you know the setup can be heavy. In this excerpt from Practical Serverless and Microservices Applications with C# and Azure, see how the same scenario is simplified using .NET Aspire — a lighter, code-first way to orchestrate microservices locally:

Using .NET Aspire in practice

In this section, we will adapt the Kubernetes exampleto run with Aspire. As a first step, let’s copy the whole solution folder into another in a different location, so we can modify it without destroying the previous version.

Then, let’s execute the following steps to prepare the overall solution:

The preceding steps prepare the solution for .NET Aspire. Now, let’s start modifying the code. As a first step, we must add service defaults to all the microservices. Therefore, let’s add builder.AddServiceDefaults(); to the program.cs file of the FakeSource, FakeDestination, and RoutesPlanning projects. Then, we must add app.MapDefaultEndpoints(), which adds health endpoints just to the program.cs file of the RoutesPlanning project, since it is the only web project that we have among our microservices. It must be placed as shown here:

var app = builder.Build();
app.MapDefaultEndpoints();

Now, let’s remember that we added all the microservices parameters as environment variables in their Properties/launcheSettings.json file. We placed them in the Docker launch settings. Now, since these projects will not use Docker anymore while running in Aspire, we must copy all these definitions into the other launch setting profile.

This is the launch settings code of the RoutesPlanning project after this change:

{
"profiles": {
"http": {
"commandName": "Project",
"environmentVariables": {
//place here your environment variables
"ConnectionStrings__DefaultConnection": "Server=localhost;
Database=RoutesPlanning;User Id=sa;Password=Passw0rd_;
Trust Server Certificate=True;MultipleActiveResultSets=true",
"ConnectionStrings__RabbitMQConnection": "host=localhost:5672;
username=guest;password=_myguest;publisherConfirms=true;timeout=10",
"Messages__SubscriptionIdPrefix": "routesPlanning",
"Topology__MaxDistanceKm": "50",
"Topology__MaxMatches": "5",
"Timing__HousekeepingIntervalHours": "48",
"Timing__HousekeepingDelayDays": "10",
"Timing__OutputEmptyDelayMS": "500",
"Timing__OutputBatchCount": "10",
"Timing__OutputRequeueDelayMin": "5",
"Timing__OutputCircuitBreakMin": "4"
},
"dotnetRunMessages": true,
"applicationUrl": "http://localhost:5212"
},
"Container (Dockerfile)": {
…
…

Want the full walkthrough with real code, resource config, and deployment guidance?
Pre-order the book!

🔐 Mastering OAuth 2.0: Secure Authorization Simplified

Understanding OAuth 2.0 is crucial for modern web development, especially when dealing with third-party integrations. OAuth 2.0 allows users to grant limited access to their resources without sharing credentials. For instance, enabling an application to access your profile data without exposing your password.

Key components of the OAuth 2.0 flow include:

A typical flow involves the user authorizing the client, the client receiving an authorization grant, exchanging it for an access token from the authorization server, and then accessing the resource server using that token.

Another week, another stack of updates, hot takes, and low-key chaos. If your brain’s buzzing with thoughts, tools, or spicy dev opinions, don’t gatekeep.

Until next time.

Cheers!

Kinnari Chohan,

Editor-in-chief