This course is intended for developers, leads, architects, and technical managers who are keen on learning and applying the ideas and practices to create maintainable software applications and products. This course dives into practices to create good web applications as well as Microservices.

The course involves presentation and discussions of various concepts in the related areas, including using tests to manage complexities, working with dependencies, creating testable services, and modulating code.

The course includes many examples and also labs for the attendees to pair up and work on. There is a good balance between presentation and hands-on lab work.

Topics

Modularizing Code

• What is a module?
• Design objectives and benefits
• Key design concerns
• Characteristics of a good module
• Identifying modules in existing code
• Leveraging IntelliJ IDEA to identify, extract, and organize modules
• Determining class and interface placements
• Degree of abstraction
• Shallow vs, Deep modules
• Exercise

Design Principles that Aid Better Module Design

• Evaluating Stability
• Evaluating Abstractness
• Acyclic Dependency Principle
• Reuse Release Equivalency Principle
• Use Dependency Structure Matrix (within IDEA) to guide the design
• Sealed classes and their benefits
• Evaluating stability and abstractness
• Exercise

Working with Tradeoffs in Module Design

• Favoring High Cohesion
• Low and loose coupling
• Design principles to focus on
• YAGNI
• Encapsulation
• Reuse
• DRY
• SOLID principles and their relevance
• Evaluating tradeoffs
• Balancing between reuse and coupling
• Why and how not to go overboard with DRY
• Where to apply DRY and where not to
• Mapping of domain models across modules
• Exercise

Evolving Modules

• Risks of evolving
• Risks of not evolving
• Key considerations for evolutionary design
• Refactoring
• Module versioning
• Good practices for versioning
• Contract tests
• Tools to create and continuously execute contract tests
• Conformance tests
• Creating module level constraints as automated tests
• Continuous integration of automated conformance tests
• Exercise

API Design Considerations

• Interface Segregation Principles
• Evolving interfaces
• Extracting interfaces rather than forcing them in
• Benefits of evolution
• Triangulation
• Avoid leaky abstractions
• Maintainability concerns
• Determining function granularity from the user vs. maintained point of view
• Good separation of interface from implementation
• Separating specifications/contracts from alternative implementations
• Exercise

Test Driving Design for Modular Code

• Creating Tests
• Qualities of good tests
• Driving design using tests
• Evolving code, incremental design, and test first development
• Exercise

Designing with Dependencies

• Dealing with dependencies
• Stubs, mocks, spies
• When to use stubs/mocks
• When not to use stubs/mocks
• Signs of inappropriate coupling
• Driving design with dependencies using tests
• Exercise

Testing Service Contracts

• Integrating testing
• Fakes to facilitate reliable development
• Service boundaries and contracts testing
• Exercise

Measuring Code Quality

• Creating maintainable code
• Measuring code complexity
• Measuring design quality
• A dozen ways to improve code quality
• Refactoring to improve code and design quality
• Reevaluating and measuring quality
• Exercise