Get Mauro speaking at your event.

Here is the list of talks ready to be delivered. Get in touch to arrange details.

All our aggregates are wrong header image

All our aggregates are wrong

It always starts well. At first glance the requirements seem straightforward, and implementation proceeds without hiccups. Then the requirements start to get more complex, and you find yourself in a predicament, introducing technical shortcuts that smell for the sake of delivering the new feature on schedule. In this talk, we'll analyze what appears to be a straightforward e-commerce shopping cart. We'll then go ahead and add a few more use-cases that make it more complex and see how it can negatively impact the overall design. Finally, we'll focus our attention to the business needs of these requirements and see how it can shed light on the correct approach to designing the feature. Walk away with a new understanding on how to take requirements apart to build the right software.

Available in: Italiano | English
Designing a UI for Microservices header image

Designing a UI for Microservices

How do we design a UI when the back-end system consists of dozens (or more) microservices? We have separation and autonomy on the back end, but on the front end this all needs to come back together. How do we stop it from turning into a mess of spaghetti code? How do we prevent simple actions from causing an inefficient torrent of web requests? Join Mauro in building a Composite UI for Microservices from scratch, using .NET Core. Walk away with a clear understanding of what Services UI Composition is and how you can architect front end to be Microservices ready.

Available in: Italiano | English
Living organizations, Particular Software header image

Living organizations, Particular Software

We are so used to organizations based on the traditional org-chart structure that we get for granted that it's the only option. Is a different approach possible? When I first joined Particular Software, it was a traditional, yet distributed, organization. We had directors and a hierarchy. A year later conscious decision to change everything from the ground up was made. It was the best decision ever. Join Mauro on a journey that aims to disclose that another organization model is possible, that top/down decisions making is not the only viable solution, and that we can organize work schedules around our private life to achieve the best possible life-work balance.

Available in: Italiano | English
Long live and prosper header image

Long live and prosper

Microservices all the thing! they say. Nowadays it seems that if architectures are not microservices based they are not worth the name. Is it really true? Do we really need a (micro)services based architecture? We should design our systems with longevity, manutenability, and evolution simplicity in mind. Not hype. Long living systems are our primary goal. We’ll analyze most common errors and we’ll see how architectures can be a game changer in systems design. Join Mauro in a journey that aims to disclose what it means to build a distributed system based on a (micro)services oriented architecture.

Available in: Italiano | English
Product Owner is dead, long live Product Ownership header image

Product Owner is dead, long live Product Ownership

What if products were not managed by manager? Or even, what if there are no managers at all? Who will be responsible to define backlog priorities? In Particular Software there are no managers. Product management belongs to everyone. If this sounds like the inmates have taken over the asylum, you're only partially right. Nowadays more and more companies are transitioning to adaptive organizational structures. What can be done to enable anyone to make decisions at any level? Is there a way to have a shared decision making process? We'll have a look at how Particular Software is structured in order to enable all the above. We'll analyze how problems are handled and which processes and tools we use to make decisions. All this without nurses, ooops, managers.

Available in: Italiano | English
The road to a Service Oriented Architecture is paved with messages header image

The road to a Service Oriented Architecture is paved with messages

One of the options on the table when implementing a Service Oriented Architecture (SOA) is to use messages and a service bus foundations. This talk will drive you through the basic SOA building blocks, introduce message based architectures, and will connect the dots between the technology and the architectural principles through some samples using NServiceBus. Finally analyzing advantages and issues we may face when choosing this option.

Available in: Italiano | English
The agony and the ecstasy of working remotely header image

The agony and the ecstasy of working remotely

Working remotely as a solution architect is amazing and brings a lot of autonomy to my life but the more geographically dispersed my team becomes, the more friction gets added to my daily job. This session discloses how we work internally at Particular Software - how we manage daily tasks, communication, and long term goals in a company whose employees span 17 time zones.

Available in: Italiano | English
Welcome to the (state) machine header image

Welcome to the (state) machine

Stateless all the thing, they say. In the last few years we’ve been brainwashed: design stateless systems, otherwise they cannot scale, they cannot be highly available, and they are hard to maintain and evolve. In a nutshell stateful is bad. However complex software systems need to do collaborative processing, that is stateful by definition. Stateless myth busted! Collaborative domains deal with long business transactions and need to interact with distributed resources. The traditional distributed transactions approach, even if tempting, is a time bomb. This is when Sagas come into play. Sagas allow to model complex collaborative domains without the need for distributed transactions and/or orchestration across multiple resources. Join Mauro on a journey that aims to disclose what sagas are, how they can be used to model a complex collaborative domain, and what role they play when it comes to designing systems with failure and eventual consistency in mind. (It’s all right, I know we’re you’ve been)

Available in: Italiano | English