If you are a software developer and you are looking towards your first software architect role, or you are a developer and want to become more architecturally aware, or you are a software architect and new to the role, this Software Architecture for Developers course is for you! Simon is an independent consultant specialising in software architecture, and the author of “Software Architecture for Developers” (a developer-friendly guide to software architecture.
Warning: this review is based on the pre-released leanpub version of the book with some chapters still missing. I'll check out the released version and update my review when it's ready.I'd rather gave the book 5 stars as its subject is indeed relevant and its ideas appeal very much to my agile and lean taste. This book will definitely help you approach software architecture in a lightweight manner avoiding rework in the near future, analysis paralysis and big design upfront. I highly recommend i Warning: this review is based on the pre-released leanpub version of the book with some chapters still missing. I'll check out the released version and update my review when it's ready.I'd rather gave the book 5 stars as its subject is indeed relevant and its ideas appeal very much to my agile and lean taste. This book will definitely help you approach software architecture in a lightweight manner avoiding rework in the near future, analysis paralysis and big design upfront.
I highly recommend it to anyone working in software development.I gave the book only 3 stars though because I didn't like 2 major points about the way those ideas are delivered.First, the book is a series of essays. Though they are logically ordered, I missed the storyline throughout the book. I know it's a non-fiction, but the book in my opinion is too much about making the case for the method it presents, rather than actually describing and guiding the reader through the method. Essays also contain a lot of repetition, I've encountered some passages like three or four times in the book.Second, I didn't like how the book tries to position itself against Agile. Though the book actually promotes quick feedback loops, iterative and incremental delivery, it in my opinion misrepresents agile as lacking any design activities. I think how the work stream is managed and what activities it contains is completely orthogonal.
That's why the book would appeal much better to me if it focused itself on integrating architecture activities in management practices rather fighting them (it equally fights waterfall to be fair). Simon Brown shows in his book “Software Architecture for Developers” how many so-called “agile projects” work: Ignore all documentation, architecture and just write code. If you ever worked in a project where the person in the role of a software architect abused this role to hide his incompetence you can sympathise with the just code approach.However, if you need to build something that can’t be done in a few weeks you need to care for the overall structure. If you do this as a team effort or wi Simon Brown shows in his book “Software Architecture for Developers” how many so-called “agile projects” work: Ignore all documentation, architecture and just write code. If you ever worked in a project where the person in the role of a software architect abused this role to hide his incompetence you can sympathise with the just code approach.However, if you need to build something that can’t be done in a few weeks you need to care for the overall structure.
If you do this as a team effort or with a dedicated role for architecture may vary by project. For both ways you find guidance in this book.As Simon Brown explains this doesn’t mean you need to go back to big upfront planning.
Architecture and agile projects are not a contradiction and can work together. The big picture is relevant and with timely feedback architectural decisions can be validated as you (hopefully) do it with business requirements on a daily basis.With so many examples from the real world and fitting solutions to the discovered problems I can highly recommend you to read this book. A pretty decent book about the Software Architecture, promoting the concept of the coding architect. The pros of this book are that in one place it gathers strong arguments why SW architecture matters and how to promote these ideas.I would recommend this book either to some aspirant to the architect role, or even to any senior developer who cares about the context of his project, solution and technology. On the other hand, any architect practitioner, who has a few years of experience with the su A pretty decent book about the Software Architecture, promoting the concept of the coding architect. The pros of this book are that in one place it gathers strong arguments why SW architecture matters and how to promote these ideas.I would recommend this book either to some aspirant to the architect role, or even to any senior developer who cares about the context of his project, solution and technology.
On the other hand, any architect practitioner, who has a few years of experience with the subject, probably won't find many new ideas here.That's also my story - I can't agree more with what is said in the book, but I had found almost everything intuitively by myself before. Therefore, I'm rather looking forward to the next volume, which looks more promising.One negative point, I'm going to mention: it's clear that there was no editor/corrector. In too many places the author just copy-pasted some paragraphs. It's too frequent and it's annoying. Volume 1 of Software Architecture for Developers has been on my to-read list for a long while.Before jumping into this book, I went through other popular software architecture books and developed some personal practical experience and opinions about software architecture in the past 2 years.I suggest as compliments to the learning experience of the book this presentation of Simon Brown. It's a nice overview of some of his point and better strengthens so Volume 1 of Software Architecture for Developers has been on my to-read list for a long while.Before jumping into this book, I went through other popular software architecture books and developed some personal practical experience and opinions about software architecture in the past 2 years.I suggest as compliments to the learning experience of the book this presentation of Simon Brown. It's a nice overview of some of his point and better strengthens some of the points that you're going to see through the book.But focusing on the book, as many other software architecture book authors have noted, being a Software Architect is not an easy task.
It's a role and not a title. Dictatorship rarely works and when it does, it's the organization's choice to practice this approach, not cause you're an architect. It's to your benefit to be adapting and do the best you can in the environment you have.Given the difficulties of the role, the book.does not talk about UML, SysML, BPMN, architecture diagrams and tools that you can use.As other reviewers have noted, the content is a collection of essays.
They say that they're not really ordered, but in my opinion, it's structured enough to make sense of it.The start of a learning experience is very important. Architecture' starts with defining what software architecture is for the author, what types of architecture exist and what they are.What the benefits of software architecture are, is a very important highlight.For better or worse, as Simon Brown points out, with the exponentially increasing popularity, training and 'organization interest' in Agile, people jumped the train with something that they don't really understand that well. The Agile manifesto is a well thought out compilation of values that software system/projects must have, but it does not exclude the 'less valuable' part of the examples, such as 'working code vs documentation'. The later is still important and must not be omitted.Technical leadership is a must have.
Agile does not argue against it, although non-technical and even 'technical' agile trainers and practitioners would argue against it.Simon. Says valid points why Software Architecture is still a must in an agile workflow.
However Agile battles the worst-cases of software architecting where 'design up front' is taken to the extreme where it's 'huge design upfront' without actual prototypes or validation of the approach chosen. The spectrum goes in the other way - no design at all upfront. Finding balance between going full no-brain Agile and extreme Waterfall 'huge design upfront' is key.
As many other experienced industry veterans have said: 'big design up front is bad, but no design upfront at all is just naive'.The industry people have also changed. Fewer people understand and/or are interested to learn how to read software architecture diagrams. They may have poor or no understanding of UML, design patterns and common system architecture. Does this mean that we throw the towel and blame it on the people? No.We have to adapt and be better at how we present information and make sure that it's understandable by our audience.As Simon points out, there's chaotic, teaching and self-organizing leadership.Chaotic is the most hands-on approach without creative freedom, it's only a survival mode move.Teaching is the 'in the middle' approach where you have to do it if you want to go next for 'self-organizing' leadership, where everybody is able to collaborate and drive forward with a clear vision of the product and software.How to overcome the 'teaching' phase? Simon very thoughtfully points out to.mind the gap. and actually help them understand your vision, how you can help them and how they can help you.
It's a collaborative effort and you want to learn from each other. The book matches exactly its name. If you are a developer and you want to know what the heck is that 'software architecture' and who are those (astronauts) 'architects'?, then this book should be the first to read.This book help you understand:- What is architecture?- Who are architects and what they do?- How architects create architectures?and under every question, you will find some other interesting topics like:- The conflict between architecture and agile- Do architects write code?- How much The book matches exactly its name. This one of the best technical books I've read although it doesn't contain any code.
It makes clear so many otherwise confusing and fuzzy things.First, the definition and explanation of what is Software Architecture, the main functions an architect should be doing, the explanation about where it comes from in the ancient times make clear the idea of what SA is about very clear.Also, the explanation about how to introduce SA in your company or team, the remarks about the importance and the danger This one of the best technical books I've read although it doesn't contain any code. I liked the book and it is usefull but overall I thought that it would be better. A lot of complaints, most of them are accurate but still. Simon tries to explain why software architecture is important, and how software book which describes a project and its evolution should be prepared in structural way. He describes also his C4 model.some quotes:But, generally speaking, a software architect who codes is a more effective and happier architect.
You shouldn’t necessarily rule out coding just bec I liked the book and it is usefull but overall I thought that it would be better. A lot of complaints, most of them are accurate but still. Simon tries to explain why software architecture is important, and how software book which describes a project and its evolution should be prepared in structural way. He describes also his C4 model.some quotes:But, generally speaking, a software architect who codes is a more effective and happier architect. You shouldn’t necessarily rule out coding just because “you’re an architect”.After telling me that he had little or no involvement in the project after he handed over the “solution”, I asked him how he knew that his software architecture would work. Puzzled by this question, he eventually made the statement that this was “an implementation detail”. He confidently viewed his software architecture as correct and it was the development team’s problem if they couldn’t get it to work.
In my view, this was an outrageous thing to say and it made him look like an ass during the interview. His approach was also AaaS “Architecture as a Service”!Despite people’s aspirations to be agile, collective code ownership and a distribution of the architecture role are likely to hinder chaotic teams rather than help them.Software architecture is about the significant design decisions, where significance is measured by cost of change. A high-level understanding of the requirements, constraints and principles is a starting point for those significant decisions that will ultimately shape the resulting software architecture. Understanding them early will help to avoid costly rework in the future.If you don’t understand the trade-offs that you’re making by choosing technology X over Y, you shouldn’t be making those decisions.
It’s crucial that the people designing software systems understand technology. This is why software architects should be master builders.Having run architecture katas with thousands of people over a number of years, I can say with complete confidence that visualising the architecture of a software system is a skill that very few people have.
People can draw diagrams, but those diagrams often leave much to the imagination.Abandoning UML is all very well but, in the race for agility, many software development teams have lost the ability to communicate visually.Agility requires good communication Why is this important? In today’s world of agile delivery and lean startups, 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.A better approach is to create a number of diagrams at varying levels of abstraction. A number of simpler diagrams can describe software in a much more effective way than a single complex diagram that tries to describe everything.How the software system fits into the existing system landscape. Why the technologies in use were chosen. The overall structure of the software system. Where the various components are deployed at runtime and how they communicate.
How the web-tier “knows” where to find the middle-tier. What approach to logging/configuration/error handling/etc has been adopted and whether it is consistent across the codebase.
Whether any common patterns and principles are in use across the codebase. How and where to add new functionality. How security has been implemented across the stack. How scalability is achieved. How the interfaces with other systems work. Etc“Working software over comprehensive documentation” is what the Manifesto for Agile Software Development says and it’s incredible to see how many software teams have interpreted those five words as “don’t write any documentation”.The agile manifesto values “responding to change” over “following a plan”, but of course this doesn’t mean you shouldn’t do any planning and it seems that some agile teams are afraid of doing any “analysis” at all. The result is that in trying to avoid big up front design, agile teams often do not design up front and instead use terms like “emergent design” or “evolutionary architecture” to justify their approach.These conflicts, in many cases, lead to chaotic teams that lack an appropriate amount of technical leadership.
Software systems that look like big balls of mud and/or don’t satisfy key architectural drivers such as non-functional requirements.Architecture is about the stuff that’s hard or costly to change. It’s about the big or “significant” decisions, the sort of decisions that you can’t easily refactor in an afternoon.
This includes, for example, the core technology choices, the overall high-level structure (the big picture) and an understanding of how you’re going to solve any complex/risky/significant problems. Software architecture is important.Agile and architecture aren’t in conflict. Rather than blindly following what others say, software teams need to cut through the hype and understand the technical leadership style and quantity of up front design that they need given their own unique context.Based upon my definition of architecture, you could say that you need to do just enough up front design to give you structure and vision. I read this book after it was highly recommended by a senior architect at my company. After reading it, I have some mixed feelings about it!The best part of the book by far is the C4 section.
As a developer, I have always struggled with visualizing the architectures systems that I work on, which I tried to do when introducing the system to new members, for instance. The 'aha' moment came when realizing that trying to put all the information in one diagram does not make sense! The 4 diagrams that I read this book after it was highly recommended by a senior architect at my company. After reading it, I have some mixed feelings about it!The best part of the book by far is the C4 section. As a developer, I have always struggled with visualizing the architectures systems that I work on, which I tried to do when introducing the system to new members, for instance. The 'aha' moment came when realizing that trying to put all the information in one diagram does not make sense!
The 4 diagrams that the author introduces felt very natural, and I was able to use them later when visualizing an entire system, or only the designs of new components/modules.As for the other chapters that define architecture and the role of an architect: I found them to be valuable as well. However, it is very obvious when you read them that they are based on a series of articles. The chapters are also full of repetitions.
Some ideas - even some paragraphs - have been repeated more than 2-3 times! These ideas are indeed important, but the repetition does not add any value.One final note if you have not read the book yet: this book is not about architectural patterns. You will not find here ideas or patterns in software architecture, but rather a higher level discussion of the role of an architect and what software architecture is all about.Overall, I would still recommend at least skimming this book for any person working in software development and to focus on the C4 chapters. The book seems to me like a collection of university essays on different topics related to software architecture. In most cases, it simply conveyed the parts of the role and is a guidebook if you ever find yourself an architect. I didn't find it inspiring, and I'm certainly not going to come back to it in moments of hard architecture decisions, and felt quite unlike Simon's speeches or his general vibe of inspiration.Good parts:.
Structured breakdown of the role. Lists of things to consider wh The book seems to me like a collection of university essays on different topics related to software architecture. In most cases, it simply conveyed the parts of the role and is a guidebook if you ever find yourself an architect. I didn't find it inspiring, and I'm certainly not going to come back to it in moments of hard architecture decisions, and felt quite unlike Simon's speeches or his general vibe of inspiration.Good parts:. Structured breakdown of the role. Lists of things to consider when starting or consulting a large project. Tips on visualising architecture.
Great source if you're writing your thesisNot so good parts:. No drive, inspiration or attention-grasping, all quite dry.
Lots of watery chapters which don't really say anything. Not much to help you become a better architect.
The best concept in this book is what Simon refers to as the 'C4' model - Context, Container, Component, Classes. Using these alone provides architectural value to projects. I tend to agree with Simon that not enough developers value or understand the role of an architect. The 'coding' architect he talks of feels like a rarity - but those I know are like this are far more valued. Simon also provides a good outline for how to lightly document software.
My main disappointment was the constant refe The best concept in this book is what Simon refers to as the 'C4' model - Context, Container, Component, Classes. Using these alone provides architectural value to projects. I tend to agree with Simon that not enough developers value or understand the role of an architect. The 'coding' architect he talks of feels like a rarity - but those I know are like this are far more valued. Simon also provides a good outline for how to lightly document software. My main disappointment was the constant references to Agile 'evangelists' in a somewhat derogatory undertones towards the end of the book.
I took a lot from this book and would recommend teams get to grips with the C4 model at least and consider many of Simon's documentation ideas. This book provides some really good things to use if you are responsible/concerned about the architecture of a software system. I will definitely consult it when starting the next project (as well as throughout the project as the architecture evolves). If there is one main point I took away from this book is that it is important to get various members involved in architectural decisions. This helps team members have a better sense of ownership for it as well as making better decisions by simply This book provides some really good things to use if you are responsible/concerned about the architecture of a software system.
I will definitely consult it when starting the next project (as well as throughout the project as the architecture evolves). If there is one main point I took away from this book is that it is important to get various members involved in architectural decisions. This helps team members have a better sense of ownership for it as well as making better decisions by simply being aware of the architectural vision.
Simon is an independent software development consultant specializing in software architecture - specifically technical leadership, communication, and lightweight, pragmatic approaches to software architecture. Simon is the author of 'Software Architecture for Developers', a developer-friendly guide to software architecture, technical leadership, the balance with agility and communicating software Simon is an independent software development consultant specializing in software architecture - specifically technical leadership, communication, and lightweight, pragmatic approaches to software architecture.
Simon is the author of 'Software Architecture for Developers', a developer-friendly guide to software architecture, technical leadership, the balance with agility and communicating software architecture with sketches, diagrams, and models. He is also the creator of the C4 software architecture model and the founder of Structurizr, a SaaS product to create web-based software architecture diagrams using code.
A developer-friendly guide to software architecture, technical leadership and the balance with agilityThis book is a practical and pragmatic guide to lightweight software architecture for developers. Youll learn:The essence of software architecture.Why the software architecture role should include coding, coaching and collaboration.The things that you.really. need to think about before coding.How to visualise your software architecture using simple sketches.A lightweight approach to documenting your software.Why there is.no. conflict between agile and architecture.What «just enough» up front design means.How to identify risks with risk-storming. File:PDF, 3.74 MBSoftware Architecture for DevelopersTechnical leadership by coding, coaching, collaboration,architecture sketching and just enough up front designSimon BrownThis book is for sale at version was published on 2014-05-12This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishingprocess.