“When it comes to code reviews, it’s a common phenomenon that there is much focus and long-winded discussions around mundane aspects like code formatting and style...” The Code Review Pyramid by
@gunnarmorling
–
.
@shanselman
is starting a new YouTube series: Computer things they didn't teach you in school, starting with the concepts of carriage returns and line feeds
NServiceBus 7 is ready, we’ve got your back.
The ultimate cross-platform messaging stack!
You’re off to Great Places! Today is your day!
There’s more than Windows now, so…get on your way!
In other words, NServiceBus 7 for .NET Core is here.
“There are plenty of times in my career when I’ve stored a boolean and later wished I’d had a timestamp. There are zero times when I’ve stored a timestamp and regretted that decision” — You might as well timestamp it, by
@jerodsanto
:
“Most people won't see much risk in moving to .NET Core these days. Blazor, on the other hand, doesn't have a clear path to success” — The Blazor Bet by
@OdeToCode
:
“Most .NET apps use a DbContext for data access, but maintainability can suffer when the use of a DbContext or an IQueryable derived from it is allowed to spread throughout an app.” Avoid Proliferating DbContext or IQueryable in .NET Apps by
@ardalis
Last chance to sign up for our free Advanced Distributed Systems Design online course. It will revert back to a paid course on May 15. Sign up now and you'll still have 60 days to complete it:
Did you see
@konradkokosa
first "async/await in a single picture" blog post? There's a new one about the SynchronizationContext and deadlocks — The danger of async/await and .Result in one picture:
Over 99% of all C# files on GitHub have just one namespace, with one level of pointless indentation affecting the whole file. Sound silly? Learn about dotnet format and file-scoped namespaces in C# 10 from
@ardalis
“CRUD API isn’t bad but it is a nightmare when you actually need to handle complexity. If you want to develop a system that moves logic out of end-users heads…then be task-driven and focus on business capabilities.”
@codeopinion
on CRUD API & complexity
We've released the new NServiceBus
@AzureServiceBus
transport for
#netcore
, including a migration path that allows you to transition your system gradually with zero downtime. Read all about it in our latest blog post:
Both Kafka and RabbitMQ use messages but they are fundamentally different. This detailed article can help you find out which one is better suited for your needs — When to use RabbitMQ or Apache Kafka:
The .NET Generic Host will probably become the most commonly used starting point of any .NET application.
@Sahan91
explains how it works in his blog post:
Understanding .NET Generic Host Model –
Our brand new package makes it easy to host NServiceBus in a .NET Generic Host in .NET Core 3.0 with a .UseNServiceBus() extension method.
Announcement:
Documentation:
In a theme park, you need to monitor how many people can ride a ride and which rides have the longest lines. Distributed software systems aren't much different! Maximizing fun (and profit) in your distributed systems, on our blog:
"Event Sourcing is a beautiful solution for high-performance or complex business systems, but you need to be aware that this also introduces challenges most people don’t tell you about." The Ugly of Event Sourcing – Real-world Production Issues by
@ddoomen
“ Perhaps initially a bit of a shock, but this a major version and a lot of work is being done to make C# and .NET more welcoming” — Exploring a minimal Web API with Core 6, by
@shanselman
:
The top 5 patterns for event-driven architecture, according to
@codeopinion
. (Incidentally, it's not an accident that NServiceBus handles all of these patterns for you.)
Using Jupyter Notebooks with .NET is quite cumbersome. With .NET interactive notebooks, all you need is Visual Studio Code and
@andrewlocknet
as your guide:
A neat trick hooking into the
#aspnetcore
IHostApplicationLifetime abstraction... Avoiding downtime in rolling deployments by blocking SIGTERM by
@andrewlocknet
—
Wild - through duck typing and extension methods you can just make just about anything awaitable, even booleans. await false & await true by
@konradkokosa
“Boundaries are hard to define. When you focus on business capabilities and not technical concerns, you have to get deeper insights into the actual business domain. [It] isn’t trivial to figure out.”
@codeopinion
on Microservices & Service Boundaries
In this post,
@buhakmeh
shows two ways to build multi-tenant apps With EF Core and
#AspNetCore
Both approaches have their advantages and disadvantages, so you’ll have to pick the one that works best for you.
What does an anti-corruption layer solve? Most systems rely on data or behaviors from a 3rd party, but often don’t share the same semantics or data structures. Left unchecked this leads to convoluting your own boundary with concepts from another.
“Guard clauses, on the surface, sound like a great idea. … However, I find guard clauses used in the real world to be of little value.” Stop using trivial Guard Clauses! Try this instead by
@codeopinion
–
Presentation by
@jbogard
at InfoQ: Getting from Monolith to Microservices - strategies to break a monolith, including database refactoring and analysis tools to see dependencies in legacy code
A task-based UI can be a critical tool for designing systems with proper service boundaries, not to mention properly capturing the context of what your users are trying to accomplish.
@codeopinion
shows you how: Decomposing CRUD to a Task Based UI
.NET async/await in a single picture — Great blog post by
@konradkokosa
if you want to know more about how async/await interacts with the I/O completion port —
“Even the simplest builds are complicated these days” —
@OdeToCode
reminds us about this great tool from
@KirillOsenkov
to deal with MSBuild log files:
“The bad news is that there are still some really wacky, unexplainable anti-HTTPS views out there, but those voices are increasingly less relevant as the browsers march forward” — Why No HTTPS? The 2021 Version, by
@troyhunt
:
“The only way to produce robust, non-brittle tests is to make them target observable behavior, not implementation details” — How to Assert Database State, by
@vkhorikov
:
Wouldn't
#NServiceBus
be better if you could get beautiful graphs showing queue length, throughput, retries, processing time, and critical time? Yes it would. Check it out!
Ready to bring your entire developer team to the next level? With the free-for-a-limited-time Distributed Systems Design Fundamentals course, you can all join
@UdiDahan
and boost your distributed systems architecture game.
If your local pizza place can adapt to out-of-order delivery of information, your software should be able to as well. You don't need ordered delivery, by
@dvdstelt
If you plan to deploy your app to Kubernetes, this series by
@andrewlocknet
is exactly what you need — An Introduction to Kubernetes: Deploying Core applications to Kubernetes - Part 1
Introducing IHostLifetime and untangling the Generic Host startup interactions by
@andrewlocknet
- explains how Core 3.0 has been re-platformed on top of the generic host, and some of the benefits that brings.
NServiceBus ❤️ .NET Core: Release Candidate now available! Includes go-live license! Go send, publish, and process messages on the platform of your choice! Do it now!
Rewriting the entire system is not the answer to dealing with an existing monolith. Learn how to use event-driven architecture to break your way out of monoliths and evolve it to where you need it to be.
In event-driven systems, large events are a design smell…keep them as small as possible. Services should really only share IDs and maybe a timestamp to indicate when the information was effective. Putting your events on a diet, on our blog:
Our new Public Preview packages for Azure Functions let you use all the good stuff you're used to with NServiceBus with just a bit of code to set up the functions endpoint. Check out the samples!
Azure Service Bus:
Azure Queues:
Did you know the rise of shopping malls in the US was an indirect effect of the creation of the Interstate Highway System? You might be surprised to learn of some of the indirect effects of using
#NServiceBus
. (Better than crowded malls, we promise!)
"I'm not old enough to say get off my lawn, but..."
@udidahan
casts a critical eye over the cargo cult forming around event sourcing in his opening keynote at
@ddd_eu
this year —
In event-driven systems, large events are a design smell…keep them as small as possible. Services should really only share IDs and maybe a timestamp to indicate when the information was effective. Putting your events on a diet, on our blog:
#AspNetCore
3.0 is coming soon.
@andrewlocknet
created an excellent overview of the upcoming changes — Exploring the new project file, Program.cs, and the generic host in Core 3:
Core 3 can detect (some) missing service bindings on the dependency injection container at startup.
@andrewlocknet
runs you through this new feature and it's caveats:
"How do you compose an aggregate? For me aggregate design involves understanding the invariants." Aggregate Design: Using Invariants as a Guide by
@codeopinion
—
You can easily add health checks to your Core apps using the Microsoft.Extensions.Diagnostics.HealthChecks package. Or go even further and add a nice UI for monitoring — Core Health Checks by
@sharpcms
:
“In this post I’m going to walk through how I used TDD myself to build a feature and try to explain why I wrote the tests I did, and why I sequenced things as I did.” Real Life TDD Example by
@jeremydmiller
–
“How do you share data between services? This is one of the most common questions when you have a system composed of many different services, and each service owns a data set.” — “I NEED data from another service!” ... Do you really? by
@codeopinion
“In a large system, modeling your domain, defining boundaries, and how they relate is far more important than concerning yourself if you’re using the Repository pattern correctly” — STOP doing dogmatic Domain Driven Design, by
@codeopinion
:
Visual Studio supports additional code style checks via .editorconfig and now you can make them work without requiring Visual Studio at all — Getting the .editorconfig working with MSBuild by
@sharpcms
:
Don't build "microliths" - services communicating over synchronous HTTP using CRUD talking to SQL - maintains strong coupling we wanted to move away from, but with higher latency. The evolution of scalable microservices by
@jboner
WCF vs gRPC by
@markrendle
… well not so much a head-to-head as a look at how to transition off of WCF using gRPC, a low-overhead, high-performance, cross-platform RPC framework, which gets first-class support in .NET Core 3.0.
"After playing with .NET 5 libraries and Web API applications inside Lambda containers I wanted to see if I could get a .NET 6 library running too." C# and AWS Lambdas, Part 8 - .NET 6, inside a Container, inside a Lambda by
@bryanjhogan
—
“Want strategies for scaling a monolith application? You have many options if you have a monolith that you need to scale.” Scaling a Monolith with 5 Different Patterns by
@codeopinion
"In my opinion, it’s one of the best visualization tools for performance profiles ever!" - Profiling .NET Code with PerfView and visualizing it with by
@SitnikAdam
—
MongoDB doesn't have built-in support for optimistic concurrency control.
@jbogard
explains how to prevent data loss when dealing with concurrent updates — Document-Level Optimistic Concurrency in MongoDB:
"HttpClient is really easy to use, and because of that, it's also really easy to use it wrong." You're (probably still) using HttpClient wrong... by Josef Ottosson —