Matthias Felleisen

© 2024 Matthias Felleisen This material is copyrighted and provided under the Creative Commons CC BY-NC-ND license [interpretation].

    Prelude

        Developing a Mind Set

        The Context, for the Instructor

        This Book and Its Parts

        Dear Instructor:

        Acknowledgments

    I Perspective

      1 The Death of Software, The Life of Software

      2 Are You Socially Responsible?

    II Principles

      3 The Nature of Software Development

      4 Egoless Programming

      5 Pair Programming

      6 Software Inspections

    III Project

      7 Running a Software Systems

      8 Developing a Complete Software System

        8.1 Ways to Proceed

        8.2 Analysis: Understanding the Project’s Purpose and Context

        8.3 Synthesis: Discovering Components

        8.4 Planning: How the Construction Proceeds

      9 Software Architecture

        9.1 Pipelines

        9.2 Model, View, Controller

        9.3 Client, Server

      10 A Sample Project: Analysis, Discovery, Planning

        10.1 Core Idea

        10.2 Context Analysis

        10.3 Component Discovery

        10.4 Construction Plan

      11 Inspecting the Plan

      12 Why Inspections Matter Even If There is No Code

        12.1 Documents: Start the README, Before the Coding Begins

    IV Programming Interfaces

      13 The Nature of Interfaces

        13.1 An Interface is the Common Ontology for Clients and Server

      14 Encapsulation via Interfaces

        14.1 Interface Inspections for Encapsulation

        14.2 Encapsulating Properly

      15 Designing an Interface

        15.1 Inspecting Simple Interface Designs

      16 Expressing an Interface

      17 Interface Inspections, Systematically

        17.1 Inspections and Design Alternatives

    V Programming Basics

      18 Clarity of Code

      19 Comments are Needed in a Small Number of Places

      20 The Very Basics

        20.1 Names Matter

        20.2 The Size of Functions and Methods

        20.3 A Short Note on Conditionals and Loops

      21 Code Inspections, the Basics

        21.1 Inspecting Code for Coding Flaws

        21.2 A Code Inspection Memo

        21.3 Reacting to a Code Inspection

        21.4 Inspecting Code for Errors and Test Coverage Problems

        21.5 Pushing Back During a Code Inspection

        21.6 Inspecting Code for Design Mistakes

      22 Systematic Design, the Basics

        22.1 Developing Data Representations for Information

          22.1.1 Information that is Considered Atomic

          22.1.2 Structured Information: Don’t Use Strings to Represent It

          22.1.3 Structured Information: Use Structs, Records, Objects

          22.1.4 From Information to Data Representations, And Back

          22.1.5 From Information to Classes via Doodling

          22.1.6 Choosing from Several Alternatives

        22.2 Developing Data Representations for Composition

        22.3 Methods vs Functions

        22.4 Designing Functions, Systematically

        22.5 Atomic vs Composite: A Tiny Case Study

        22.6 Designing Methods, Systematically

          22.6.1 Favor Functions, Favor Immutability

        22.7 A Second Look at the Tiny Case Study

        22.8 Why Systematic Design is Socially Responsible

      23 Code Inspections, Systematically

        23.1 The Labyrinth Game: A Problem Statement

        23.2 Presenting Systematically Designed Code

        23.3 Inspecting Systematically Designed Code

        23.4 A General Guide to Code Inspections

          23.4.1 README Files

          23.4.2 Presenting

          23.4.3 Inspecting

    Postlude

        Onward

        AI

        A Mindset for Life