Why Join Us About the Event

GSAS (Global Software Architecture Summit) is a 2-days summit which aims to attract and connect software architecture experts from all over the world as well as all those interested in building working software to improve their skills, share knowledge, and connect.

Buy Ticket

Practical Talks and Hands-on workshops

Our speakers are experts in essential practices, innovation, working software and practical solutions. Draw your inspiration and learn to become a better software architect.

01

Software Architecture-focused

Robust and scalable software is in the center of every discussion and talk, which makes it a perfect place for people who fight for quality in the software development world.

02

Networking

Over 350 software architects will come together for two days to promote quality in the world of software. Don't miss the opportunity to connect with the community.

03

Have Fun

In addition to technical talks and hands-on workshops, it will be fun! There will be snacks and beers, opportunity to meet like-minded people and generate discussions.

04

+20

Our Expert Speakers

+15

Countries Present

+16

Talks & Workshops

+350

Event Participants

Listen to the Event Speakers

Neal Ford

Author of the book "Building Evolutionary Architectures: Support Constant Change"

Carola Lilienthal

Author of the book "Sustainable Software Architecture"

Mark Richards

Co-author of the book "Fundamentals of Software Architecture: An Engineering Approach"

Nathaniel Schutta

Author of the book "Thinking Architecturally"

Rebecca Wirfs-Brock

Inventor of Responsibility-Driven Design

Ken Power

Winner of the IEEE Software Best Paper Award

Mathias Verraes

Founder of Domain-Driven Design Belgium

Allen Holub

Author of the book "Holub on Patterns: Learning Design Patterns by Looking at Code"

Mike Amundsen

Co-author of the book "Microservice Architecture"

Luca Mezzalira

Author of the Book "Front-End Reactive Architectures"

Clare Sudbery

Lead consultant developer with Made Tech

Indu Alagarsamy

Distributed Systems Design Engineer

Eoin Woods

Co-author of the book "Software Systems Architecture"

Rene Weiß

Software Architect, Consultant & Coach at embarc

Marit Van Dijk

Software Engineer at bol.com

Vladik Khononov

Co-organizer of the "DDD Israel" and "Tel Aviv Software Architecture" groups

Emily Bache

Author of the book "The Coding Dojo Handbook"

Ben Evans

JVM Technologies Architect at New Relic

Sonya Natanzon

Solutions Architect at Guardant Health

Alexander von Zitzewitz

Co-founder of hello2morrow

João Rosa

Strategic Software Delivery Consultant at Xebia

Grow the Community Become a better software architect

To grow the software architecture community, focusing on essential practices, innovation, working software and practical solutions for current issues.

Schedule Details Event Schedules

08.30 - 09.00

Registration & Coffee

09:00 - 09:15

GSAS 2020 Opening Ceremony

09.15 - 09.20

Inspirational talk by Gold Sponsor

09.20 - 10.10

Where Do Ideas Come From? by Neal Ford

Where do ideas for new talks, books, videos, software...ultimately, everything...come from? A common question at conference panels to the speakers is "Where do you get your ideas for talks?" This session answers that question, along with how some of us cultivate new ideas. This talk investigates three aspects of ideation: How do new ideas arise? I cover various ways of synthesizing new ideas: switching axiom(s), mutation, oblique strategies, and a host of other techniques to generate a germ of a new idea. How do ideas grow into intellectual property? I cover techniques for iterating on ideas to discover deeper meanings and connections. I also cover how techniques to evolve and grow ideas.How do you communicate new IP?I cover various ways to convey IP: presentations, articles, books, videos, and a host of other media. I talk about how writing and presenting techniques to amplify your new idea and get it out into the world. One key to building new IP is separating ideation, organization, and realization, which often become jumbled. By separating them, we can build practices to allow each to flourish. This talk provide concrete advice in each area to help realize new ideas. Creativity is the reason we have all the Cool Stuff we have. This session investigates how to fan the spark of an idea into a roaring flame of intellectual erudition.

10.10 - 11.00

Resilience Design Patterns by Indu Alagarsamy

