--

Low Hanging
Software
Architectures
software architectures and problems they solve
for you to apply in your project today!

Yugo Sakamoto
/
--

Table of
contents

Introduction
Yugo Sakamoto
Architecture Patterns
Architectures
Layered Architecture
Event Driven Architecture
Microservice Architecture
Problems
Scaling
Evolving
Reducing Bugs
Solving Common Problems
Reach out!

/
Introduction
Low Hanging Software Architecture are basic
architecture concepts that bring lots of value
and results to your project, but that are easy
to learn and apply.

Do you struggle to understand how your applications works

without having to go deep into the code? Maybe you are
missing some common software architecture patterns
concepts or even worse, your application doesn’t follow any
pattern at all and you already have a big ball of mud!
Understanding some software architecture patterns can help
you design better solutions, giving you more clarity to create
new software or also xing already existing ones.
Mark Richards in his Software Architecture Patterns,
described some of the most common patterns used in our
industry.
Here we will look at the 3 most used architectures, and
discuss 4 architecture problems so you can improve your
project today.
This e-book is part of the "Low Hanging" series. Easy things
you can do that will give you amazing results.

Yugo Sakamoto
Yugo Sakamoto - Software Architect

/
--

Yugo sakamoto

Building software in the

technology industry and
leading development
teams for the last 10
years, Yugo helps
professionals developers
to create elegant software
architectures, so they can
create credibility, in uence
their project decisions and
become technical leaders
of their teams.

Interested in having
amazing projects using the
best architectures? Ping
me and we can have a
conversation.

Twitter: @ymoto

/
--

Just as developers use design

patterns in software
development, architects use
well-de ned architecture
patterns to de ne the
characteristics and shape of
the architecture.
Mark Richards - Software
Architecture Patterns

/
--

Low Hanging Software Architectures

ArCHitectures
well-defined architecture patterns helps you to define the
characteristics and shape of the software architecture.

/
--

Layered Architecture
Organize your application into
horizontal layers, each layer with a
specific role and responsibility.
Presentation, business and persistence are
standard layers for this pattern, and it’s a
great starting point for most projects.
Keeps components decoupled between
different layers and is easy to understand by
every developer.
The problem with this architecture pattern is
that horizontal separation of your entire
application may bloat your code sometimes
or push you to a monolithic development
approach, which unfit in particular scenarios.

/
--

Event Driven Architecture

Use events to control your
application execution flow and
asynchronously run your logic into
separated event processors.
It’s a popular pattern to create highly scalable
applications due to the strong decoupled
feature.
You may need to use an event mediator to
orchestrate the execution of the event
processors or chain the events by directly
triggering the event processors.
The bad side of this pattern is that event
driven architecture can become very
complex to maintain, due to the
asynchronous distributed nature.
You are going to face challenges with remote
process availability, lack of responsiveness
and other kinds of component failures.

/
--

Microservice Architecture
If you split the application into
independent, distributed and
separately deployable
components you will have a high
decoupled and more evolvable
architecture. This is Microservices.
Microservices are responsible for a part of
your application domain.
These components can communicate with
each other through remote protocol such as
JMS, REST, SOAP or any others.
The distributed nature allows you to achieve
higher scalability and more frequent and
independent deployment pipelines.
This pattern is powerful but comes with a lot
of complexity.
Many distributed components, working
asynchronously, deployed independently,
each with their own life-cycle, version and
even database. Sometimes written in
different programming languages.
All this requires advanced tooling and a
good trade-off before applying it.
/
--

Low Hanging Software Architectures

PROBLEMS
architecture patterns solve real life problems. But each one
has different objectives. Understanding the trade-off helps
you choose the correct architecture for your problem.

/
--

Scaling

Scaling is the ability for a system

to support a large number of
users, requests or executions.

Software architectures help you create

components that improve the scalability of
your application.
The layered architecture distributes the
load in each layer, helping with scalability.
But the event driven and the microservices
architectures are the ones that will take
scaling to a higher level.
Having higly decoupled components allows
for the application to increase or reduce the
size or number of each component, to reach
a higher scalability.

/
--

Evolving

Evolution is the ability of a system

to evolve, add new functionality or
change existing features to adapt
for changed requirements.

A good architecture will minimize the impact

of a change, so the team can be more
confident in adding new things into the
project. This guarantees that the system will
evolve to support the ever changing business
demands.
The layered architecture although it has
separation between the layers, they can have
too strong dependencies. Business changes
in one layer -- lets say, the user interface --
usually needs to be reflected in all other
layers.
Event driven and microservices
architectures are much better at handling
changes. Each component is highly
independent. Changes in one part of the
system can be done without affecting other
components. Microservices can even be
completely self-suficient!

/
--

Reducing Bugs

It is important that an architecture

helps with bug reduction. The
harder it is to catch or identify a
bug, the bigger the chance that it
will break the system later on.

Software architectures can make it easier to

identify bugs, and so they can help our teams
to reduce potential harmful problems.
The decoupling from microservices
architecture can be awesome for many things,
but creates a very complex integration
situation. Catching bugs, reproducing
problems, and even identifying where the
problem happened can be a complex effort.
Event driven architectures reduce the
integration problems by having all
components connecting to an event bus.
Testing and bug hunting becomes easier.
Testing the layered architecture is more
direct. It is easy to understand what is going
on with the system and where the problem is
located. What it looses in flexible, it gains a lot
in terms of simplicity!

/
--

Solving Common Problems

Most software applications suffer

from common issues such as
logging and security. You could
develop in-house, specific
solutions. But there are plenty of
third party or open source
components to solve those things.

Software architectures can help you experiment

and connect those solutions to your system, so
you can choose the best one for your situation.
When experimenting third party solutions,
layered architecture may end up creating strong
dependency to them, giving you less freedom to
change them later.
Event driven architecture usually requires a
connection to the event bus, and may limit your
choice of components.
Because each microservice is independent, you
can completely separate third party
dependencies in the microservice
architecture. Microservices can be written in any
language, so you can choose the best solution
available from a broad pool of components.

/
--

reach out!
Follow Yugo Sakamoto on twitter to
get daily tips about software
architectures and leadership.

@ymoto