Software Architecture

Software architecture is a very important phase on a project, because it can present all the parts or the
necessary things it will need. By having a greater context, not just, single functions, the software
architect could review the “blueprint” in search for errors or requirements not totally satisfied.

At this stage, a change on requirements is not a huge deal, like we saw on software modeling, a
change on requirements will cost more time and money as the project is close to completion.

As Googliffe stated in his book, we need to find a balance between the software’s architecture
being too general, that we can’t understand the scope of the development, or too specific,
that a simple change of requirements will have a big impact on the design.

All software projects need some sort of architecture if they need to be finished on a reasonable
time, even the smaller ones. As the project becomes bigger, it’ll need a bigger architecture,
but it has to still be compact, so everyone, even outsiders of the project, could get a grasp of
what the project is about.

I think the examples given of software architecture comparing it with building architecture is
great because they have same type of success on the project, and a change once the project
has begun, could compromise the reliability of the project and could not be ready for launch on
the due date.

The architecture is about knowing what components of software do, and how they interact with
each other. The implementation and how they work isn’t on the architect’s worries.

Not all software is created equal, so there are many styles to create an architecture. For starters,
we need a good architecture, a project with no architecture most likely will produce more problems
than it solves, “cheap gets expensive”. The most common is the layered, which stacks components
as if they were blocks, one on top of the other, so the top components doesn’t get affected if a lower
component gets changed. The pipe and filter are just components that take data, modify it and pass
it so other components can do the same. The client-server just relies on a external computer(server)
to do the heavy lifting, and then it returns data to the client. Component-Based architecture works
by dividing the project into smaller pieces which talk to each other, all of them solving different
tasks. Finally the Framework is just a collection of predefined methods and functions that a
developer can use to simplify the project and waste less time.

Goodliffe, P. (2006). Code Craft. S. Francisco: No Starch Press.