Building Bruges

Software development is expensive, software has bugs, fixing bugs is expensive. Is there no way to turn things around? Don’t we have tools available to deliver software with higher quality? Yes we do!

In this session I’ll share my experiences which tools really contribute to deliver quality in software development.

In this presentation I address the following topics from a non-coding point of view.

• Getting things done
• CI/CD
• DevOps culture
• DDD
• Eventstroming
• TDD
• Pair Programming

What are the benefits of applying them in your daily dev routines!

Past weekend we delivered over 1300 meals at our basketball clubs takeaway fundraiser in under 3 hours. The unsung hero of this effort is an order management system that runs equally well online as well as offline. Building such a system proved to be quite a challenge. In this session I want to share some of the architectural, design and implementation lessons that I’ve learned along the way while solving this challenge.

The shift towards an API landscape indicates a significant evolution in the way we build applications. The rise of JavaScript and mobile applications have sparked an explosion of easily-accessible REST APIs. But does the rise of APIs result in the downfall of security? Why are there so many vulnerabilities and incidents involving APIs? How can you ensure that your APIs are secure?

In this session, we use real-world cases to dive into best practices for securing your APIs. We discuss the attack surface of an API, common authorization problems, and best practice techniques to avoid these problems. At the end of this session, you will have an actionable set of guidelines to assess and improve the security of your own APIs.

A true story about how a 90ies email marketing tool was transformed into a modern product organisation. Product, here, deals with what features should be build and how they should work. Not technically, but from a business but mostly a user point of view.
We’ll tell you what we changed, how we handled that and how this affects all people involved. It includes change and heavy moments, but it has a happy ending.

Unfortunately the current covid-19 situation is still precarious.

We had the intention of hosting a workshop in Q3 on which attendees had to pair program but keeping the safety measures in mind this seems infeasible at the moment. This workshop will be postponed to a later date once this pandemic is under control.

Alas this means there will be no event from us in Q3 but we are eagerly looking for alternatives for the next quarter.

Thanks again to Jon Skeet for the interesting talk about versioning. The recording of the webinar can be found here.

Follow us the get more details on the upcoming workshop about legacy code planned in Q3.

Software engineers use versioning all the time, and .NET is no different. Over the last couple of years, I’ve been thinking a lot about versioning in different contexts, and I wish I could now say I knew how to do it easily. Instead, I can at least share my experiences, highlight some problems, and maybe look at possible improvements to come. We’ll look at:

• What is a version anyway?
• Where do we use versions day to day?
• What do we mean by semantic versioning?
• What are the patterns for server-side API versioning?
• What are the highlights and lowlights of .NET’s support for versioning?

About Jon Skeet

Thank you Tom for your session on Multi-tenancy on Azure! For those of you who want to recap, or if you weren’t present, you can find the slides here.

See you next at our next event! Jon Skeet will be giving a remote talk on 27 May. We’ll keep you posted.

Building a multi-tenant PaaS is not a walk in the part, certainly if the platform you are building on is constantly changing.

In this session I’ll walk you through the adventure we’ve been on where you’ll learn about the challenges we’ve had and how we approached them and whether or not our decisions worked out or not.

– How to design for scale
– How to operate the platform
– How to grow a platform mindset and force ownership
– How to provide user-friendly webhooks
– How to roll out changes
– How to design for multi-tenancy
– How to approach constant change
– etc

When we design software for a complex domain, it helps to have a deep understanding of that domain, and reflect it in the system’s model. That’s the central premise of DDD. Many interesting business domains are temporal; they involve many interconnected processes and behaviours happening over time.

This is where traditional ways of understanding our domains fall short: they look at the artifacts of those processes, but not enough at the processes themselves.