• Batch Dispatch #1

    Welcome back. Over the last few months, the Particular Slack channels have been awash with interesting links, thoughts, and blog posts. Here are the ones that bubbled to the surface.

    Read more →
  • How to build a Babel fish in NServiceBus

    I'll admit it: I'm a huge fan of The Hitchhiker's Guide to the Galaxy. I've voted for Zaphod Beeblebrox in more than one election and had a cat in college named The Ravenous Bugblatter Beast (Rav, for short). True to her name, she was an adept and ruthless hunter of cockroaches.

    Read more →
  • The new and improved NServiceBus testing framework

    Tests are the life blood of many large codebases. They protect you from introducing bugs and in some cases, are instrumental in your code's design. Because of this, maintaining those tests is every bit as crucial as the underlying code that it tests. Like the rest of the project, your tests should be clear, concise, and consistent with your code style. Otherwise, tests might fall into disrepair and end up in a large bucket called technical debt, never to be heard from again.

    Read more →
  • RabbitMQ updates in NServiceBus 6

    The new RabbitMQ transport for NServiceBus 6 has one overriding theme: speed. Although we've added a few other features as well, the biggest news is how much faster we've made the new version of the RabbitMQ transport. We've redesigned the message pump to be more efficient, so it can handle more incoming messages. Outgoing messages are sent faster. We've even contributed changes to the official RabbitMQ Client project to increase its performance. Almost everything we've done was focused on making your systems faster and more efficient.

    Read more →
  • Batch Dispatch #0

    Happy holidays to all of you readers out there! Lately, several of our staff members have been active in the community, sharing valuable insights into building distributed systems. We thought we'd take this opportunity to share some of those resources, as well as other fun stuff, with you. With a bit of async/await, Azure Service Bus, AngularJS, code-driven visualizations, and even a throwback to the Commodore 64, there's something in here for everyone. We hope you enjoy!

    Read more →
  • NServiceBus on .NET Core - Why not?

    .NET Core is out. Officially. After a lot of waiting, it's finally a real, finished, RTM thing, and as developers who are passionate about the .NET ecosystem, we're very excited about it. How cool is it to know that we can write code in C# (or VB.NET, or F#, etc.) and have it run on Windows, Linux, and even macOS? So why on earth doesn't NServiceBus support .NET Core yet? Well, good question.

    Read more →
  • Async/await tips and tricks

    Many .NET developers have been busy upgrading their code to take advantage of the async and await keywords. These keywords make asynchronous programming a lot easier by allowing us to represent a call to an asynchronous method almost as if it were a synchronous one. We just add the await keyword, and the compiler does the hard work of dividing the method into sections and keeping track of where to resume execution once async work completes. However, it's difficult to hide all the complexity of asynchronous programming behind a couple keywords, and there are a host of pitfalls and gotchas that you should be aware of. Without proper tooling, it's all too easy for any one of them to sneak up and bite you.

    Read more →
  • Upgrading NServiceBus handlers to async/await

    In order to support the async/await keywords in NServiceBus 6.0, we had to make the first ever breaking change to the message handler API. We realize that this is a big change, and it's not one that we made lightly. The move to async/await required that the Handle method signature return a Task instead of void. At the same time, we replaced IBus with context-specific parameters to make it clearer which messaging operations are available from within a message handler. In order to make the conversion process as easy as possible, we've prepared a screencast that demonstrates how to convert a message handler from the previous syntax to the async-enabled API in NServiceBus 6.0.

    Read more →
  • A new era for MSMQ scale-out

    Scaling out a web server is easy. All you have to do is stand up a bunch of web servers behind a load balancer like HAProxy and you're covered. Unfortunately, it hasn't been quite as easy to scale out MSMQ-based NServiceBus systems. That is, until now.

    Read more →
  • A promise is only as good as the code that makes it

    When I make a promise to someone, I do my best to keep it. If I'm pretty sure I won't be able to do something, I don't make any promises about it. Instead, I say I'll try to address it eventually. It's all about managing expectations. In some ways, a promise is like a software interface — a kind of contract between the other person and me. With asynchronous computations, we make promises in software too. They are similar to the promises you and I make, representing operations that haven't happened yet but are expected to happen in the future. In JavaScript, for example, there is an explicit Promise construct. In .NET, this is done with the System.Threading.Task class. Unfortunately, not everyone takes promises seriously — both in real life and in software.

    Read more →
  • MSMQ performance improvements in NServiceBus 6.0

    MSMQ was the very first NServiceBus message transport, and while not overly flashy, it got the job done. You could almost call MSMQ a finished product because, while it's updated with each Windows release, it doesn't really change much. It's solid, reliable, dependable, and overall, it Just Works™. One of the biggest changes we made in version 6.0 of NServiceBus (V6) is that the framework is now fully async. The thing is, the MSMQ's API in the .NET Framework hasn't been updated to support async/await, so what could we do for the MSMQ transport in NServiceBus? Make it go faster anyway. That's what.

    Read more →
  • NService... umm, where's the bus?

    With the upcoming version 6 of NServiceBus, we bid the IBus interface farewell and in its place, welcome a new wave of context-specific interfaces that are more intuitive and easier to test.

    Read more →
  • NServiceBus Sagas, Simplified

    In the 1960s, Shigeo Shingo, a Japanese manufacturing consultant from Saga City, Japan, pioneered the concept of *poka-yoke*, a Japanese term that means "mistake-proofing." In a nutshell, *poka-yoke* involves saving time and cutting waste by reducing the possibility of defects. Although some number of mistakes will always occur, processes can be put in place to catch those mistakes before they turn into actual customer-facing defects. This is a model we've been trying to follow with NServiceBus -- not only with regards to our internal development processes, but also in our efforts to guide developers toward building message-driven systems. Through countless API design decisions over the years, we've been making it ever easier to use NServiceBus the right way and ever more difficult to use it wrongly. This way, developers naturally fall in to a pit of success.

    Read more →
  • Latency is zero

    Upon the return from my visit with the newly-discovered Ossian society, it happened that my ship capsized and I was marooned for a time on a tiny deserted island somewhere in the Caribbean Sea. One might think that the biggest problem with being marooned would be finding food for survival, but that was not the case on this island. Coconut and pineapple trees grew all over, and as luck would have it, I stumbled across a hidden cache of rations likely left behind by Spanish explorers or pirates. Among the supplies were dried and preserved meats and a collection of rum in glass bottles. The biggest problem when stranded, after finding food and shelter, is keeping one's own mind occupied. One day, I took a discarded rum bottle, inserted a note, and threw it into the sea.

    Read more →
  • What does your particular system look like?

    Have you ever been pulled in to a software project and had to figure out how everything works? Often, your options are limited to either sifting through piles of documentation or diving into thousands of lines of code. Unfortunately, the documentation probably became obsolete as the software grew and evolved and, while the code is accurate by definition, it requires a lot of concentration to trace through and figure out how everything fits together. …

    Read more →
  • The network is reliable

    In the spring of that year, my travels brought me upon a previously undiscovered civilization. The people called themselves Ossians, and they lived in an isolated collection of villages in a remote part of South America. Being remote as they were, their level of technology was understandably primitive. But I was surprised by the locals' recent obsession with new forms of communication. It all started, they told me, when one of them discovered that by attaching a rope between two clay pots and stretching the rope taut, a voice uttered into one side could be heard on the other. (I neglected to tell them that even as a boy I had done this very thing with tin cans.)

    Read more →
  • NServiceBus 6.0 Public Beta

    We've been hard at work on the next major version of NServiceBus for a long time, and we're really excited to show it to you for the first time today! With major improvements in performance, top-to-bottom async support, and an even cleaner API, this version takes NServiceBus to a whole new level. And as of today, NServiceBus 6.0 is now available for public beta.

    Read more →
  • What Starbucks can teach us about software scalability

    In 2004, Gregor Hohpe published his brilliant post "Starbucks Does Not Use Two-Phase Commit." When I read it, my time working at Starbucks during my college years suddenly became relevant. Over the years, I gradually realized there's even more that programmers can learn from the popular coffee chain. Although many people may want to build scalable software, it can be much harder than it first appears. As we work on individual tasks, we can fall into a trap, believing all things are equally important, need the same resources, and happen synchronously in a predefined order. It turns out they don't—at least not in scalable systems, and certainly not at Starbucks.

    Read more →
  • NSBCon 2015: Platform-Oriented Architecture

    In the second keynote of NSBCon 2015, Ted Neward introduces the concept of Platform-Oriented Architecture (POA) as the logical successor to the currently used SOA/REST architectural approaches. POA is a developer-focused approach that has an established communication backplane, an entity definition, a built in agent model and a set of expectations around various execution topics. Ted also talks about the relationship between POA and operating systems, programming languages, and database engines.

    Read more →
  • NSBCon 2015: Top Mistakes Using NServiceBus

    One of the great things about NServiceBus is that it is so flexible. But with that flexibility comes the opportunity to do inadvisable things. What kind of things, you ask? At NSBCon 2015, Kijana Woodard shares the top mistakes (14 in all) that, in his opinion, developers routinely make when using NServiceBus. From row-based database operations instead of set-based ones to using callbacks as a permanent solution, Kijana covers a myriad of different issues that are inadvertently, or possibly intentionally, introduced to many NServiceBus projects. Watch Kijana's NSBCon 2015 presentation and learn how to avoid the pitfalls that many developers make.

    Read more →
  • NSBCon 2015: Behind the Scenes at Particular Software

    Have you ever wondered how Particular Software makes NServiceBus? At NSBCon 2015, David Boike outlines the systems, tools, and methods used in Particular to manage a large number of Github repositories, along with the techniques that make sure all of their releases follow semantic versioning.

    Read more →
  • NSBCon 2015: Full-Stack, Message-Oriented Programming with Akka.NET Actors

    The Moore's Law party is over. We cannot make processors more powerful by making them faster. We have no choice but to embrace multiple processors, multi-core processors, and multiple threads in our code. But how do you do this? In his session at NSBCon 2015, Andrew Skotzko introduces us to message-based programming with the actor model and Akka.NET. Andrew shows how immutable messages, combined with the actor behaving as a unit of concurrency, make taking advantage of all those processors and cores much easier.

    Read more →
  • NSBCon 2015: RavenHQ in the Cloud

    Not all NServiceBus implementations are on-premises. More and more people are releasing applications into the cloud. Jonathan Matheus speaks at NSBCon 2015 about the challenges and rewards of working in the cloud. As the official cloud hosting provider for RavenDB, RavenHQ uses NServiceBus to handle database provisioning and usage-based billing.

    Read more →
  • NSBCon 2015: Opening Keynote

    Udi Dahan opens NSBCon 2015 by summarizing the current state of the NServiceBus ecosystem. He outlines the foundation of our practices over the last year by comparing Particular Software to a duck on water: it looks calm on the surface, but below the waterline, it's paddling like hell. This ethos of continually working to stay ahead of the issues that NServiceBus users encounter sets the stage for a discussion on the current and future state of the platform. Udi explains the [retirement of ServiceMatrix](http://particular.net/blog/beyond-servicematrix), new features in ServiceInsight, and the future of NServiceBus with the coming release of v6.

    Read more →