Tag: soa

  • Compensation is all around us (28 November 2023)
    In a message-based system, we might feel a lack of control, especially when in need of compensating changes spread across the system. Fear not! Real life deals with compensation every day! And it's better than rolling back a transaction or deleting some data in the database.
  • The power of timeouts to compensate for failures and other tales (18 October 2023)
    There are scenarios when a chatty services relationship seems the only option, with the results of coupling quickly becoming our best friend. Not all hope is lost, we can try to ask different questions to untangle the knot.
  • What if my command was rejected? (27 June 2023)
    Distributed systems are different and require a different mindset. That's particularly true when dealing with async processes and failures. We need new tools and a new toolbox. And in the end, we can avoid rejecting that command.
  • Back to Basics: service boundaries, autonomous components, and coupling (17 May 2023)
    When you're involved with something for a very long time, it's easy to fall into the trap of taking many concepts for granted. Let's go back to the basics and build a common foundation. Today's topics are service boundaries, autonomous components, and coupling.
  • How many (micro)services do I need? (15 March 2023)
    Microservices, microservices everywhere. But how many of them do we need? It's easy to be trapped by the micro thing and end up with thousands of them. Let's try to provide some guidance.
  • The pitfalls of request/response over messaging (19 January 2023)
    Request/response is everywhere. It serves us very well and is a neat solution in many scenarios. It comes with a few pitfalls in distributed systems and needs to be handled with care.
  • What is the deal with security and distributed systems? (1 November 2022)
    Security is a crucial topic for any architect. We cannot implement it as a second thought. We must consider its implications from day one. Distributed systems are no different. However, it might be a little more involved.
  • Autonomy probably doesn't mean what you think it means (5 September 2022)
    There seems to be some misunderstanding around the word 'autonomous' when used in the context of distributed systems. Unfortunately, there is no unique meaning, it depends on the context and the observer's point of view. It might not mean what you think.
  • Where we're going, we don't need service discovery (12 March 2022)
    Too many times technology is used to solve problems that, to begin with, should not be considered problems. Service discovery, on many occasions, is a solution in search of a problem.
  • AsyncAPI, a specification for defining asynchronous APIs (23 February 2022)
    Distributed systems governance is a hot topic. At first, it might feel overwhelming. It's important to understand what we need to govern and which tools can help.
  • Let's get logical! On logical and physical architectural views (25 January 2022)
    Having a deep understanding of the differences between physical and logical boundaries can help shed light on the way we architect systems. Usually, it leads to simpler solutions.
  • Is it complex? Break it down! (3 January 2022)
    Sometimes, we choose technology based on the perceived complexity or heaviness. We focus our decisions on the technical solutions and rather than looking deeper at the problems, we stick with what we know. Are we making the right choices?
  • You don't need that abstraction (20 December 2021)
    Abstractions, abstractions everywhere! We're obsessed with clean design and architecture. Do we need that, or does the introduced cognitive load come with more issues than benefits?
  • On working with a ViewModel Composition based system (23 November 2021)
    What is it like to work with a ViewModel Composition-based system? And is it always the right choice? So far, we have touched on the architectural part. It's time to answer those fundamental questions.
  • Isn't A supposed to come before B? On message ordering in distributed systems. (20 October 2021)
    We are used to lists, sequences, and procedural approaches. We are constantly under the impression that what we do is ordered. That's not the case. Why are we trying to replicate into software architectures a non-existent ordering?
  • Update me, please (3 August 2021)
    We're so used to notifications that we probably never stopped to think about how to implement them. It might be trivial at first glance. However, in a distributed system, we might face more challenges requiring techniques we don't expect when implementing a notifications infrastructure.
  • Don't keep a saga in both camps (28 July 2021)
    When it comes to distributed systems, autonomy is a guiding star, and coupling is the villain trying to sneak in at every step. Orchestration is a particularly subtle form of coupling, usually detected when it's too late. However, the root cause is somewhere else.
  • Own the cache! (15 July 2021)
    Caches are everywhere and power the internet. When it comes to distributed systems, they are an essential tool in our tool belt. However, special care needs to be put into defining who owns the cache.
  • There is no such thing as orchestration (8 July 2021)
    Coupling is subtle and sneaks in from every hole. With long-running business processes, the overall business problem tends to take precedence over what seems to be a minor concern. Unfortunately, those choices might turn against us in the long run.
  • You want to compose emails, right? (2 July 2021)
    Composing emails comes with the same issues as composing ViewModels. Data constantly leaves the system for an email, a user interface, or a report, ViewModel Composition techniques help define robust solutions.
  • Can we predict the future? (2 June 2021)
    Eventual consistency is everywhere and distributed systems tend to expose consistency issues. Most of the time that's not a problem, except when it comes to the UI. What options do we have?
  • Tales of a reservation (5 May 2021)
    Are you relying on invariants and assuming trust in business rules? Distributed software systems disrupt most of our beliefs. They require a deep understanding of the business and a shift in the way we think. Let's see how the business affects the system design and what new opportunities come to life.
  • On ViewModel Composition and UI Composition (20 April 2021)
    We often confuse UI and ViewModel Composition. They are not the same thing and they solve different problems. We can use them in isolation but in most cases, they give their best when used in conjunction.
  • Please welcome Model Binding and Formatters to ServiceComposer (14 April 2021)
    Model binding frees the code from dealing with incoming payload content type and deserialization issues. It's a great way to move the attention from infrastructure code to business code. Model binding is now available in ServiceComposer.
  • NServiceBus.IntegrationTesting baby steps (7 April 2021)
    NServiceBus.IntegrationTesting started as an exploration activity and recently turned into a stable v1 release. V1 comes with some new features and one limitation that led to brainstorming options for the future.
  • A thorough UX analysis is part of the solution (2 April 2021)
    Decomposing a monolith is a satisfying exercise. In many cases, the decomposition process leads to a task-based user interface with its set of issues. We should not try to address those using either technology or architecture. A UX analysis is the way.
  • To API, or not to API. Is this a real problem? (24 March 2021)
    Breaking a public API is scary but sometimes unavoidable. Versioning an API is complex and error-prone. In many cases, I observed teams breaking an API that should not have been there to begin with, or fighting with versioning issues. The problem, though, was not the API.
  • Not all changes are born equal (10 March 2021)
    We should not fear change. There are changes for good and changes for bad. As for change, we should not fear coupling. There is bad coupling and good coupling. The critical aspect is to understand the impact of the changes and the coupling.
  • Please welcome Attribute Routing to ServiceComposer (11 February 2021)
    Attribute routing is a great MVC feature. However, endpoint routing is the game-changer. Library authors can plug in custom route handling and benefit from all the attribute routing goodies. It's easier than ever.
  • Do not trust the user mental model: Model behaviors, not data (2 February 2021)
    When designing systems, we say how important it is to model the system following the user mental model. Nonetheless, it works. However, it's not necessarily always the right choice.
  • Transactions? None for me, thanks (30 January 2021)
    Queues are designed for reliability. I personally stress a lot about designing message processing to be as transactional as possible. Is there a use case for unreliable message processing?
  • Ooops, can I try again, please? (21 January 2021)
    When systems fail, we can retry the whole process and be successful. However, there are scenarios in which retrying a subset of the process might be a better choice. Not all failures are born equal.
  • Ehi! What's up? Feedback to users' requests in distributed systems (12 January 2021)
    The system's design proceeds at full speed; all of a sudden, a thunderbolt hits us: how do we go about providing feedback to users? Request handling is asynchronous, and thus results are eventually consistent. What technique can we use to preserve the user context to get back to them with results?
  • OK Mauro, but I want to do paging AND sorting (6 March 2020)
    Paging and sorting can be applied in isolation, even in distributed systems. When in need of paging AND sorting, the level of coordination required grows exponentially. It turns out that the problem is not that different from searching in distributed systems, and similar techniques can be used to address the paging and sorting dilemma.
  • Paging and sorting in distributed systems, oh my! (27 January 2020)
    Paging and sorting sound like a controversial and complex topic when it comes to displaying data; however, they don't need to be, even in distributed systems.
  • The Price of Freedom (13 June 2019)
    When designing UIs for a distributed system we're faced with many choices. It's hard to districate ourselves into the options jungle. We might be tempted to select what at a first look seems to be most flexible solution, as flexibility pretend to imply freedom. It's tremendously easy to transition from freedom to anarchy.
  • Search is a Team Effort (22 May 2019)
    Designing search functionality for a distributed system is challenging. There is the coupling threat on the one hand, and on the other we cannot sacrifice efficiency. There are a lot of similarities to what happens during a race car pit stop.
  • The Quest for better Search (15 May 2019)
    There is search and then there is search. And despite having the same name their meaning, and thus their technical implications, is shaped by the business we are in. Let's have a look at what search in a distributed system is and what problems brings to the table.
  • You don't have to be cool to rule my world, KISS. (8 May 2019)
    HTTP is the Microservices way, so it must be used as a communication transport, they say. Is HTTP adding any benefit to our systems? Can it be considered harmful in some scenarios? Are there better approaches? Shedding some light on the system logical architecture might be helpful.
  • Safety first! (2 May 2019)
    In a distributed system, communication reliability is a key aspect. Orchestrating multiple HTTP calls is generally a bad idea; it's very hard, if not impossible, to be reliable. This is when messaging and patterns like the Outbox come into play.
  • The fine art of dismantling (18 April 2019)
    What happens when there is the need to write data in a distributed system? What if this data needs to go to different services? How do services participate in this process like they do for the Composition part? This is when ViewModel Decomposition comes into play. Let's have a look at what it is and especially when it's really needed.
  • Slice it! (9 April 2019)
    We desperately strive to achieve autonomy at the back-end, but not so much when it comes to front-ends. Using ViewModel Composition techniques we can achieve autonomy at the front-end as well. There should not be any such thing as orchestration though.
  • Turn on the motors (3 April 2019)
    It's time to discover all the nitty gritty details of the Composition Gateway. It's going to be a roller-coaster ride from ASP.Net Core Routing to the composition engine and back. Fasten your seat belt and enjoy the ride!
  • Read models: a knot to untie (26 March 2019)
    Read models can be a tempting solution when it comes to presenting data in a distributed system. Before going down this route it's important to disclose the very nature of the choice we're going to make. It's a knot to untie.
  • The ViewModels Lists Composition Dance (21 March 2019)
    Composing a list in an efficient way is complex. Multiple components need to interact with each other to produce the final result. It's not that different from a chorus, where each dancer performs the studied choreography so that the end result is an amazing ballet.
  • There is no such thing as cross-service ViewModel Composition (13 March 2019)
    At a first look it might sound reasonable to use ViewModel Composition to allow services to talk to each other. Why not allowing services to share complex data structure composed at runtime? Let me put it simple: you don't want a distributed monolith!
  • ViewModel Composition: show me the code! (6 March 2019)
    Time was spent discussing ViewModel Composition concepts and their design. It's time for some code. Let's see Single Item Composition in action: how does the code look like?
  • Into the darkness of ViewModels Lists Composition (28 February 2019)
    ViewModels Lists composition has an interesting challenge: must be designed in such a way that it doesn't flood servers with tons of requests. Number of requests cannot exceed the number of services involved in the composition process, no matter how many items are composed. There is a light at the end of the tunnel (cit.)
  • The Services ViewModel Composition maze (20 February 2019)
    ViewModel Composition can be scary, at a first look. The real world, we deal with every day, is complex as the information we manage are complex. Do we need to manually craft dedicated solutions or can we extract reusable patterns? There is always an exit to the maze.
  • What is Services ViewModel Composition, again? (6 February 2019)
    Building distributed systems requires facing an interesting challenge: there is a dichotomy between the way behaviors and data are decomposed at the backend and the way users expect to consume them from the frontend. Services ViewModel Composition techniques are designed to help us overcoming this dichotomy.
  • Services UI Composition @ ApiConf 2018 in Turin (30 May 2018)

    Once again I’ll have the pleasure of presenting at a conference organized by Cloud Conf folks.

    This time the topic is one of my favorite: Services UI Composition!

    The talk will cover how to build a UI for a system built using a microservices architecture. The talk will be in Italian and details are available on the event page.

    If you happen to be in Turin, that by the way is a wonderful city, take a chance to attend this very well organized conference. And come and say hi!