It's time for another edition of Reading Notes! This week brings exciting developments in the open source world, with major announcements from Microsoft making WSL and VS Code's AI features open source. We've also got updates on Azure Container Apps, .NET Aspire, and some great insights on developer productivity tools.
Let's dive into these interesting reads that caught my attention this week.
Cloud
Happy 5th Birthday Bicep! (Sam Cogan) - What?! Five years already! That's incredible, I remember all the discussion about how we make our business better and honestly, bicep is a big success. Congrats to the team
Have I Been Pwned 2.0 is Now Live! (Troy Hunt) - New look, new merch, and confetti, all without API breaking changes! Learn all about this major update in this post.
What's new in .NET Aspire 9.3 (David Pine) - Wow! How so many great new features can be added in a single version?! Aspire is a must for all .NET developers.
Accelerate Your .NET Upgrades with GitHub Copilot (McKenna Barlow) - That's the tool I've been waiting for ages! Adding a Copilot to the extension is the smartest move they could make. I'm going to update an app right away. I'll share more later
Open Source
Edit is now open source (Christopher Nguyen) - That's a great news! I installed it half through the post and it great! Fast, simple, and tiny!! Love it!
Agent mode for every developer (Katie Savage) - Great new for everyone as the agent mode become available in so many different editor. This post also contains videos to shows some scenarios.
Podcasts
Reimagining the Windows Terminal with Warp's Zach Lloyd (Scott Hanselman) - A very interesting talk with the CEO of Warp that answers so many questions I had about this very different terminal. Really interesting episode, and terminal too BTW)
The experience is enough (Salma Alam-Naylor) - Whether we like it or not, we are people creature. We all need to stop hiding behind our screens and get out there!
Automating deployments is something I always enjoy. However, it's true that it often takes more time than a simple "right-click deploy." Plus, you may need to know different technologies and scripting languages.
But what if there was a tool that could help you write everything you need—Infrastructure as Code (IaC) files, scripts to copy files, and scripts to populate a database? In this post, we'll explore how the Azure Developer CLI (azd) can make deployments much easier.
What do we want to do?
Our goal: Deploy the 2D6 Dungeon App to Azure Container Apps.
This .NET Aspire solution includes:
A frontend
A data API
A database
The Problem
In a previous post, we showed how azd up can easily deploy web apps to Azure.
If we try the same command for this solution, the deployment will be successful—but incomplete:
The .NET Blazor frontend is deployed perfectly.
However, the app fails when trying to access data.
Looking at the logs, we see the database wasn't created or populated, and the API container fails to start.
Let's look more closely at these issues.
The Database
When running the solution locally, Aspire creates a MySQL container and executes SQL scripts to create and populate the tables. This is specified in the AppHost project:
var mysql = builder.AddMySql("sqlsvr2d6")
.WithLifetime(ContainerLifetime.Persistent);
var db2d6 = mysql.AddDatabase("db2d6");
mysql.WithInitBindMount(source: "../../database/scripts", isReadOnly: false);
When MySQL starts, it looks for SQL files in a specific folder and executes them. Locally, this works because the bind mount is mapped to a local folder with the files.
However, when deployed to Azure:
The mounts are created in Azure Storage Files
The files are missing!
The Data API
This project uses Data API Builder (dab). Based on a single config file, a full data API is built and hosted in a container.
Locally, Aspire creates a DAB container and reads the JSON config file to create the API. This is specified in the AppHost project:
var dab = builder.AddDataAPIBuilder("dab", ["../../database/dab-config.json"])
.WithReference(db2d6)
.WaitFor(db2d6);
But once again, when deployed to Azure, the file is missing. The DAB container starts but fails to find the config file.
The Solution
The solution is simple: the SQL scripts and DAB config file need to be uploaded into Azure Storage Files during deployment.
You can do this by adding a post-provision hook in the azure.yaml file to execute a script that uploads the files. See an example of a post-provision hook in this post.
Alternatively, you can leverage azd alpha features: azd.operations and infraSynth.
azd.operations extends the provisioning providers and will upload the files for us.
infraSynth generates the IaC files for the entire solution.
💡Note: These features are in alpha and subject to change.
Each azd alpha feature can be turned on individually. To see all features:
azd config list-alpha
To activate the features we need:
azd config set alpha.azd.operations on
azd config set alpha.infraSynth on
Let's Try It
Once the azd.operation feature is activated, any azd up will now upload the files into Azure. If you check the database, you'll see that the db2d6 database was created and populated. Yay!
However, the DAB API will still fail to start. Why? Because, currently, DAB looks for a file, not a folder, when it starts. This can be fixed by modifying the IaC files.
One Last Step: Synthesize the IaC Files
First, let's synthesize the IaC files. These Bicep files describe the required infrastructure for our solution.
With the infraSynth feature activated, run:
azd infra synth
You'll now see a new infra folder under the AppHost project, with YAML files matching the container names. Each file contains the details for creating a container.
Open the dab.tmpl.yaml file to see the DAB API configuration. Look for the volumeMounts section. To help DAB find its config file, add subPath: dab-config.json to make the binding more specific:
You can also specify the scaling minimum and maximum number of replicas if you wish.
Now that the IaC files are created, azd will use them. If you run azd up again, the execution time will be much faster—azd deployment is incremental and only does "what changed."
The Final Result
The solution is now fully deployed:
The database is there with the data
The API works as expected
You can use your application!
Bonus: Deploying with CI/CD
Want to deploy with CI/CD? First, generate the GitHub Action (or Azure DevOps) workflow with:
azd pipeline config
Then, add a step to activate the alpha feature before the provisioning step in the azure-dev.yml file generated by the previous command.
- name: Extends provisioning providers with azd operations
run: azd config set alpha.azd.operations on
With these changes, and assuming the infra files are included in the repo, the deployment will work on the first try.
Conclusion
It's exciting to see how tools like azd are shaping the future of development and deployment. Not only do they make the developer's life easier today by automating complex tasks, but they also ensure you're ready for production with all the necessary Infrastructure as Code (IaC) files in place. The journey from code to cloud has never been smoother!
If you have any questions or feedback, I'm always happy to help—just reach out on your favorite social media platform.
Welcome to this week's collection of fascinating reads across cloud computing, AI, and programming! As technology continues to evolve at breakneck speed, I've gathered some of the most insightful articles that caught my attention. From securing MCP servers to exploring Rust, there's something here for every tech enthusiast.
Dive in and discover what's new in our rapidly changing digital landscape.
When ASP.NET Core Identity Is No Longer Enough (Andrea Chiarelli) - Authentication and authorization have an important place in our Apps. This post shares details about how things work and the different processes.
New Docker Extension for Visual Studio Code (Remy Suen) - This extension was already a must, they made it better, it's a must must! But seriously give it a try and try it by yourself.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Welcome to this week's reading notes! I've found some great articles that caught my eye - from security tips for MCP servers to exciting updates in Rust and AI. Whether you're into cloud services, programming tools, or wondering about the future of coding with AI, there's something here for you.
Let's dive in!
Programming
The Aspire Compiler (David Fowler) - I really appreciate Aspire. It's one of the tools that completely changed my experience as a developer. Learning more about it is, without a doubt, interesting.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Have you ever wanted to give your AI assistants access to your own custom tools and data? That's exactly what Model Context Protocol (MCP) allows us to do, and I've been experimenting with it lately.
I read a lot recently about Model Context Protocol (MCP) and how it is changing the way AI interacts with external systems. I was curious to see how it works and how I can use it in my own projects. There are many tutorial available online but one of my favorite was written by James Montemagno Build a Model Context Protocol (MCP) server in C#. This post isn't a tutorial, but rather a summary of my experience and what I learned along the way while building a real MCP server that manages short URLs.
MCP doesn't change AI itself, it's a protocol that helps your AI model to interact with external resources: API, databases, etc. The protocol simplifies the way AI can access an external system, and it allows the AI to discover the available tools from those resources. Recently I was working on a project that manages short URLs, and I thought it would be a great opportunity to build an MCP server that manages short URLs. I wanted to see how easy it is to build and then use it in VSCode with GitHub Copilot Chat.
Code: All the code of this post is available in the branch exp/mcp-server of the AzUrlShortener repo on GitHub.
Setting Up: Adding an MCP Server to a .NET Aspire Solution
The AzUrlShortener is a web solution that uses .NET Aspire, so the first thing I did was create a new project using the command:
dotnet new web -n Cloud5mins.ShortenerTools.MCPServer -o ./mcpserver
Required Dependencies
To transform this into an MCP server, I added these essential NuGet packages:
Microsoft.Extensions.Hosting
ModelContextProtocol.AspNetCore
Since this project is part of a .NET Aspire solution, I also added references to:
The ServiceDefaults project (for consistent service configuration)
The ShortenerTools.Core project (where the business logic lives)
Integrating with Aspire
Next, I needed to integrate the MCP server into the AppHost project, which defines all services in our solution. Here's how I added it to the existing services:
var manAPI = builder.AddProject<Projects.Cloud5mins_ShortenerTools_Api>("api")
.WithReference(strTables)
.WaitFor(strTables)
.WithEnvironment("CustomDomain",customDomain)
.WithEnvironment("DefaultRedirectUrl",defaultRedirectUrl);
builder.AddProject<Projects.Cloud5mins_ShortenerTools_TinyBlazorAdmin>("admin")
.WithExternalHttpEndpoints()
.WithReference(manAPI);
// 👇👇👇 new code for MCP Server
builder.AddProject<Projects.Cloud5mins_ShortenerTools_MCPServer>("mcp")
.WithReference(manAPI)
.WithExternalHttpEndpoints();
Notice how I added the MCP server with a reference to the manAPI - this is crucial as it needs access to the URL management API.
Configuring the MCP Server
To complete the setup, I needed to configure the dependency injection in the program.cs file of the MCPServer project. The key part was specifying the BaseAddress of the httpClient:
var builder = WebApplication.CreateBuilder(args);
builder.Logging.AddConsole(consoleLogOptions =>
{
// Configure all logs to go to stderr
consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
});
builder.Services.AddMcpServer()
.WithTools<UrlShortenerTool>();
builder.AddServiceDefaults();
builder.Services.AddHttpClient<UrlManagerClient>(client =>
{
client.BaseAddress = new Uri("https+http://api");
});
var app = builder.Build();
app.MapMcp();
app.Run();
That's all that was needed! Thanks to .NET Aspire, integrating the MCP server was straightforward. When you run the solution, the MCP server starts alongside other projects and will be available at http://localhost:{some port}/sse. The /sse part of the endpoint means (Server-Sent Events) and is critical - it's the URL that AI assistants will use to discover available tools.
Implementing the MCP Server Tools
Looking at the code above, two key lines make everything work:
builder.Services.AddMcpServer().WithTools<UrlShortenerTool>(); - registers the MCP server and specifies which tools will be available
app.MapMcp(); - maps the MCP server to the ASP.NET Core pipeline
Defining Tools with Attributes
The UrlShortenerTool class contains all the methods that will be exposed to AI assistants. Let's examine the ListUrl method:
[McpServerTool, Description("Provide a list of all short URLs.")]
public List<ShortUrlEntity> ListUrl()
{
var urlList = _urlManager.GetUrls().Result.ToList<ShortUrlEntity>();
return urlList;
}
The [McpServerTool] attribute marks this method as a tool the AI can use. I prefer keeping tool definitions simple, delegating the actual implementation to the UrlManager class that's injected in the constructor: UrlShortenerTool(UrlManagerClient urlManager).
The URL Manager Client
The UrlManagerClient follows standard HttpClient patterns. It receives the pre-configured httpClient in its constructor and uses it to communicate with the API:
public class UrlManagerClient(HttpClient httpClient)
{
public async Task<IQueryable<ShortUrlEntity>?> GetUrls()
{
IQueryable<ShortUrlEntity> urlList = null;
try{
using var response = await httpClient.GetAsync("/api/UrlList");
if(response.IsSuccessStatusCode){
var urls = await response.Content.ReadFromJsonAsync<ListResponse>();
urlList = urls!.UrlList.AsQueryable<ShortUrlEntity>();
}
}
catch(Exception ex){
Console.WriteLine(ex.Message);
}
return urlList;
}
// other methods to manage short URLs
}
This separation of concerns keeps the code clean - tools handle the MCP interface, while the client handles the API communication.
Using the MCP Server with GitHub Copilot Chat
Now for the exciting part - connecting your MCP server to GitHub Copilot Chat! This is where you'll see your custom tools in action.
Configuring Copilot to Use Your MCP Server
Once the server is running (either deployed in Azure or locally), follow these steps:
Open GitHub Copilot Chat in VS Code
Change the mode to Agent by clicking the dropdown in the chat panel
Click the Select Tools... button, then Add More Tools
Selecting the Connection Type
GitHub Copilot supports several ways to connect to MCP servers:
There are multiple options available - you could have your server in a container or run it via command line. For our scenario, we'll use HTTP.
Note: At the time of writing this post, I needed to use the HTTP URL of the MCP server rather than HTTPS. You can get this URL from the Aspire dashboard by clicking on the resource and checking the available Endpoints.
After selecting your connection type, Copilot will display the configuration file, which you can modify anytime.
Interacting with Your Custom Tools
Now comes the fun part! You can interact with your MCP server in two ways:
Natural language queries: Ask questions like "How many short URLs do I have?"
Direct tool references: Use the pound sign to call specific tools: "With #azShortURL list all URLs"
The azShortURL is the name we gave to our MCP server in the configuration.
Key Learnings and Future Directions
Building this MCP server for AzUrlShortener taught me several valuable lessons:
What Worked Well
Integration with .NET Aspire was remarkably straightforward
The attribute-based approach to defining tools is clean and intuitive
The separation of tool definitions from implementation logic keeps the code maintainable
Challenges and Considerations
The csharp-SDK is only a few weeks old and still in preview
OAuth authentication isn't defined yet (though it's being actively worked on)
Documentation is present but evolving rapidly as the technology matures, so some features may not be fully documented yet
For the AzUrlShortener project specifically, I'm keeping this MCP server implementation in the experimental branch mcp-server until I can properly secure it. However, I'm already envisioning numerous other scenarios where MCP servers could add great value.
If you're interested in exploring this technology, I encourage you to:
This post gathers my recent reading notes on artificial intelligence, programming, and a few inspiring podcasts. It includes links to articles, tutorials, and fascinating discussions. Whether you're interested in the latest AI developments, .NET tools, or modern architectures, there's plenty here to spark your curiosity.
Vertical Slice Architecture with Jeremy Miller (.NET Rocks!) - This episode is about Vertical Slice Architecture, what it is, when it makes sense to use it, and some comparisons with the others that we know.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
In this week Reading Notes, we explore a diverse range of updates and insights from the tech world. From the latest features in the Azure SDK and Developer CLI, to an introduction to .NET Aspire and its innovative approach to Infrastructure as Code, there's plenty to catch up on.
Jump into discussions on AI productivity, free Azure SQL tiers, and even a refreshing podcast on stress-free living.
Let's get started!
Cloud
Azure SDK Release (March 2025) (Hector Norzagaray) - Many languages are supported and now Rust is part of it. There also some new bits for Node and Python.
Does AI really make you more productive? (Salma Alam-Naylor) - I trust AI as much as I trust any code found after googling.Meaning it might works but to I need to understand what it is doing. There is no trust, is always gambling.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week, I explored posts about improving cache management for ASP.NET Core applications and understanding error handling in Blazor. These articles, along with others on AI model selection and development productivity, offer valuable insights for developers.
Selecting the right model for coding (Mark Downie) - Nice post that answers a question, that I'm sure many of us thought without really knowing the answer.
Miscellaneous
Announcing Dapr AI Agents (Mark Fussell, Yaron Schneider, Roberto Rodriguez) - I like those tech savvy agent that knows about one thing. I f|l I can trust them more and it usually go faster.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
If you have interesting content, share it!
Cloud
Azure Developer CLI (azd) - March 2025 - The azd CLI just got better, with some new features, improved error messages, and of course bug fixes. Don't forget to update your version.
.NET Aspire and Dev Container (Laurent Kempé) - DevContainers are really a game changer. You don't have to be a container guru to use it, and it will make a dev environment constant everywhere on any device.
Welcome to Reading Notes —a curated dive into the latest and greatest in programming, cloud, and AI. From mastering multithreading with Azure to exploring GitHub Copilot's productivity potential, this collection is brimming with knowledge. Let's unravel what's new, innovative, and worth your attention!
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Welcome to this week's roundup! I'm excited to share some standout blog posts and podcasts that caught my attention. Enjoy exploring the latest updates, tips, and insights!
Suggestion of the week
azd CDN changing January 2025 (Kristen Womack) - Important note, that will probably impact many of you, like I was. Luckily the fix is very simple
AI Killed the Content Creator...Star 🤩 (Kirupa) - Interesting observation. The artificial intelligence is impacting all processes and changes the way we interact with the world. Will I kill it or change it?
Podcasts
438: Jon Galloway - From Submarine Office to Software Developer (Merge Conflict) - Super interesting episode about Jon. I learn more in those minutes than in all the time I've been working with him! But at the same time, a Teams call is not "the place" to share about Submarine stuff I guess ;)
.NET Aspire with Anthony Simmon (Hanselminutes) - Interesting episode about .NET Aspire by someone who is using it in his day to day and have been extending it. Great conversation, very interesting.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
During the holidays, I embarked on a fun project to create a visual countdown for important dates. Inspired by howmanysleeps and hometime from veebch, I wanted to build a countdown that didn't rely on Google Calendar. Instead, I used a Raspberry Pi Pico and some custom code to achieve this.
After cloning the repo, navigate to the src/NextEvent/ folder and use the Azure Developer CLI to initialize the project:
azd init
Enter a meaningful name for your resource group in Azure. To deploy, use the deployment command:
azd up
Specify the Azure subscription and location when prompted. After a few minutes, everything should be deployed. You can access the URL from the output in the terminal or retrieve it from the Azure Portal.
How to Set Up the Raspberry Pi Pico
Edit the config.py file to add your Wi-Fi information and update the number of lights on your light strip.
You can use Thonny to copy the Python code to the device. Copy both main.py and config.py to the Raspberry Pi Pico.
How It Works
The website creates a JSON file and saves it in a publicly accessible Azure storage.
When the Pi is powered on, it will:
Turn green one by one all the lights of the strip
Change the color of the entire light strip a few times, then turn it off
Try to connect to the Wi-Fi
Retrieve the timezone, current date, and settings from the JSON file
If the important date is within 24 days, the countdown will be displayed using random colors or the specified colors.
If the date has passed, the light strip will display a breathing effect with a random color of the day.
The Code on the Raspberry Pi Pico
The main code for the Raspberry Pi Pico is written in Python. Here's a brief overview of what it does:
Connect to Wi-Fi: The connect_to_wifi function connects the Raspberry Pi Pico to the specified Wi-Fi network.
Get Timezone and Local Time: The get_timezone and get_local_time functions fetch the current timezone and local time using online APIs.
Fetch Light Settings: The get_light_settings function retrieves the important date and RGB colors from the JSON file stored in Azure.
Calculate Sleeps Until Special Day: The sleeps_until_special_day function calculates the number of days until the important date.
Control the LED Strip: The progress function controls the LED strip, displaying the countdown or a breathing effect based on the current date and settings.
The Configuration Website
The configuration website is built in C#. It's a Blazor server webapp, and I used .NET Aspire to make it easy to run it locally. The UI uses FluentUI-Blazor so it looks pretty, without effort.
The website allows you to update the settings for the Raspberry Pi Pico. You can set the important date, choose custom colors, and save these settings to a JSON file in Azure storage.
Little Extra
The website is deployed in Azure Container App with a minimum scaling to zero to save on costs. This may cause a slight delay when loading the site for the first time, but it will work just fine and return to "dormant" mode after a while.
I hope you enjoyed reading about my holiday project! It was a fun and educational experience, and I look forward to working on more projects like this in the future.
What's Next?
Currently the project does a 24 days countdown (inspired from the advent calendar). I would like to add a feature to allow the user to set the number of days for the countdown. I would also like to add the possibility to set the color for the breathing effect (or keep it random) when the important date has passed. And lastly, I would like to add the time of the day when the light strip should turn on and off, because we all have different schedule 😉 .
Last thoughts
I really enjoyed doing this project. It was a fun way to learn more about the Raspberry Pi Pico, micro-Python (I didn't even know it was a thing), and FluentUI Blazor. I hope you enjoyed reading about it and that it inspired you to create your own fun projects. If you have any questions or suggestions, feel free to reach out, I'm fboucheros on most socials.
This week, ReadingNotes shares some insightful blog posts that caught my attention. From embracing a positive mindset and integrating local AI models with .NET Aspire, to leveraging Docker for cloud-native development and exploring AI-powered Blazor Kanban, there's plenty to dive into. Happy reading!
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week, I stumbled upon some fascinating reads. From the announcement of .NET 9 and its incredible versatility to an intriguing new type of failover for Azure Storage, there's plenty to explore. Discover how to get .NET 9 running on your Raspberry Pi, check out the latest Blazorise update, and delve into the power of GitHub Models in .NET with Semantic Kernel. Plus, don't miss out on the introduction of GitHub Copilot for Azure and a new season of AI-related sessions in Visual Studio. And for my fellow open-source enthusiasts, the .NET Aspire Community Toolkit is a game-changer.
Dive in and let's geek out together! 🌟
Suggestion of the week
Announcing .NET 9 - .NET Blog (.NET Team) - You can build anything with C# (aka .NET) and I love it! With runs everywhere, it's open source, it's fast and free!
Introducing GitHub Copilot for Azure (Chris Harris) - After trying it, I can tell that it is pretty amazing! It's like have someone else besides you with the Azure portal answering all you're questions.
Integrating .NET Aspire With Azure Storage (Fiodar Sazanavets) - Nice wait to have an emulator for local work. I will have to check this as I'm using Azure table storage in many of my projects.
Open Source
Introducing the .NET Aspire Community Toolkit - .NET Blog (Aaron Powell) - Very happy (and proud) about this OSS project. .NET Aspire makes things so much easier for developers. And now we can simply add more types of integration thanks to the CF.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Welcome to this week’s reading notes! In this post, you’ll find a curated selection of insightful articles and tutorials covering various topics in technology and programming. Whether you’re looking to enhance your testing skills with .NET Aspire, improve your code comprehension with GitHub Copilot, or explore the world of Docker for DevOps, there’s something here for everyone. Dive in and enjoy these valuable resources!
If you have interesting content, share it!
Suggestion of the week
Getting started with testing and .NET Aspire (Aaron Powell) - This is a great tutorial, with a video version if you prefer, to get us started with test when .NET Aspire is part obor solution.
Hosting a (DevOpsDays) Tech Conference (Dewan Ahmed) - I went to this even and you could feel it was prepared with patio and care. It very interesting to learn about the behind the scene and all the work put both before and after.DevOpsDay Halifax you won my heart.
It's reading notes time! It is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Working with tar files in .NET 8 (Andrew Lock) - A nice post that explored and show what we can to do with tarbal from .NEt and explains some of the limitations.
Blazor Basics: Testing Blazor Components with BUnit (Claudio Bernasconi) - We all agree that tests are important (or we should). bUnit is specially build for Blazor Applications. If you are using this web frontend you should definitely have a look!This post helps you getting started.
It's reading notes time! It is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Back from a two weeks time off it was nice to get back into tech read.
Adding .NET Aspire to your existing .NET apps (Jon Galloway) - This great post explains step by step how to add .NET Aspire to your existing app, saying what you gain and how it's helping you to be faster at buildinba better application.
Combining multiple docker images into a multi-arch image (Andrew Lock) - Another great article from Andrew that explains very clearly a Docker feature: generate multiple image under the same ta to target different OS and infrastructure (ex: x64,arm32)
Logging in Banana Cake Pop (Pascal Senn) - What a amazing new feature! This will greatly improve development and debugging productivity!
The ultimate guide to developer happiness (Jeimy Ruiz) - Many great tools and solution within GitHub "circle". This post provides best practices to improve developers productivity and announces when the next GitHub Universe is coming up.
In this week’s Reading Notes, we explore cloud debugging, .NET Aspire, and more. Join us for insights, workshops, and podcasts covering a range of exciting topics! 🚀
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Cloud
GalaSoft Laurent Bugnion (Laurent Bugnion) - Nice post debugging investigating a bug, that cannot be reproduce locally only in the cloud.... But with the right tools it's much easier.
Apprendre .NET Aspire en français (Frank Boucher) - Another shameless plug for French content this time. I did a 1h45 long video where I explain the basic of .NET Aspire by doing a workshop and providing details.
What is platform engineering? (Julia Kulla-Mader, Chuck Lantz) - Platform engineering is gaining in popularity, but what ibis really. This article gives a good explanation to start our learning journey.
Happy Canada Day! It's reading notes time! It is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
You also read something you liked? Share it!
Cloud
Is .NET Aspire NuGet for Cloud Service Dependencies? (Phil Haack) - I like the comparison with NuGet. Using .NET Aspire in a project does indeed simplify a lot things. I'll be waiting for that follow up post.
Announcing TypeScript 5.5 - TypeScript (Daniel Rosenwasser) - Really good news for the JavaScript developers. This post shares all the new features like ECMAScript, Set Methods support, and the performance improvement included in this release candidate of Typescript.
Blazor Basics: Dealing with Complex State Scenarios (Claudio Bernasconi) - Interesting package Fluxor that help managing states. The post also explains different pros and cons of methods to maintain states.
