This website is about the 2006 edition of the school. Visit this year's edition of LASER.

LASER Summer School on Software Engineering

Practical Programming Processes

Past, Present, Proposed
Proven, Passable, Polemical

September 17 - 23, 2006
Elba, Italy

Directors: Bertrand Meyer (ETH Zürich), Erik Meijer (Microsoft)



Title: Incremental software construction

Speaker: Ralph Back

Description: The construction of large software systems has to be done in an incremental manner, in order to manage the complexity of these systems. We will in this lecture series concentrate on incremental software construction using the correct-by-construction paradigm, where each increment is built in such a way that it preserve the correctness of the software built thus far. Our theoretical framework will be refinement diagrams. These give us both a graphical notation and a rigorous mathematical framework for reasoning about the architecture and function of large software systems. We use this framework for describing incremental software construction on three different levels: algorithm, procedures and classes. Algorithms and procedures are constructed using invariant based programming. This allows us to build complicated algorithms in an incremental manner, such that the resulting program is correct by construction. Object oriented systems are built using stepwise feature introduction. The system is then built in thin layers, each layer introducing one new feature. Correctness is maintained by checking that the new feature is correctly implemented and that all features introduced earlier are preserved by this extension. We illustrate both these approaches with case studies. We will also describe some software tools that support these incremental construction methods. Finally, we will discuss what kind of software processes are suitable for incremental software construction. We will describe our experiences of using the above methods in the Gaudi Software Factory. This is an experimental software factory for producing reliable and maintainable software in an academic environment. The software processes used in Gaudi are based on agile practices, in particular Extreme Programming.

Further reading:  

  • Heikki Anttila, Ralph-Johan Back, Pekka Ketola, Katja Konkka, Jyrki Leskelä, and Erkki Rysä. Combining stepwise feature introduction with user-centric design. Technical Report 495, TUCS - Turku Centre for Computer Science,, Dec 2002. An extended abstract was published at the International Conference on Human Computer Interaction, Crete, 2003.
  • Ralph-Johan Back. Software construction by stepwise feature introduction. In Bowen J.P. Henson M.C. Robinson K. Bert, D., editor, ZB 2002: Formal Specification and Development in Z and B, proceedings of the 2nd International Conference of B and Z Users, LNCS, pages 162-183, Grenoble, France, January 2002. Springer Verlag. Also appeared as TUCS Technical Report 496.
  • Ralph-Johan Back, Luka Milovanov, Ivan Porres, and Viorel Preoteasa. XP as a framework for practical software engineering experiments. In Proceedings of the Agile Processes in Software Engineering (XP2002), May 2002. Also appeared as TUCS TR 451.
  • Ralph-Johan Back and Joakim von Wright. Refinement Calculus: A Systematic Introduction. Springer-Verlag, 1998.
  • Ralph-Johan Back and Joakim von Wright. Enforcing behavior with contracts. In A. McIver and C. Morgan, editors, Programming Methodology. Springer-Verlag, 2002.
  • Ralph-Johan Back and Joakim von Wright. Compositional action system refinement. Formal Aspects of Computing, 15(2):103-117, 2003.


Title: Lean software development

Speaker: Mary Poppendieck

Description: As global competitiveness comes to the software development industry, the search is on for a better way to create first-class software rapidly, repeatedly, and reliably. Lean initiatives in manufacturing, logistics, and services have led to dramatic improvements in cost, quality and delivery time; can they do the same for software development? The short answer is “Absolutely!”
Of the many methods that have arisen to improve software development, Lean is emerging as one that is grounded in decades of work understanding how to make processes better. Lean thinking focuses on giving customers what they want, when and where the want it, without a wasted motion or wasted minute.

You will learn how to:

  • Develop a value stream map for your current software development organization, and then create a new map for the future.
  • Create customer-focused value that lasts over time.
  • Reorganize the software development process around iteration cycles and implement responsibility-based planning and control.
  • Assess the state of the basic disciplines which determine a software development process capability.
  • Drive software quality by moving testing to the front and center of the development process.
  • Organize so as to most effectively deliver superb software rapidly and at minimum cost.
  • Apply queuing theory to effectively manage the software development pipeline.
  • Create a financial model for a software development project and use it to make optimal tradeoff decisions.


Lecture 1 – Overview

  • A History of Lean
  • Principles of Lean Software Development
    • Eliminate Waste
      MYTH: Early Specification Reduces Waste
    • Build Quality In
      MYTH: Do It Right The First Time
    • Amplify Learning
      MYTH: Predictions Create Predictability
    • Delay Commitment
      MYTH: Planning Is Commitment
    • Deliver Fast
      MYTH: Haste Makes Waste
    • Respect People
      MYTH: There is One Best Way
    • Optimize The Whole
      MYTH: Optimize By Decomposition
Lecture 2 – Value
  • Creating Value
    • Focus on the Job
    • Identify Customers
  • Sustaining Value
    • Complexity
    • Legacy
  • Seeing Waste
    • Partially Done Work
    • Extra Features
    • Paperwork
    • Handoffs
    • Task Switching
    • Delays
    • Writing Defective Code
  • Mapping the Value Stream
    • Preparation
    • Exercise
