Lateral Thinking

Developers, Architects, and those of us with heavy STEM backgrounds are well versed in linear thinking. Linear thinking is the ability to use logic to analyse problems and is a central skill for software engineering. When we are working with complex business contexts, cause and effect relationships become fuzzy, logic fails to be the best way to analyse the problems, and sometimes we experience friction with other stakeholders because of our stubborn linear analysis. Becoming a great architect means letting these things complement each other instead of being in conflict. This session introduces a different set of tools that become important as you move toward architectural roles: lateral thinking. Making the best use of both linear and lateral thinking takes time, practice, and reflection, and this session should help you speed up this journey.

The Philosophy of Architecture

This session looks at the underlying philosophical beliefs that inform the everyday practice of software architecture. Instead of endlessly arguing in terms of frameworks and methods, why not understand why we think the way we do, why some people disagree, and why we can’t trust our Computer Science educations? Who are we, why are we like this, and can we ever change?

Model Drift and Software Attractors

What actually happens when we make a decision about a software architecture? How do we map from a business context to a component structure? How do we make decisions about granularity and arrive at monoliths or microservices? Is it heuristic? Is it a repeatable pattern? How do we know if it’s right? Why do we get this wrong so often?

This session takes a step back and looks at the relationship between a business context and software structure using tools from the complexity sciences that help us to clarify our decision making and understand the forces that drive us to think in certain patterns. The session will take traditional methods like process and capability mapping and add a new layer of understanding that will help architects and developers avoid the mistakes of the past. The session will help us to think about where the levers are to make our designs more flexible and identify the places where we can copy from others and, most importantly, where we need to think for ourselves.

Advanced Software Architecture with Residuality(2 days)

Residuality theory is a revolutionary new theory of software design that aims to make it easier to design software systems for complex business environments. Residuality theory models software systems as interconnected residues - an alternative to component and process modeling that uses applied complexity science to make managing uncertainty a fundamental part of the design process.

## This is what you will learn
This workshop teaches advanced, cutting edge techniques based on ongoing research that are designed to identify and decrease risk, improve confidence in decision making and protect your architecture when the domain is characterized by uncertainty.

The workshop introduces ideas on the philosophy of architecture, forcing participants to think outside of the technology and relate decision making to markets, culture, economic and societal concerns. It teaches practical techniques in stressor analysis and the use of matrices to make component decisions and gives participants the chance to work with these techniques in labs and groups.

## Target Audience
This workshop is suitable for senior developers who want a head start into the world of architecture, for teams embarking on large, risk filled projects, and for seasoned architects seeking new techniques. It has also been successful in unting teams around a common definition of architecture.

## Agenda

### Day 1:
- Philosophy of Architecture
- Concrete Complexity for Software Engineering
- Representation in Architecture
- Residuality Theory
- Modelling stress: socio-economic architecture
- Defining residues

### Day 2
- Surviving unknown unknowns
- Producing a real world architecture.
- Contagion analysis and component decisions
- Adjacency matrix techniques
- Incidence matrix techniques
- Testing the architecture

Residues: Time, Change and Uncertainty in Software Architecture

Residuality theory is a revolutionary new theory of software design that aims to make it easier to design software systems for complex business environments. Residuality theory models software systems as interconnected residues - an alternative to component and process modeling that uses applied complexity science to make managing uncertainty a fundamental part of the design process.

Based on ongoing research: https://www.sciencedirect.com/science/article/pii/S1877050920305585
https://www.cutter.com/article/“there-no-spoon”-residuality-theory-rethinking-software-engineering (contact me for free copy)