Please enable JavaScript.
Coggle requires JavaScript to display documents.
Clean architecture (PART V (Chapter 15: what is architecture, Chapter 16:…
Clean architecture
PART V
Chapter 15: what is architecture
Chapter 16: Independence
Chapter 17: Boundaries: Drawing lines
Chapter 18: Boundary anatomy
Chapter 19: Policy and level
Chapter 20: Business rules
Chapter 21: Screaming architecture
Chapter 22: The clean architecture
Chapter 23: Presenters and humble objects
Chapter 24: Partial boundaries
Chapter 25: Layers and boundaries
Chapter 26: The main component
Chapter 27: Services: great and small
Chapter 28: The test boundary
Chapter 29: Clean embedded architecture
PART III
Chapter 7: SRP: The single responsibility principle
Chapter 8: OCP: The open-closed principle
Chapter 9: LSP: The liskov substitution principle
Chapter 10: ISP: The interface segregation principle
Chapter 11: DIP: The dependency inversion principle
PART VI
Chapter 30: The database is a detail
Chapter 31: The web is a detail
Chapter 32: Framework are details
Chapter 33: Case study: video sales
Chapter 34: The missing chapter
PART II
Chapter 3: paradigm overview
Chapter 4: structured programming
Chapter 5: Object-oriented programming
Chapter 6: Functional programming
PART IV
Chapter 12: Components
Chapter 13: Component cohesion
Chapter 14: Component coupling
PART I
Chapter 1. What is design and architecture?
Chapter 2: A tale of two values
Clean code
CHAPTER 1: CLEAN CODE
CHAPTER 2: MEANINGFUL NAMES
CHAPTER 3: FUNCTIONS
CHAPTER 4: COMMENTS
CHAPTER 5: FORMATTING
CHAPTER 6: OBJECTS AND DATA STRUCTURES
CHAPTER 7: ERROR HANDLING
CHAPTER 8: BOUNDARIES
CHAPTER 9: UNIT TESTS
CHAPTER 10: CLASSES
CHAPTER 11: SYSTEMS
CHAPTER 12: EMERGENCE
CHAPTER 13: CONCURRENCY
CHAPTER 14: SUCCESSIVE REFINEMENT
CHAPTER 15: JUNIT INTERNALS
CHAPTER 16: REFACTORING SerialDate
CHAPTER 17: SMELLS AND HEURISTICS
APPENDIX A: CONCURRENCY II
The mythical man-month
CHAPTER 1: THE TAR PIT
CHAPTER 2: THE MYTHICAL MAN-MONTH
CHAPTER 3: THE SURGICAL TEAM
CHAPTER 4: ARISTOCRACY, DEMOCRACY, AND SYSTEM DESIGN
CHAPTER 5: THE SECOND-SYSTEM EFFECT
CHAPTER 6: PASSING THE WORD
CHAPTER 7: WHY DID THE TOWER OF BABEL FAIL?
CHAPTER 8: CALLING THE SHOT
CHAPTER 9: TEN POUNDS IN A FIVE-POUND SACK
CHAPTER 10: THE DOCUMENTARY HYPOTHESIS
CHAPTER 11: PLAN TH THROW ONE AWAY
CHAPTER 12: SHARP TOOLS
CHAPTER 13: THE WHOLE AND THE PARTS
CHAPTER 14: HATCHING A CATASTROPHE
CHAPTER 15: THE OTHER FACE
FUNDAMENTALS OF SOFTWARE ENGINEERING
1. INTRODUCTION
2. SOFTWARE LIFE CYCLES MODELS
3. SOFTWARE PROJECT MANAGEMENT
4. REQUIREMENTS ANALYSIS AND SPECIFICATION
5. SOFTWARE DESIGN
6. FUNCTION-ORIENTED SOFTWARE DESIGN
7. OBJECT MODELLING USING UML
8. OBJECT-ORIENTED SOFTWARE DEVELOPMENT
9. USER INTERFACE DESIGN
10. CODING AND TESTING
11. SOFTWARE RELIABILITY AND QUALITY MANAGEMENT
12. COMPUTER AIDED SOFTWARE DESIGN
13. SOFTWARE MAINTENANCE
14. SOFTWARE REUSE
15. EMERGING TRENDS
REFACTORING IMPROVING THE DESIGN OF EXISTING SOFTWARE
CHAPTER 1: REFACTORING, A FIRST EXAMPLE
CHAPTER 2: PRINCIPLES IN REFACTORING
CHAPTER 3: BAD SMELLS IN CODE
CHAPTER 4: BUILDING TESTS
CHAPTER 5. TOWARD A CATALOG OF REFACTORINGS
CHAPTER 6: COMPOSING METHODS
CHAPTER 7: MOVING FEATURES BETWEEN OBJECTS
CHAPTER 8: ORGANIZING DATA
CHAPTER 9: SIMPLIFYING CONDITIONAL EXPRESSION
CHAPTER 10: MAKING METHODS CALL SIMPLER
CHAPTER 11: DEALING WITH GENERALIZATION
CHAPTER 12: BIG REFACTORINGS
CHAPTER 13: REFACTORING, REUSE, AND REALITY
CHAPTER 14: REFACTORING TOOLS
CHAPTER 15: PUTTING IT ALL TOGHETHER
code simplicity
1. INTRODUCTION
2. THE MISSING SCIENCE
3. THE DRIVING FORCES OF SOFTWARE DESIGN
4. THE FUTURE
5. CHANGE
6. DEFECTS AND DESIGN
7. SIMPLICITY
8. COMPLEXITY
9. TESTING
INTRODUCTION TO ALGORITHMS
1. FOUNDATIONS
THE ROLE OF ALGORITHMS IN COMPUTING
GETTING STARTED
GROWTH OF FUNCTIONS
DIVIDE-AND-CONQUER
PROBABILISTIC ANALYSIS AND RANDOMIZED ALGORITHMS
2. SORTING AND ORDER STATISTICS
HEAPSORT
QUICKSORT
SORTING IN LINEAR TIME
MEDIANS AND ORDER STATISTICS
3. DATA STRUCTURES
ELEMENTARY DATA STRUCTURES
HASH TABLES
BINARY SEARCH TREES
RED-BLACK TREES
AUGMENTED DATA STRUCTURES
4. ADVANCED DESIGN AND ANALYSIS TECHNIQUES
DYNAMIC PROGRAMMING
GREEDY ALGORITHMS
AMORTIZED ANALYSIS
5. ADVANCED DATA STRUCTURES
B-TREES
FIBONACCI HEAPS
VAN EMDE BOAS TREES
DATA STRUCTURES FOR DISJOINT SETS
6. GRAPH ALGORITHMS
ELEMENTARY GRAPH ALGORITHMS
MINIMUM SPANNING TREES
SINGLE-SOURCE SHORTEST PATHS
ALL-PAIRS SHORTEST PATHS
MAXIMUM FLOW
7. SELECTED TOPICS
MULTITHREADED ALGORITHMS
MATRIX OPERATIONS
LINEAR PROGRAMMING
POLYNOMIALS AND THE FFT
NUMBER-THEORIC ALGORITHMS
STRING MATCHING
COMPUTATIONAL GEOMETRY
NP-COMPLETENESS
APPROXIMATION ALGORITHMS
8. APPENDIX: MATHEMATICAL BACKGROUND
A. SUMMATIONS
B. SETS, ETC.
C. COUNTING AND PROBABILITY
D. MATRICES
THE PRAGMATIC PROGRAMMER
1. A PRAGMATIC PHILOSOPHY
2. A PRAGMATIC APPROACH
3. THE BASIC TOOLS
4. PRAGMATIC PARANOIA
5. BEND, OR BREAK
6. WHILE YOU ARE CODING
7. BEFORE THE PROJECT
8. PRAGMATIC PROJECTS
CODE COMPLETE 2
PART I: LAYING THE FOUNDATION
PART II: CREATING HIGH-QUALITY CODE
PART III: VARIABLES
PART IV: STATEMENTS
PART V: CODE IMPROVEMENTS
PART VI: SYSTEM CONSIDERATIONS
PART VII: SOFTWARE CRAFTSMANSHIP
DESIGN PATTERNS
1. INTRODUCTION
2. A CASE STUDY: DESIGNING A DOCUMENT EDITOR
3. CREATIONAL PATTERNS
4. STRUCTURAL PATTERN
5: BEHAVIORAL PATTERN
6: CONCLUSION
STRUCTURE AND INTERPRATATION OF COMPUTER PROGRAMS
1. BUILDING ABSTRACTIONS WITH PROCEDURES
1.1: THE ELEMENTS OF PROGRAMMING
1.2: PROCEDURES AND THE PROCESSES THEY GENERATE
1.3: FORMULATING ABSTRACTION WITH HIGHER-ORDER PROCEDURES
2. BUILDING ABSTRACTIONS WITH DATA
2.1: INTRODUCTION TO DATA ABSTRACTION
2.2: HIERARCHICAL DATA AND THE CLOSURE PROPERTY
2.3: SYMBOLIC DATA
2.4: MULTIPLE REPRESENTATIONS FOR ABSTRACT DATA
2.5: SYSTEMS WITH GENERIC OPERATIONS
3. MODULARITY, OBJECTS, AND STATE
3.1: ASSIGNMENT AND LOCAL STATE
3.2: THE ENVIRONMENT MODEL OF EVALUATION
3.3 MODELING WITH MUTABLE DATA
3.4 CONCURRENCY: TIME IS OF THE ESSENCE
3.5: STREAMS
4. METALINGUISTIC ABSTRACTION
4.1 THE METACIRCULAR EVALUATOR
4.2: VARIATIONS ON A SCHEME - LAZY EVALUATIONS
4.3: VARIATIONS ON A SCHEME - NONDETERMINISTIC COMPUTING
4.4: LOGIC PROGRAMMING
5. COMPUTING WITH REGISTER MACHINES
5.1: DESIGNING REGISTER MACHINES
5.2: A REGISTER-MACHINE SIMULATOR
5.3: STORAGE ALLOCATION AND GARBAGE COLLECTION
5.4: THE EXPLICIT-CONTROL EVALUATOR
5.5: COMPILATION
WORKING EFFECTIVELY WITH LEGACY CODE
PART I: CHANGING SOFTWARE
CHAPTER 1: CHANGING SOFTWARE
CHAPTER 2: WORKING WITH FEEDBACK
CHAPTER 3: SENSING AND SEPARATION
CHAPTER 4: THE SEAM MODEL
CHAPTER 5: TOOLS
PART II: CHANGING SOFTWARE
CHAPTER 6: I DON'T HAVE MUCH TIME AND I HAVE TO CHANGE IT
CHAPTER 7: IT TAKES FOREVER TO MAKE A CHANGE
CHAPTER 8: HOW TO ADD A FEATURE?
CHAPTER 9: I CAN'T GET THIS CLASS INTO A TEST HARNESS
CHAPTER 10: I CAN'T RUN THIS METHOD IN A TEST HARNESS
CHAPTER 11: I NEED TO MAKE A CHANGE. WHAT METHODS SHOULD I TEST?
CHAPTER 12: I NEED TO MAKE MANY CHANGES IN ONE AREA
CHAPTER 13: I NEED TO MAKE A CHANGE, BUT I DON'T KNOW WHAT TESTS TO WRITE
CHAPTER 14: DEPENDENCIES ON LIBRARIES ARE KILLING ME
CHAPTER 15: MY APPLICATION IS ALL API CALLS
CHAPTER 16: I DON'T UNDERSTAND THE CODE WELL ENOUGH TO CHANGE IT
CHAPTER 17: MY APPLICATION HAS NO STRUCTURE
CHAPTER 18: MY TEST CODE IS IN THE WAY
CHAPTER 19: MY PROJECT IS NOT OBJECT ORIENTED, HOW DO I MAKE SAFE CHANGES?
CHAPTER 20: THIS CLASS IS TOO BIG AND I DON'T WANT IT TO GET ANY BIGGER
CHAPTER 21: I'M CHANGING THE SAME CODE ALL OVER THE PLACE
CHAPTER 22: I NEED TO CHENGE A MONSTER METHOD AND I CAN'T WRITE TESTS FOR IT
CHAPTER 23: HOW DO I KNOW THAT I'M NOT BREAKING ANYTHING?
CHAPTER 24: WE FEEL OVERWHELMED. IT ISN'T GOING TO GET ANY BETTER
PART III: DEPENDENCY-BREAKING TECHNIQUES
CHAPTER 25: DEPENDENCY-BREAKING TECHNIQUES