ViewModel Composition

  • 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.
  • 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.
  • 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?
  • 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.
  • 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.
  • 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.
  • 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!