Code Quality and Software Craftsmanship: Fundamentals of Professional Software Development

Course Overview

This comprehensive 2-day foundation course teaches the fundamentals of high-quality software development. Participants learn the principles of Clean Code, Software Craftsmanship, and professional software engineering. Hands-on exercises introduce Test-Driven Development (TDD), code reviews, and static code analysis. The course establishes the foundation for ensuring sustainable code quality within development teams.

What You Will Learn

Day 1: Fundamentals & Classical Approaches

• Introduction to Code Quality

  • Importance of code quality (maintainability, readability, testability)
  • Typical quality metrics (complexity, coupling, cohesion)
  • Technical debt and its implications

• Software Craftsmanship and Clean Code

  • Fundamentals of Software Craftsmanship
  • The Software Craftsmanship Manifesto
  • Professionalism and professional ethics

• Software Entropy

  • Definition and causes
  • Indicators (smells) of software entropy

• What Is Software Architecture?

  • Architecture in the small vs. architecture in the large
  • Difference between “Design” and “design” (strategic vs. tactical)
  • The role of architecture as a link between requirements and implementation

• Architectural Representation and Views

  • Communication and documentation purposes
  • Block diagrams vs. UML
  • The 4+1 architecture view model (Logical, Process, Development, Physical View + User)

• Architecture Design Principles

  • Separation of Concerns, SOLID, KISS, YAGNI
  • Clean Architecture, modularity, abstraction
  • Dependency Injection & Inversion of Control
  • Maintainability, flexibility, and testability as architecture goals

Day 2: Modern Approaches & Professional Practices

• Architecture Patterns

  • Layered architecture
  • Client/Server, Peer-to-Peer, Master/Slave
  • Repository, CQRS, Event Bus, Message Queue

• Standard Architectures

  • Model-View-Controller (MVC)
  • Service-Oriented Architecture (SOA, Microservices)
  • Hexagonal Architecture (Ports & Adapters, Dependency Rule)

• Introduction to Software Design Patterns

  • Difference from architecture patterns and how they work together
  • Structure of a pattern (name, problem, solution, consequences)
  • Categories: Creational, Structural, Behavioral

• Testing Strategy and Test-Driven Development (TDD)

  • Red–Green–Refactor cycle
  • Unit tests and their role in code quality

• Static Code Analysis & Tooling

  • Linters and analysis tools (e.g., SonarQube, ESLint, Pylint)
  • CI/CD integration and quality gates

• Trunk-Based Development and Feature Toggles

  • Short release cycles and continuous integration
  • Using feature toggles for risk-free deployments and controlled feature rollout

• Integrating Architecture and Design Patterns

  • Combining Clean Architecture with Strategy and Repository Patterns
  • How patterns practically support principles such as SOLID and Separation of Concerns

Prerequisites

• Basic programming skills in an object-oriented programming language (preferably Python, C++, C#, or Java)
• Initial experience working with version control systems (e.g., Git)
• Basic knowledge of development and build tools (IDE, compiler, test frameworks)

Course Format

• Duration: 2 full days (8 hours each)
• Format: Instructor-led training with extensive hands-on exercises
• Class Size: Maximum 12 participants for intensive support
• Materials: Comprehensive course materials, code examples, and checklists included

Hands-on Exercises

During the course, you will work on practical projects:

1. Code Analysis: Identifying code smells and improvement suggestions
2. Refactoring Exercise: Improving legacy code
3. TDD Practice: Implementing a function with Red-Green-Refactor
4. Architecture Design: Creating a 4+1 view model for a system
5. Pattern Application: Implementing design patterns in existing code
6. Static Analysis: Setup and configuration of SonarQube/Linter
7. Feature Toggle Implementation: Practical implementation

Tools and Technologies Used

In the course, we work with:

• Programming languages: Python, Java, C#, or C++ (depending on participant preference)
• Git for version control
• SonarQube for static code analysis
• Linters: ESLint, Pylint, or similar
• Test frameworks: pytest, JUnit, NUnit
• IDE: VS Code, IntelliJ IDEA, or Visual Studio
• CI/CD tools for quality gates

Who Should Attend

• Software developers (Junior to Mid-Level)
• Backend and frontend developers
• Developers who want to improve their code quality
• Team leads who want to establish standards
• Career changers in professional software development
• Anyone who wants to learn Clean Code principles

Learning Objectives

At the end of this course, you will be able to:

• ✅ Evaluate and measure code quality
• ✅ Apply Clean Code principles
• ✅ Identify and eliminate code smells
• ✅ Understand and document software architecture
• ✅ Implement SOLID principles in practice
• ✅ Apply Test-Driven Development (TDD)
• ✅ Recognize and use common design patterns
• ✅ Utilize static code analysis tools
• ✅ Understand and manage technical debt
• ✅ Establish professional development practices

Course Materials

All participants receive:

• Comprehensive Software Craftsmanship handbook (180+ pages)
• Clean Code checklist and quick reference
• Design Patterns catalog with code examples
• SOLID Principles poster
• Architecture templates and diagram templates
• Code examples in multiple programming languages
• Access to exercise repository (60 days)
• Digital certificate of completion
• 30 days post-course email support

Certification Preparation

This course supports preparation for:

• Certified Software Development Professional (CSDP)
• iSAQB Certified Professional for Software Architecture (CPSA-F)
• Clean Code Developer Grades