The Architecture track at GOTO London 2016 was one of the most popular at the conference! With great speakers presenting topics like continuous architecture and being Agile about the qualities of your software architecture, this session was packed with great talks.
Watch the videos from the Architecture track at GOTO London 2016 below.
with Murat Erder, Director at Deutsche Bank
As the pace of innovation increases, IT departments are tasked to deliver value quickly and inexpensively. Agile, Continuous Delivery and DevOps are focused on addressing this demand. But, what about architecture; is it still relevant? We definitely say YES! We present an approach called Continuous Architecture. It is based on six key principles that provide an architectural focus while supporting Agile, Continuous Delivery and DevOps. The application of these six simple principles and supporting tools, help solve the architectural challenges at the project and enterprise levels, and relate to IT processes including application testing, software deployment, and software architecture.
Software Architecture as Systems Dissolve
with Eoin Woods, CTO at Endava
The way we build systems is changing. From our history of monolithic systems, then distributed systems, to Internet connected systems, we are now entering the era of cloud-hosted, microservice based, pay-for-usage system development. What does the history of software architecture tell us about the challenges of this new environment? And how does our approach to software architecture need to evolve in order to meet them?
Software architecture has been a mainstream discipline since the 1990s and in that time has become a recognised, widely researched and often valued part of the software engineering process. However architecture approaches must reflect the technologies and priorities of the systems we are building and in this regard its future has never looked more uncertain or more exciting. From our history of monolithic compile time architecture, to many tiered distributed systems, to Internet connected services, we are now entering the era of cloud-hosted, microservice-based, pay-for-usage systems development. In this new world the boundaries of “my” system are no longer so clear and our systems are dissolving into complex webs of independently owned and evolved services, with nothing more in common than a shared credit card for billing and an agreement on the format of network requests. What can the history of software architecture tell us about the likely challenges in this environment? And how must it develop in order to meet them?
Visualise, document and explore your software architecture
with Simon Brown, Consultant at Coding the Architecture
We value working software over comprehensive documentation” is what the manifesto for agile software development says, with the typical misinterpretation of these few words being “don’t write documentation”. Of course, that’s not what the manifesto says and “no documentation” certainly wasn’t the intent. It seems that many software teams have lost the ability to communicate what it is they are building and it’s no surprise that these same teams often seem to lack technical leadership, direction and consistency. This session will look at various approaches and tools that you can use to visualise, document and explore your software architecture in order to build a better team.
Whoops! Where did my architecture go?
with Oliver Gierke, Spring Data Project Lead at Pivotal
Maintainable software needs to be modular to allow pieces of it to be evolved independently and at different paces. Accepting that, the question of which means to use to implement and enforce modularity still stays open.
The talk starts by looking into the fundamentals of modularity, introduces means and approaches to connect logical architecture to the codebase and discusses how microservices architecture and modular monoliths constitue different tradeoffs in implementing modularity. Beyond that we discuss patterns and best practices around general code organization, package structures to build a solid foundation for Java applications.
Being Agile About Architecture Qualities
with Rebecca Wirfs-Brock, IEEE Software and The Hillside Group
In a sprint to deliver features, software qualities or “non-functional requirements” such as security, scalability, performance or reliability can be slighted or ignored. Prioritizing and implementing necessary functionality keeps an agile project moving forward. However, if you don’t focus on system quality while incrementally delivering features, system qualities can get shoved aside or wistfully imagined as emerging along with your architecture. This presentation introduces you to techniques for weaving architecture quality-related work into your project rhythms and practices for keeping system quality requirements in mind, measurable, and tangible. You’ll learn about agile landing zones, qualifying product/project roadmaps, agile quality scenarios, incrementally testing for system qualities, and options for making architecture work visible. Yes, you can interject quality specification, design, and testing efforts into your project and be more agile about it.
with Robert Smallshire, Founding Director of Sixty North
Step back from your system and take a look at its architecture. Are the major structures and technology choices the result of conscious decisions, or have they emerged as the system has evolved? Architecture is often an ad hoc, responsive process where designs get stuck in local minima while ever more features are piled into the system. Such systems often fail to live up to the origin vision and expectations of stakeholders.
In this talk we look at how to design systems which are a purely a function of the major forces acting on a solution, rather than being modishly reflective of the prevailing software zeitgeist. We’ll explore the idea that software architecture, and hence software architects, should focus deliberately on the constraints and qualities of system design, and avoid getting too distracted by features.
with George Fairbanks, Software Engineer at Google
Senior software developers can walk up to a whiteboard and give an impromptu talk on how their software works, explaining both the details and the broad strokes. Most importantly, they connect the specifics of this system to general architecture patterns, domain models, design patterns, development patterns, or programming styles. How do we become “senior software developers”, other than waiting until we are older? The answer is models.
This talk covers Model-Minded Development. It briefly shows how we underestimate the cognitive task of programming and how we consequently use models to amplify our own cognitive abilities and to coordinate our ideas with others. Then we’ll dig into source code and compare equivalent programs that do better and worse jobs of expressing models in the code.