Design Thinking Research

1. Program design requires continuous change and adaptation

Programming is a process of learning.

Iterative development: Software development is not a linear process of assembling predefined parts. Instead, it's an iterative journey of discovery and refinement. Programmers face ill-defined problems and evolving requirements, necessitating frequent changes to existing code. This iterative nature applies both at the macro level (client-programmer interactions) and micro level (individual coding decisions).

Co-evolution of understanding: As programmers implement features, their understanding of the problem domain deepens. This improved understanding often leads to refining or adapting previously written code. The process is cyclical:

• Implement a feature
• Gain new insights
• Revisit and modify existing code
• Repeat

2. Well-designed code facilitates future modifications and maintenance

Appropriate source code design helps in two ways: it eases the implementation of new functionality and it supports maintenance and evolution.

Modularity and abstraction: Well-designed code is modular, with clear abstractions that encapsulate specific functionalities. This approach:

• Reduces complexity by allowing focus on relevant details
• Improves code readability and comprehension
• Facilitates easier modifications and additions

Elegant solutions: Programmers strive for elegant, concise code that expresses the problem's essence. This often involves:

• Creating new programming constructs (e.g., methods, classes)
• Refining existing code structures
• Eliminating unnecessary complexity

Future-proofing: Good design anticipates future changes, making it easier for programmers (including the original author) to understand and modify the code later.

3. Changing source code involves inherent risks and potential errors

While programmers regularly make changes to their programs, changing programs always involves the risk of creating errors.

Types of risks:

• Promising ideas unexpectedly prove inappropriate
• Changes cause unintended side effects
• Code complexity is underestimated
• Multiple improvements become entangled

Consequences of errors: When errors occur, programmers often face tedious and time-consuming recovery work. This may involve:

• Manually reverting changes
• Disentangling mixed improvements
• Debugging unexpected behavior
• Re-implementing lost functionality

Cognitive challenges: The risk of errors is amplified by the cognitive demands of programming. Programmers must juggle multiple concepts, anticipate potential issues, and make decisions with incomplete information.

4. Traditional risk management relies on disciplined practices and planning

To reduce the risk of encountering such situations, literature recommends following a structured and disciplined approach and employing certain practices of work.

Best practices:

• Work on one well-defined task at a time
• Write and run tests frequently
• Use version control systems
• Make regular, small commits

Limitations of best practices:

• Require subjective judgment and interpretation
• Add mental overhead to the programming process
• Demand upfront planning and structure

Challenges in application:

• Programmers may incorrectly assess risks
• Disciplined practices are easily forgotten in creative flow
• Constant vigilance requires significant mental effort

Inevitable errors: Despite best efforts, programmers will occasionally make errors and face recovery situations. The traditional approach cannot completely eliminate this risk.

5. CoExist: A tool-based approach to encourage fearless code changes

We have developed CoExist, an extension to the programming environment Squeak/Smalltalk, to preserve previous development states and to provide immediate access to relevant information.

Key insight: The risks in programming stem from information loss during the change process. CoExist preserves this valuable information automatically.

Core features:

• Continuous background commits
• Easy access to previous versions
• Branching support
• Integrated version visualization

Benefits:

• Reduces mental overhead of manual version control
• Encourages experimentation and fearless changes
• Provides safety net for recovering from errors

Paradigm shift: CoExist moves from a discipline-based approach to a tool-supported workflow, reducing the cognitive load on programmers.

6. Continuous versioning preserves valuable development history

The basis of CoExist takes care of preserving potentially valuable information. It continuously performs commits in the background.

Automatic versioning:

• Every code change creates a new version
• Versions are stored efficiently in the background
• No manual action required from the programmer

Version bar: A timeline-like interface element provides:

• Visual representation of development history
• Quick access to previous versions
• Highlighting of versions relevant to current code

Version browser: Allows detailed exploration of version history:

• Tabular view of multiple versions
• Diff information for selected versions
• Fast scanning for elements of interest

Branching support:

• Implicitly creates branches when reverting to previous versions
• Preserves exploratory work that might prove useful later

7. Automated analysis and testing enhance code quality assessment

The versioning facilities of CoExist also allows continuously running analysis on every newly created version.

Continuous testing:

• Automatically runs tests for each new version
• Visualizes test results in the version bar
• Highlights immediate impact of changes on code quality

Extensible analysis:

• Programmers can define custom analyses (e.g., performance measurements)
• Full programmatic access to version objects
• Ability to run arbitrary code on specific versions

Benefits:

• Immediate feedback on code changes
• Early detection of regressions or issues
• Encourages maintaining high code quality throughout development

Focus on task: Automated analysis allows programmers to concentrate on their current task, knowing they can easily review the impact of changes later.