How does your system react when a key resource fails? Say, the database becomes unavailable, or the message broker fails. What if you get a current surge of load, that you have to keep up? What if a badly worded error message results in a billion dollar fire? Real life engineering disciplines can teach us a thing or two on designing for resilience. Learn the techniques and patterns that you can borrow from other areas of engineering, and apply them in your systems.

11:00 - 11:30

Coffee Break

11.30 - 12.20

Fitness function patterns supporting evolutionary architectures by Rene Weiß

Modern software is developed iteratively, enhanced actively and released often to production. By following the ideas of evolutionary architectures one can evolve architectures incrementally and support a modern software lifecycle without the need of big bang changes. Fitness Functions provide guidance by giving objective measures of "how good" the last incremental architecture modification was. In this talk I want to show patterns for Fitness Functions in order to give you ideas to create useful architectural tests for your systems. I will show categories for fitness functions in order to establish proven patterns which are useful in different scenarios. Last but not least I will show how to incorporate Fitness Function development into your daily iterative/agile development lifecycle. This talk is for software developers and architects who want to gain practical ideas on patterns to create fitness functions and how to use them in their agile software development lifecycle.

12.20 - 13.10

Software Metrics for Architects by Alexander von Zitzewitz

Software metrics can be used effectively to judge the maintainability and architectural quality of a code base. Even more importantly, they can be used as canaries in a coal mine to warn early about dangerous accumulations of architectural and technical debt. Alexander von Zitzewitz introduces some key metrics that every architect should know (e.g., average component dependency, propagation cost, structural debt index, and more). Then he talks about the journey to create a metric to measure maintainability and introduces a new metric maintainability level. This metric is promising because its value usually matches quite well the gut feeling of developers about the maintainability of their software systems. Therefore, it can be used to monitor code maintainability and as an early warning indicator if things move in the wrong direction.

13.10 - 14.10

Lunch Break

14.10 - 18.40 Parallel Workshop

Architecture Styles and Patterns by Mark Richards

Whether starting a new greenfield application or analyzing an existing application architecture, one of the decisions an architect must make is which architecture style to use (or to refactor to). Microservices? Service-Based? Microkernel? Pipeline? Layered? Space-Based? Event-Driven? SOA?. Having the right architecture style in place is essential to the success of any application, big or small. In this fast-paced workshop I dive into the details of 5 major architecture styles - microkernel, microservices, service-based, event-based, and space-based. Then, through hands-on exercises with individual teams, you will determine the appropriate architecture style for several actual case studies.

14.10 - 18.40 Parallel Workshop

Architecting Cloud Native Applications by Nathaniel Schutta

By now your organization has planted a flag in “the Cloud” and it is up to you to figure out just what that means to your application portfolio. Should everything be a microservice? Wait, what *is* a microservices anyway? How do you deal with massively distributed applications? How can event storming fix the gap between your business problems and domain model? In this workshop, you will take a kata from quality attributes through to an initial design stopping along the way to discuss: Cloud native culture, Domain driven design, The importance of paved roads, Chaos engineering & Production Hardened Services.

14.10 - 18.40 Parallel Workshop

Understanding and applying different decision models for evolving software architectures by Rebecca Wirfs-Brock & Ken Power

Agility implies responding to change appropriately. Every response is a decision. Sometimes we choose among several competing options, sometimes not. Some decisions demand immediate action, others require us to step back and think and weigh our options. There are many decision models that can support how we respond. Often, our decisions are part of a series of inter-related decisions that influence each other. From this perspective, the agility of an architecture can be viewed as an outcome of decisions made over time. In this workshop session, participants will learn and apply three specific decision styles and models that are useful in different circumstances. Some of the models we use in this workshop come from the field of Naturalistic Decision Making (NDM), which has the goal of studying how people actually make decisions in a variety of real-world settings. Settings in which NDM is appropriate are characterized by time pressure, high stakes, experienced decision makers, inadequate information, ill-defined goals, poorly defined procedures, context, dynamic conditions, and team coordination. In this session we explore NDM in the context of architecture agility and evolution.

14.10 - 18.40 Parallel Workshop

Improving legacy code with DDD by Carola Lilienthal

