Software Engineering

Prof. Dr. Mirco Schoenfeld

software crisis

The major cause of the software crisis is that the machines have become several orders of magnitude more powerful! To put it quite bluntly: as long as there were no machines, programming was no problem at all; when we had a few weak computers, programming became a mild problem, and now we have gigantic computers, programming has become an equally gigantic problem.

Edsger Dijkstra, Germany, 1972

computers in 1972

https://becker.wustl.edu/news/groundbreaking-us-china-computer-science-learning-exchange-expedition-1972/

software crisis

Back to the software crisis.

  1. Projects running over-budget
  2. Projects running over-time
  3. Software was very inefficient
  4. Software was of low quality
  5. Software often did not meet requirements
  6. Projects were unmanageable and code difficult to maintain
  7. Software was never delivered

the issue

Large software development projects generally require a team.

https://xkcd.com/2021/

small scale problem

Imagine building a house.

That involves architects, carpenters, plumbers, electricians, construction workers, etc.

large scale problem

How about building a skyscraper?

Extensive requirements specification, design and planning phases, cost estimations, safety requirements, etc.

It’s your turn!

Task

Software Engineering Process

  1. What kind of software development have you experienced / can you observe in your company?
  2. To which metaphor does it relate more – to building a house or building a skyscraper?
  3. Discuss why you think that is.

Time: 15 minutes

Task Summary

What have you discussed?

a study

Study showed: 68 percent of IT projects fail. (Krigsman 2009)

Solid requirements planning establishes a clear connection between the business case, project goals, and the project outcome.

the issue

Software development going wrong is often not easy to see.

misconception

Big misconception:

Programming is not Software Engineering!

Successful software development

Successful software development requires a plan!

  1. Requirements specification (listen to the customer)
  2. Software Design (listen to the developers, organization)
  3. Implementation
  4. Testing
  5. Documentation

general aim

Aim of Software Engineering:

Find repeatable, predictable processes that
improve productivity and quality.

Software development processes

Some try to systematize or formalize
the seemingly unruly task of designing software.

Others apply project management techniques to designing software.

old world

The old world:

  • Requirements gathering
  • Planning and design
  • Development
  • Testing and quality assurance
  • Deployment
  • Maintenance and support

Waterfall

The waterfall model

(Sommerville 2011)

Waterfall

The waterfall model:

  • dates back to 1970
  • strict sequential procedure
  • early commitments, yet no change allowed
  • errors appear very late in the process.

Spiral Model

(Boehm 1988; Sommerville 2011)

Spiral Model

The Spiral model:

  • Main aim: minimizing risk
  • iterative risk analysis
  • incremental

the old world

The old world (summarized)

(Sommerville 2011)

the old world

Can you still observe one of the old models being in use?

If so, does it make sense?

the new world

The new world

(Sommerville 2011)

Agile Development

Agile Development

We are uncovering better ways of developing software by doing it and helping others do it.

(Beck et al. 2001)

Agile Development

https://agilemanifesto.org/

(Beck et al. 2001)

Agile Development

The values are based on these principles:

  1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
  2. Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
  3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
  4. Business people and developers must work together daily throughout the project.

https://agilemanifesto.org/

Agile Development

  1. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
  2. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
  3. Working software is the primary measure of progress.
  4. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

https://agilemanifesto.org/

Agile Development

  1. Continuous attention to technical excellence and good design enhances agility.
  2. Simplicity–the art of maximizing the amount of work not done–is essential.
  3. The best architectures, requirements, and designs emerge from self-organizing teams.
  4. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

https://agilemanifesto.org/

Agile Methods

Agile Development is brought to life
by agile methods, or agile practices

  • incremental and continuous delivery
  • customer involvement
  • people not process
  • embrace change
  • maintain simplicity

Agile Methods

Agile methods are most suitable for projects

  • with rapidly changing requirements
  • where working software needs to be delivered quickly
  • in which customers can be involved

It’s your turn!

Task

Agile Projects

  1. Are you working in an agile environment?
  2. What makes your environment agile? Are you following specific plays?
  3. Are agile methods working well in your context?
  4. Who are your customers and are they invovled?

Time: 20 minutes

Task Summary

Let’s hear about your thoughts!

Agile Methods

A bunch of methods exist

  • adaptive software development
  • dynamic systems development method
  • extreme programming
  • feature-driven development
  • lean software development
  • kanban
  • scrum
  • …

Agile practices

And a bunch of practices exist as well

  • backlogs
  • cross-functional team
  • daily stand-up
  • pair programming
  • scrum events
  • story-driven modeling
  • user stories
  • …

