Clean Architecture
Comprehensive Beginners Guide to Learn and Understand Clean Architecture
Copyright 2019 - Connor Wallace - All rights reserved.
The contents of this book may not be reproduced, duplicated, or transmitted without direct written permission from the author. Under no circumstances will any legal responsibility or blame be held against the publisher for any reparation, damages, or monetary loss due to the information herein, either directly or indirectly.
Legal Notice:
This book is copyright protected. This is only for personal use. You cannot amend, distribute, sell, use, quote, or paraphrase any part of the content within this book without the consent of the author.
Disclaimer Notice:
Please note the information contained within this document is for educational and entertainment purposes only. Every attempt has been made to provide accurate, up to date, and reliable information. No warranties of any kind are expressed or implied. Readers acknowledge that the author is not engaging in the rendering of legal, financial, medical, or professional advice. The content of this book has been derived from various sources. Please consult a licensed professional before attempting any techniques outlined in this book. By reading this document, the reader agrees that under no circumstances are the author responsible for any losses, direct or indirect, which are incurred as a result of the use of the information contained within this document, including, but not limited to, errors, omissions, or inaccuracies.
Contents
Clean Architecture
Comprehensive Beginners Guide to Learn and Understand Clean Architecture
Introduction
Chapter One: What is Design and Architecture?
Major Qualities of Software Programming
Eisenhower's Matrix Of Importance Versus Urgency
Summary
Chapter Two: Getting Started with Clean Architecture
How The Language of Programming Evolves
Structured Programming
Functional Decomposition in Structured Programming
Object-Orient Programming
Polymorphism
Functional Programming
Immutability And Architecture
Event Sourcing
Summary
Chapter Three: Principles of Design
Solid Principle
Single Responsibility Principle (SRP)
Accidental Duplication
Merge
Open-Closed Principles
Summary
Chapter Four: Solid Principles
The Liskov Substitution Principle
The Interface Segregation Principle
The Dependency Inversion Principle
Stable Abstraction
Factory
Concrete Component
Summary
Chapter Five: Component Principles
Software Component
History of Software Component
How Library Functions are Located in Those Days
Relocatability
Linkers
Component Cohesion
Tension Resulting from Component Cohesion
Summary
Chapter Six : Component Coupling
The Acyclic Dependencies Principles
How A Cycle Affects the Component Dependency
The Stable Dependencies Principles
What Is Stability in Software Development?
How to Measure the Stability of a Component
The Stable Abstraction Principle (Sap)
How to Measure Abstraction
How To Measure The Relationship Between Stability (I) And Abstractness (A)
Summary
Chapter Seven: Architecture
What Is A Software Architect?
Functions Of A Software Architecture
Decoupling Layers, Uses, And Modes
How to Use the Decouple Mode
Summary
Chapter Eight: Drawing Lines
How To Determine The Lines To Draw And When To Draw The Lines
The Input and Output Of A System
Boundary Anatomy
Summary
Chapter Nine: Elements of Software Architecture
Policy
Level
Business Rules
Entities
Use Cases
Response and Request Models
Summary
Chapter Ten: Theme and Purpose Of Software Architecture
Screaming Architecture
The Theme Of The Software Architecture
The Purpose of an Architecture
Testable Architecture
Clean Architecture
The Dependency Rule
Crossing Boundaries And How To Determine Which Data Cross The Boundary
Entities and Use Case
Interface Adapter
Summary
Chapter Eleven: Boundaries
Partial Boundaries
Layers And Boundaries
Test Boundaries
Testability
What Is Structural Decoupling?
Summary
Chapter Twelve: Significant and Non-Significant Architectural Components
What Is A Presenter in Software Architecture?
What Is An Humble Object Pattern?
Presenter and View
Great and Small Services Of A Software Architecture
Importance of Service to Software Architecture
Summary
Chapter Thirteen: Clean Embedded Software Architecture
Clean Embedded Software Architecture
Ap-titude Test
The Target-Hardware Bottleneck
Controlling The Target-Hardware Bottleneck
The Hardware
The Processor
The Operating System
What Is the Os?
Interface Programming And Substitutability
Dry Conditional Compilation Directives
Summary
Chapter Fourteen: Details
The Database is a Detail
Relational Databases
What Makes a Database System so Prevalent?
Details
Web And Framework Details
A Framework is a Detail
Summary
Chapter Fifteen: Implementation and Case Study
Package by Layer
Package by Feature
Ports And Adapters
Package By Component
Problem with The Implementation Details
Case Study
Use Case
Component Architecture
Managing Dependencies
Summary
Conclusion
Introduction
Designing a working software architecture is one thing; designing a clean architecture is another. To design working software architecture, you don't have to be an expert in programming. You don't need to know all there is about programming before creating architecture with impeccable functionality. However, the fact that your system runs smoothly does not mean the components are thoroughly integrated to avoid imminent problems that might lead to its crashing. The effort required to create a working architecture is not as much as the efforts required to create a clean architecture. Creating a clean architecture requires some level of specialty and competence. This, in software development, is a different ball game entirely.
This book extensively explains all the necessary skills needed to create clean architecture. The level of proficiency needed to build an efficient and effective clean architecture is very different from that required to create a working architecture. Not all working architecture is clean architecture, but all clean architectures work very well and run very smoothly than software designed just for the working benefits alone. The aspect of creating a clean architecture requires thoughts and skills, but unfortunately, many young programmers are not interested in this aspect. What many programmers focus on is creating a working architecture with a high level of productivity while little or no attention is paid to how clean the software is. Developing an impeccable software requires dedication, commitment, and discipline. It requires the desire for self-investment, the passion for the art, and the ambition to become an expert. Without these three keys, a programmer will only remain in the peripheral and will be sidelined as technology develops and progresses.