Domain-Driven Design are recommended to develop new software systems. But they are also very useful to put legacy systems back on the path of virtue. To ensure that the use of these techniques does not end as an aggravation, legacy systems must be broken down into well-cut bounded contexts to form self-contained microservices. DDD's building blocks must be introduced into the legacy systems in meaningful step. You will see how the concepts and solutions of DDD can be applied meaningfully in an ongoing project and during maintenance.

08.30 - 09.00

Registration & Coffee

09:00 - 09:15

Opening

09.15 - 09.20

Inspirational talk

09.20 - 10.10

Secure by Design - the Architect’s Guide to Security Design Principles by Eoin Woods

Security is an ever more important topic for system designers. As our world becomes digital, today’s safely-hidden back office system is tomorrow’s public API, open to anyone on the Internet with a hacking tool and time on their hands. So the days of hoping that security is someone else’s problem are over. The security community has developed a well understood set of principles used to build systems that are secure (or at least securable) by design, but this topic often isn’t included in the training of software developers, assuming that it’s only relevant to security specialists. Then when principles are explained, they are often shrouded in the jargon of the security engineering community and so mainstream developers struggle to understand and apply them. In this talk, we will introduce a set of ten key, proven, principles for designing secure systems, distilled from the wisdom of the security engineering community. We’ll explain each principle the context of mainstream system design, rather than in the specialised language of security engineering, explaining how it is applied in practice to improve security.

10.10 - 11.00

Demystifying Micro-Frontends by Luca Mezzalira

Luca Mezzalira introduces micro-frontends and principles. You’ll cover key topics on how to structure a micro-frontends architecture like identifying micro-frontends inside a project, routing and communication between micro-frontends, UX consistency, performance optimizations, and build and deployment. He busts some myths about the concerns raised by the community around micro-frontends by providing concrete examples applied in the past three years while delivering a streaming video platform across multiple devices with hundreds of developers distributed across Europe.

11:00 - 11:30

Coffee Break

11.30 - 12.20

Evolving EventSourced Systems by Mathias Verraes

EventSourcing is a domain modelling and persistence style, where domain events are first class concepts in the model and the database. Storing a history of all events as a Single Source of Truth comes with challenges for sure. But it can be worth it: an event store is business asset, which enables better auditing, compliance, complex business processes, bitemporality… EventSourcing however has the reputation of being hard to evolve after a feature has gone into production. I believe EventSourced systems are in fact easier and safer to evolve than migrating classical OOP/RDMBS-based systems. But the existing EventSourcing tooling is constraining, many designs are stuck in the old mindset, and we lack the patterns for expressing evolution. Just like EventSourcing makes changes first class, the changes to the model themselves need to become first class as well. I will discuss some approaches, in part based on my experience consulting for such systems, in part speculation on the future of evolving EventSourced design.

12.20 - 13.10

Q&A with Software Architecture Experts by Vladik Khononov, Marit van Dijk, João Rosa, Ben Evans, Sonya Natanzon

We will have leading software architecture experts from different industries and countries. And we will use online tool to ask questions that were not covered during the summit in real time.

13.10 - 14.10

Lunch Break

14.10 - 18.40 Parallel Workshop

DbC (Design by Coding): Applying TDD principles to architecture by Allen Holub

Design by Coding (DbC) is a way to develop an architecture incrementally as you code. It builds on Test- and Behavior-Driven-Development techniques, and provides a way to go from user stories to an effective API or declarative interface, using actual code as your design canvas. You effectively design and code simultaneously. The process is an ideal way to build a coherent agile system incrementally, working directly from the stories and without a formal up-front design process, and it addresses a common failing of standard TDD: losing track of the big picture when you focus on incremental improvements. The result is a system that's can handle volatility with ease. The technique is also perfectly suited for building effective and minimal microservice APIs. This is a hands-on workshop. You'll come away understanding how to use the technique in your own work.

14.10 - 18.40 Parallel Workshop

Designing a Continuous Delivery Pipeline by Emily Bache

What steps should you include? how long will it take from commit to deploy? Be creative and collaborate to come up with the best solution for your scenario. In this workshop we will learn about designing a Continuous Delivery pipeline, by playing a game with a custom card deck. We will work in groups, each one designing a pipeline for a slightly different business scenario, with different priorities, risks and competitors. Some of the cards represent steps you could include in your pipeline, and by laying them out on a table, you will decide which to include and how long each should take. Other cards describe constraints which restrict your design choices. During the workshop you will learn about the DevOps metrics described in the book ‘Accelerate’ by Nicole Forsgren et al. We will work out the lead time for the pipelines we have designed, and discuss how that will affect our competitiveness in the marketplace. At the end you will have the chance to take a card deck home with you. You might want to use it to help you design a pipeline with your team.

14.10 - 18.40 Parallel Workshop

Compassionate Refactoring by Clare Sudbery

Refactoring is something we all do when writing code, whether consciously or not. But often it's something we guiltily avoid, or feel we don't have time for. Sometimes our teams have areas of code that need so much refactoring we set it aside as a separate task. But the longer we leave it the harder it gets, the longer we know it will take and the more likely it never gets done. This workshop will go through several worked examples in detail, teaching you how to refactor in tiny chunks and with good test coverage. It will teach you ways of seeing refactoring as a daily achievable task instead of an insurmountable mountain, and give you lots of good arguments as to why it is not only worthwhile but essential for robust maintainable code. You will be strongly encouraged to work in pairs for this workshop - a side benefit is that you will learn how pairing can also be used as a useful tool when refactoring, as well as learning some TDD techniques. The reason for the word "compassionate" in the title is that in software we often have a tendency to beat ourselves up or point the finger of blame when we believe our code has not been maintained effectively. One of the emphases in this workshop will be on using forgiveness as a technique to move forward and improve the future without bemoaning the past. No code base is ever perfect. The examples will all be in C# using .Net Core, which means they will work in Linux, on a Mac or on a Windows operating system. You don't need C# experience but you will benefit from knowing a similar language such as Java. You will need coding experience. A Test-Driven approach will be used (although people are often surprised at how few new tests you need to write when refactoring).

14.10 - 18.40 Parallel Workshop

Implementing Real-time Discoverable APIs on the Open Web by Mike Amundsen

What does it take to implement APIs that are easily discovered and used at runtime? What features does an API service provider need to be a part of an autonomous, self-driving API ecosystem? And what features does an API service consumer need in order to take advantage of this rich world of discoverable APIs? This workshop covers the basics of protocol-free service description and open web-based service discovery and, through a set of simple exercises, shows how you can use existing protocols and formats to implement your own discoverable API ecosystem to create API providers and consumers that can survive runtime changes without "breakage" and continue operating as expected. Working examples will be provided in NodeJS and patterns will be provided that can be applied in any other web-aware framework or programming language.

18.40 - 19.10

Closing Ceremony

19.10 - 20.00

Beer & Networking

Pricing Plans Get your Ticket

Blind Tickets

350

Available until 29/02/2020

Group (+ 3 people): 325€ + VAT

Not Available

*Price does not include VAT

Early Bird Tickets

375

1/03/2020 - 31/05/2020

Group (+ 3 people): 350€ + VAT

GSAS 19 Attendees: 325€ + VAT

Buy Ticket

*Price does not include VAT

Regular Tickets

400

1/06/2020 - 31/07/2020

Group (+3 people): 375€ + VAT

Not Available

*Price does not include VAT

Last Year Edition GSAS 2019

Who helps us Call for Sponsors

Reach us Get Direction to the Summit

Filmax Gran Via, L'Hospitalet de Llobregat, Barcelona

Avenida de la Gran Via, 75,08908 L'Hospitalet de Llobregat, Barcelona, Spain

Filmax Gran Via is easily accessible by public transport, just 7 minutes from bus and train stations.

Transports

Car/Taxi: 8 min. ride from the Airport

Bus: L94-L95

Train: Europa Fira (FGC) R5-R6-R50-R60-S3-S4-S8-S9

Metro: Europa Fira L8-L9S

Contact information

Phone: +34934815085

Email: gsas@apiumhub.com