Summary of "ICSE 2015 - Grady Booch Keynote"

Summary of ICSE 2015 - Grady Booch Keynote

Main Ideas and Concepts:

Software as an Invisible Thread: Software is the intangible force that animates hardware, much like a loom weaves fabric. Developing software is a complex, evolving process akin to raising children, managing cities, producing films, or even making art.
Historical Evolution of Software Engineering:
- Early computing was hardware-centric; "computers" were often women performing calculations manually.
- Transition from manual computation to mechanized and then digital computing (e.g., Harvard Mark 1, Colossus, ENIAC).
- Emergence of programming languages (Assembly, Fortran, COBOL), operating systems, and separation of software from hardware.
- Rise of the "programming priesthood" where programmers were intermediaries between users and machines.
- Development of methodologies like Waterfall, Agile, and structured programming to manage complexity and cost.
- Shift from numeric to symbolic computation, then to simulations ("mirror worlds"), and finally to personal computing.
- Networking and the Internet introduced new challenges: distributed systems, reliability, and complexity.
- Cloud computing and microservices architectures represent current dominant paradigms.
- Emergence of platforms (e.g., Facebook, Amazon) and APIs as dominant design patterns.
- Increasing personalization and cognitive capabilities in devices, including human-computer integration (prosthetics, AI assistants).
Software Engineering Principles:
- Abstraction: Increasing levels of abstraction are key to managing complexity.
- Separation of Concerns: Loosely coupled components enable reuse and flexibility.
- Information Hiding: Protecting internal details to reduce complexity.
- Simplicity: Continuous refactoring and simplification are vital for maintainability.
Legacy and Software Lifecycle:
- Software has a lifecycle with discovery, invention, and implementation phases.
- Legacy systems (e.g., IRS tax system in Assembly) illustrate challenges of maintaining and evolving old code.
- Agile methods need adaptation depending on domain, risk, and scale.
Challenges in Modern Software Engineering:
- Balancing formality, risk, and scale in methodologies.
- Managing teams of teams and scaling Agile.
- Handling legacy code and systems of systems.
- Addressing human and organizational factors, which are often more critical than technical issues.
- The rise of non-programmers building software (scientists, domain experts) necessitates new languages and tools.
- Tooling should focus on reducing developer friction and improving team productivity.
- Ethical and moral responsibilities of software developers due to societal impact.
Future Directions and Calls to Action:
- Need for new languages that empower non-programmers without repeating past mistakes.
- Research and innovation in tooling, especially for team collaboration.
- Developing best practices for systems of systems, especially with unreliable components.
- Handling cognitive and AI-driven systems, including debugging and coexisting with intelligent assistants.
- Exploring higher-level languages for neural networks and quantum computing.
- Recognizing software’s profound role in shaping civilization and the responsibility that entails.
Notable Metaphors and Observations:
- Software is the "invisible writing" that tells stories to hardware.
- Computing is woven on the "loom of sorrow," reflecting its roots in wartime innovation.
- The human becomes the computer, and the computer increasingly mimics human traits.
- Dominant designs and platforms shape software ecosystems.
- Software engineering is as much about managing humans as it is about technology.

Detailed Methodology / Instructions / Lessons

Historical Understanding: Study the evolution of software engineering to understand current practices and anticipate future challenges.
Core Engineering Principles:
- Emphasize abstraction, separation of concerns, information hiding, and simplicity.
- Invest in continuous refactoring (~10% of development effort recommended).
- Adapt methodologies to project risk, scale, and domain context.
Managing Legacy Systems:
- Recognize legacy code’s subtle dependencies and user adaptations.
- Stabilize release cycles and build systems before attempting refactoring.
- Accept that some legacy code (e.g., IRS Assembly) may be nearly impossible to replace quickly.
Team and Organizational Dynamics:
- Understand that software engineering is a human problem as much as a technical one.
- Foster communication and collaboration across distributed teams.
- Scale Agile thoughtfully, mixing methodologies as needed.
Tooling and Productivity:
- Focus on reducing developer friction rather than just adding features.
- Study real developer workflows and optimize tooling accordingly.
Language and Accessibility:
- Support non-programmers with accessible languages and computational thinking education.
- Avoid repeating mistakes of past “easy” languages like Visual Basic.
Systems of Systems and Reliability:
- Develop practices for building systems where components are unreliable.