Get updates

Follow us

Contacts

Software Architecture Improvements

What's more important than an elegant architecture? Finding a way to keep it that way over the lifetime of the application. How can an application evolve while still keeping the architecture's gestalt in the face of team changes, changed requirements, scalability challenges and other problems? In this track we'll look at tools to keep an eye on code and design quality, ways to see and fight architecture erosion and much more.

Day of week:

Thursday

Location:

Grand Ballroom - Salon F

Host:

Greg Young

Presentations

Conway's Law states that systems mirror the communication structure of the organizations that design them. When developers first hear of Conway's Law they often think of it as a superficial observation, but the point of view that the law implies is profound and it contains seeds for the solution of many common problems in software development including feature selection and the accumulation of technical debt. In this talk, Michael Feathers will describe how talent allocation, process, and structure deeply affect code - and how the these insights lead to counter-intuitive new practices if we take them seriously.

Idealized architecture bores me or occasionally frightens me. When it isn’t leading us in disastrous crusades, it is irrelevant. We have legacy systems that aren’t going away. We have some talented teams and some who are less so. We make mistakes as we go along. A practical architecture isn’t just a destination; it should give you a path from where you are now to someplace better. It should accommodate quality tradeoffs and design triage. I’ll share a few approaches that have helped me with these issues, with a focus on establishing boundaries between software with different conceptual approaches and discipline levels.

Presentations

Let's face it, good programming is hard, let alone safe concurrent programming. Even with an in-depth understanding of Java concurrency there are still many pitfalls and traps to avoid. You have atomicity, ordering, race-conditions, deadlocks, shared mutable state, and many other monsters are waiting to derail your shiny new application. What if there was a better way? Well, there it is. You can build asynchronous, non-blocking, resilient applications in an isolated manner that is not difficult to reason about. No longer, do you get to worry about threading issues. You can concentrate on what you're paid to do, solve the business domain concerns. In this session, we will review the challenges of concurrent programming on the JVM and explore Akka a powerful toolkit and runtime for building highly concurrent, distributed applications on the JVM.

I will present methods for implementing event-driven services with F# and EventStore that we've been using to build an ecommerce platform at Jet.com. The two key ingredients are functional programming and event-sourcing. Functional programming with F# enables service logic which is correct, understandable, testable and elegant. Event-sourcing with EventStore provides a solution for both persistence and integration which exhibits desirable service characteristics such as autonomy, loose coupling, and compositionality.