Extreme Programming

Extreme Programming

Best known and most widely used of the agile methods.

(Beck 1999)

Extreme Programming

Expectation:

XP release cycle

Reality:

https://en.wikipedia.org/wiki/Extreme_programming

XP release cycle

Extreme Programming Release Cycle

(Sommerville 2011)

Extreme?

Push iterative development to extreme levels:

For example, in XP, several new versions of a system may be developed by different programmers, integrated and tested in a day. (Sommerville 2011)

XP implementation

Extreme Programmings implementation of the agile mindset:

 

  1. Incremental Development:
  • small, frequent releases
  • requirements based on user stories
  • user stories decide what functionality is implemented

XP implementation

Extreme Programmings implementation of the agile mindset:

 

  1. Customer Involvement:
  • continuous engagement of customer in dev. team
  • customer takes part in development
  • customer is responsible for defining acceptance tests

XP implementation

Extreme Programmings implementation of the agile mindset:

 

  1. People, not process:
  • pair programming
  • collective ownership of system code
  • sustainable process, no excessively long working hours

XP implementation

Extreme Programmings implementation of the agile mindset:

 

  1. Embrace change:            
  • regular system releases to customers
  • test-first development
  • refactoring of code
  • continuous integration

XP implementation

Extreme Programmings implementation of the agile mindset:

 

  1. Maintain simplicity:
  • constant code refactoring to improve code quality
  • simple designs
  • no anticipation of future changes

XP story cards

Story cards are the main input to the XP planning process.

(Sommerville 2011)

XP tasks

Story cards are broken down into tasks, efforts are estimated, and resources are planned.

(Sommerville 2011)

XP tests

In XP, testing is absolutely crucial.

(Sommerville 2011)

Testing in XP

Test-first development
is one of the most important innovations in XP.

Testing is required
due to extensive code refactoring and shared responsibilities.

Testing in XP

Key features of testing in XP:

  • Test-first development
  • develop tests from scenarios
  • involve users/customers in test development and validation
  • use automated testing frameworks

Testing in XP

However, many automated tests not necessarily lead to thoroughly tested software:

Testing in XP

…or in other words:

  1. Programmers are lazy take shortcuts when writing tests
  2. Some tests can be very difficult to write incrementally
  3. Judging completeness of a set of tests is difficult

From Testing to Programming

To produce better code in the first place,
XP introduced another innovation: pair programming

Pair programming

Pair programming is the second important innovation in XP.

https://www.freecodecamp.org/news/want-to-be-a-developer-you-should-probably-be-pair-programming-2c6ec12c4866/

More about XP

Extreme Programming Summarized:

https://en.wikipedia.org/wiki/Extreme_programming

Agile flavors

Agile development has multiple flavors
and combinations of methods & practices.

  • DevOps
  • Lean Software Development
  • Dynamic systems development method (DSDM)
  • Kanban
  • …

Issues with agile methods

Agile development is sometimes difficult to realize

  • customers need to be willing to be involved
  • team members have to like intense involvement
  • prioritizing changes can be difficult
  • maintaing simplicity is not easy
  • organizations are sometimes too sluggish

Context-specific conflict of objectives

Issues with agile methods

More recent models for software engineering try
to overcome the before-mentioned issues of agile methods:

Making use of scientific principles

Scientific principles

Learn from data science and scientific principles (Farley 2021)!

Scientific principles

Continuous delivery is founded upon
most durable ideas from science:

  • Characterize: Make an observation of the current state.
  • Hypothesize: Create a description, a theory that may explain your observation.
  • Predict: Make a prediction based on your hypothesis.
  • Experiment: Test your prediction.

(Farley 2021)

Thanks

https://xkcd.com/1570/

References

Beck, Kent. 1999. Extreme Programming Explained: Embrace Change. addison-wesley professional.
Beck, Kent, Mike Beedle, Arie Van Bennekum, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, et al. 2001. “The Agile Manifesto.” http://agilemanifesto.org/.
Boehm, Barry W. 1988. “A Spiral Model of Software Development and Enhancement.” Computer 21 (5): 61–72.
Farley, David. 2021. Modern Software Engineering: Doing What Works to Build Better Software Faster. Addison-Wesley Professional.
Krigsman, Michael. 2009. “Study: 69 Percent of IT Projects Fail.” https://www.zdnet.com/article/study-68-percent-of-it-projects-fail/.
Sommerville, Ian. 2011. “Software Engineering.” ISBN-10 137035152.
Back to Lecture Website