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
- 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, www.tucs.fi, Dec 2002. An extended abstract was published at the International Conference on Human Computer Interaction,
- 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
Lecture 2 – Value
- 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 3 – Process
- Creating Value
- Focus on the Job
- Identify Customers
- Sustaining Value
- Seeing Waste
- Partially Done Work
- Extra Features
- Task Switching
- Writing Defective Code
- Mapping the Value Stream
Lecture 4 – People
- 5 S's
- Basic Disciplines
- Learning (Product)
- Set-Based Design
- A3 Documents
- Improvement (Process)
- Pareto Analysis
Lecture 5 – Pipeline
- Chief Engineer
- Shared Leadership
- Team of Experts
- Shared Approach
- Responsibility-Based Planning ∧ Control
- Self-Organizing Teams
- Visible Workspace
- Custom Software
- Software Products
- Distributed Teams
- Large Systems
Lecture 6 – Measurement
- Cycle Time
- Measure UP
- Business Case
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: http://www.whyprogramsfail.com/
- 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: http://www.st.cs.uni-sb.de/softevo/
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.
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.
- 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
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.