Lecture 3 – Process
  • Flow
    • Workcell
    • Small Batches
  • Quality
    • 5 S's
    • Standards
    • Mistake-Proofing
    • Basic Disciplines
  • Learning (Product)
    • Set-Based Design
    • Refactoring
    • A3 Documents
  • Improvement (Process)
    • Pareto Analysis
    • Experiments
    • Kaizen
Lecture 4 – People
  • Leadership
    • Chief Engineer
    • Shared Leadership
    • Team of Experts
    • Shared Approach
  • Teams
    • Expertise
    • Engagement
    • Responsibility-Based Planning ∧ Control
    • Self-Organizing Teams
  • Visible Workspace
    • Kanban
    • Andon
    • Score
  • Organization
    • Custom Software
    • Software Products
    • Distributed Teams
    • Large Systems
Lecture 5 – Pipeline
  • Speed
  • Utilization
  • Cycle Time
  • Pull
Lecture 6 – Measurement
  • Measure UP
  • Business Case
    • P ∧ L
    • ROI
    • Non-Profit
  • Incentives
    • Compensation
    • Contracts


Title: Mining programs and processes

Speaker: Andreas Zeller


  • Mining Programs

    A program fails. How can we locate the cause? A new generation of program analysis techniques automatically determines failure causes - in the input, in the set of code changes, or in the program state.

    In contrast to "classical" static analysis, these new techniques exploit the data from multiple concrete runs - and may even generate further runs as needed. In this lecture, we explore the state of the art in automated debugging in practice and research, using real- life case studies such as Mozilla and GCC. Finally, we discuss the current frontiers in debugging, and how future research may break them.

    More information:

  • Mining Processes

    I need to change some piece of code. What do I need to consider? Is there anything else I need to change? To answer such questions, one needs to know not only the software, but also its development process. To learn about the process, one can mine software repositories such as version archives and bug databases - and learn, for instance, which changes are correlated with each other, and better yet, which activities are correlated with success or failure.

    In this lecture, we discuss the state of the art in mining repositories, using real-life development processes from groups such as Eclipse or Microsoft Windows. Finally, we discuss the current challenges and opportunities in research.

    More Information:


Title: Software development at Microsoft: an insider's view

Speakers: Erik Meijer

Description: The Microsoft Engineering Excellence Group is chartered to help drive quality standards, best practices, and prescriptive guidance for the engineering process across Microsoft products groups. In these lectures we will delve into the details of the complete Microsoft product life cycle. We will discuss the roles and responsibilities of the three major disciplines of which product teams are composed: development, quality assurance, and program management. We will cover the whole spectrum of the process that is required to actually ship commercial software, from writing specifications, tracking and triaging bugs, the build process, working effectively within a team and across groups, identifying and managing dependencies, resolving inter-personal issues, creating test plans and test automation, to the design of security models.


Title: The object-oriented development process

Speaker: Bertrand Meyer

Description: The aim of this set of lectures is to close the gap between the best practices of software technology and those of software management. It has been a defining characteristic of management-focused software process approaches such as CMMI, lifecycle models and cost models to stay away from specific technologies. This drastically limits their effectiveness. It is possible to obtain a comprehensive methodology, covering most concrete aspects of software development, by combining these principles with explicit technology choices: seamless, incremental and reversible development; the Cluster model of the lifecycle; Design by Contract; Eiffel as the programming language.

The presentation is divided into 6 lectures as follows.

  • Lifecycle issues
    Waterfall, V-model, spiral, RUP, cluster. Role of seamlessness and reversibility. Various forms of incremental development. Agile and extreme approaches: arguments and critique.

  • CMMI
    Role, scope and limitations of capability maturity models. Where technology choices fit.

  • Design by Contract as a unifying thread through the lifecycle
    Contracts as an engineering metaphor. Application to requirements collection, specification, design, implementation, reuse, testing, maintenance. Contracts as a management tool; role in the lifecycle and in CMMI.

  • Eiffel as the vehicle
    Summary of Eiffel's main contribution to the development of quality software. Role in the various phases of the lifecycle.

  • Components and tools
    The place of reuse and component-based development in the search for an effective, quality-focused software process. Collaborative development; use of metrics, configuration management, project management tools.

  • The complete picture
    A comprehensive methodology for ensuring CMMI goals with "best practices" object-oriented techniques, components and tools.

Further reading:
  • Bertrand Meyer: Object Oriented Software Construction, second edition, Chapter 30, Prentice Hall, 1997.
  • Dennis Ahern, Aaron Clouse, Richard Turner: CMMI Distilled: A Practical Introduction to Integrated Process Improvement, Second Edition, Addison-Wesley, 2003


Title: Open source development

Speaker: Miguel de Icaza

Description: These lectures will focus on the various processes adopted by different open source efforts. Strictly speaking, open source software is software that satisfies certain licensing requirements. These requirements in most cases have lead to an opening up of the development process and also have laid down the foundation for collaboration between individual and companies.

Open source developers benefit from existing software development practices, and they have benefited, probably more than any other software project, from the popularization of the Internet to reach like-minded developers.

We will discuss the methodologies, practices used by different open source projects, their design process, how they with change, integrate innovation and evolve the software.

Although the licensing provides the foundation on which open source is built, people are the glue that binds a project together, we will look at how people interact, manage, direct and administer the project. Open source's nature also raise issues typically not found in proprietary software: governance and conflict resolution.



Chair of Software Engineering - ETH Zürich Last update: 13.09.2006