One size does not fit all
There is a growing recognition of the value of teaching software engineering at undergraduate level for those wishing to develop software professionally. McDermid sets out the case for making such courses domain specific, arguing that the knowledge and skills needed for developing and managing systems, such as embedded control and office automation systems, are very different.
The term ‘software engineering’ was first coined in the late 1960s, albeit more as an aspiration or challenge than from the view that this was an established engineering discipline. Some 35 years later there have been many technical advances with some very impressive projects delivering on time and meeting customer expectations. However, as noted by the recent report The Challenges of Complex IT Projects produced by the Royal Academy of Engineering and the BCS (April 2004), too many software-intensive IT projects still fail.
One of the reasons for project failures is that developers often do not apply best practice. This is both a management and an educational issue. The focus in this article is on the educational perspective. Most people entering the profession with relevant academic qualifications were taught in a computer science (CS) department; however, there is a growing recognition of the need to teach software engineering (SE), not CS, to those wishing to develop software professionally. This is reflected in work on model curricula.
These curricula should cover what software engineers need to know in order to practice professionally and effectively in so far as it can be taught. The first question is what are the key aspects of successful projects?
CCSE: Computing curricula for software engineering
CS: Computer science
SE: Software engineering
UML: Unified modelling language
V&V: Verification and validation
What do software engineers need to know?
Software engineers need to understand key aspects of CS. The analogy is with the need for understanding physics in the ‘physical’ engineering disciplines such as mechanical engineering and electronics. Beyond this, they need knowledge and skills in five areas, giving six strands for any course:
- computer science
- good practice>
- domain knowledge
- soft skills.
Software is an intellectual artefact. Producing software is essentially a ‘pure design’ activity. The core of what software engineers need to know is how to design software systems and how to tell good designs from bad. Often this involves understanding the non-functional properties of the design; for example, will it perform fast enough to process all the data? Will it be secure (against anticipated attacks)? Will it manage hardware failures to preserve system safety? And will it be useable by the general public?
All engineers should use good practice, but this is sadly all too rare in SE. According to Fred Brooks, ‘in no other discipline is the gulf between typical practice and best practice so large’. Good practice is not static; indeed, technology moves apace. However, not all the new technology is useful or stands the test of time. Software engineers need to understand principles so they can assimilate new practices and, to some degree, sort out the genuine advances from the ‘mere fads’.
Software engineers also need domain knowledge. Programs have a role in the world, either as the control and monitoring element in some embedded system (for example, in an aircraft engine controller) or as a key enabler in a business or organisation (for example, providing electronic access to patient health records). Most requirements for software systems are incorrect. The users or procurers do not fully understand what they want, and also do not write down what is obvious – at least to them. To defend against this, and produce something useful and useable, software engineers need to understand the application domain to validate and complete requirements. It is not normally possible for software engineers to gain domain knowledge in many disparate areas. There is simply too much to understand to be an expert in every area, such as car braking system design and online retailing. Software may be ubiquitous but the domain knowledge is not.
This is why ‘one size does not fit all’. Software engineers must obtain domain knowledge to work effectively – knowledge of the computer (science) is necessary, but not sufficient, to work effectively in a given domain.
Modern software systems are amongst the most complex artefacts produced by mankind. Traditional engineering distinguishes repeat design (making something very similar to what was produced before) from novel design (producing something that is largely unprecedented). Most software projects involve novel design. This is one of the reasons why traditional engineering management methods based on gated processes do not transfer well to software. Management strategies for dealing with uncertainty, such as incremental development and approaches to software (project) risk management are keys to success.
Software engineers may spend much of their day working with computers but they need to communicate with other stakeholders. They need to write manuals or online help from the user’s perspective not from an internal (design) perspective. They have to work in teams with other software engineers to solve problems of scale. Soft skills are therefore crucial to project success.
What can be taught?
Can these six areas be taught in undergraduate courses to produce an effective SE course? It is not easy for several reasons. First, the subject is intrinsically multi-disciplinary. Second, it is difficult to communicate the problems of large-scale software development and solutions to these problems without being able to experience them first hand. Third, it is hard to teach design. Many would argue that good designers are born, or learn through experience – not taught.
Nonetheless, I believe it can be taught but at varying degrees across these six areas. We start by considering these topics in detail.
Computer science (CS)
Software engineers need to understand how computers and programs work, as well as other key issues including language theory, as many programs parse or otherwise interpret languages. This material is well-understood, and widely taught. This area should not present a challenge to those wishing to produce an undergraduate SE course based on the principles discussed here.
A key element of design is software system architecture, which I view as defining system components, their interfaces, interactions and properties. A good architecture will allow properties of the finished system to be predicted (with some accuracy) before it is implemented. It will also be sufficiently rich to enable the components to be developed independently then integrated with the minimum of surprise.
But design is much more. Real designs involve trade-offs of, for example, performance versus robustness, and are constrained by factors such as the need for upwards compatibility with legacy systems, the need to comply with standards and the need to conform with data protection legislation.
Architecture and design approaches vary significantly between systems. Repeat design opens up the possibility of employing re-use and product lines, whilst novel design requires flexibility, ease of change, and more iterative development.
Can this be taught? Yes, but it is much harder than with the core CS. One strategy is to borrow the ‘case study’ approach from business schools. Another is to use carefully constructed and designed projects. It would probably be helpful to use both in any course.
Methods for developing computer systems evolve rapidly so it is important to teach lasting principles, not just specific methods. Best practice covers both the constructive aspects of software development and verification and validation (V&V), including review and testing.
In practice, many of the principles can most readily be taught by studying particular techniques, comparing and contrasting their strengths and weaknesses. However, there are particular principles, such as Cleanroom and Problem Frames, which deserve specific treatment.
Many courses cover requirements and design, and teach methods such as unified modelling language (UML) and use cases. However, there are many fads and often courses teach ‘the latest’ methods even though they are not always a step forward. Also, many of the principles date back to the 1960s. In some cases this is frowned on by students who ‘didn’t come to university to do this old stuff’. V&V is not as well covered in university courses as it deserves, but this can be rectified. Principles behind methods and comparison of methods (true methodology) are rarely taught.
Although this can be done, it is a significant shift from current practice – more so than might be apparent from looking at course syllabi.
The domain comprises what is outside the computer – the engineered system or the organisation that the computer and software support. However, there are often particular techniques used within the computer system, or its development process, that also need considering. Specifically, these include:
design and assessment methods
typical architectural styles or properties
The analogy here is with other engineering disciplines. For example, an electronic engineering degree might discuss radio design, which covers high frequency models of transistors and classical types of receiver circuits. It might also cover power supplies ranging from simple traditional designs through switched mode and explain the advantages and disadvantages of each. The same is needed for software.
What might be taught is illustrated in Table 1 using fairly broad domains.
The focus in this area is on project management and covers topics such as planning, scheduling and resource estimation.
Most software development projects are constrained. A banking system, for instance, may have a strong imperative to meet a given date (a bank holiday weekend!) to ‘roll over’ from an existing system to the new one. For an embedded safety critical system, the timescales of the embedding system, such as engine certification and aircraft in-service dates, drive the programme. Management has to plan, monitor and control projects whilst respecting these constraints.
Software projects are also highly dynamic, responding to frequent changes in requirements and, in some cases, producing new software builds every day. Classical project management approaches such as waterfall or V models might work for repeat design, but aren’t effective for the majority of projects.
However, more modern practices involve explicit models of iteration and evolution that are more appropriate for novel design. Software engineers need to understand risk management, and the specific risks and remedies that arise in software projects. They also need to understand the pitfalls of software development:
Adding more people to a late project will make it later (the existing staff spend much of their time explaining the project, so productivity falls).
Measuring effort will not accurately indicate the progress of projects (delivered end-user functionality is a better measure).
Management also needs to cover so-called ‘maintenance’ (modifying and updating existing systems) as this is where the majority of software engineers are employed.
The ‘mechanics’ (Gantt and slip charts) can be taught readily. The other material is harder to get across as an intellectual discipline without the support of real-world experience. A possible strategy would be to use case studies, preferably presented by industry, together with projects undertaken by the students themselves.
Some of the soft skills, such as technical writing and presentation skills, can be taught without difficulty. Many Universities address these issues and cover the other topics needed to meet the accreditation requirements. Other soft skills, the ability to work in teams and collaborate with customers are generally difficult to teach but can be learnt through experience. Most universities use team software projects to address these issues and I would view Sheffield’s Software Observatory as perhaps the leading example of good practice in this area. Soft skills can therefore be encompassed and learnt, if not taught.
What is in the model curricula?
The most directly relevant material is the Computing Curricula for Software Engineering (CCSE). This is part of a wider project led by the ACM and IEEE to define a set of (related) computing curricula. Although led from the USA, the work on the CCSE has been international, involving academics from the UK and Japan.
The CCSE covers the computer science elements and ‘best practice’ areas outlined above and addresses some of the soft skills. It also addresses process issues and aspects of management, albeit in a limited way. Some of this is sound, but it is a missed opportunity to ‘shape the discipline’.
The CCSE does not address application domains. It discusses how SE might be taught in an engineering department but misses the opportunity to address the knowledge needed in engineering domains. Further, it does not have the focus on architectures and products that are central to a software engineer’s education – it has a ‘one size fits all’ flavour.
In the 1990s Dave Parnas defined a detailed curriculum for software engineering with a very strong engineering basis. He was instrumental in setting up a course at McMaster in Canada, although it has since evolved from his original model. This course is perhaps closest to the form set out here, although it did not consider non-engineering application domains. Parnas’ ideas have much to commend them and some of the identified modules such as ‘Communication skills – explaining software’ deserve a place in any software engineering course.
Whilst the detail is not provided here, there is evidence that the ideas outlined can be turned into workable curricula, as illustrated by Parnas’ work at McMaster.
What are the problems?
The biggest problems involve limitations on the skills and knowledge in university CS departments. Whilst there are exceptions, few academics in CS departments have enough knowledge outside computing to teach the non-computing applications.
Also, surprisingly few have the experience of large-scale software development needed to address the management issues credibly. Collaboration with engineering, other departments (e.g. law) and with industry could address these problems. There is likely to be mutual benefit from such collaboration, such as giving an interesting perspective for classical engineering degrees, and helping companies with recruitment.
Another major problem is that this requires a cultural shift in university CS departments and one that takes them away from their comfort zones. Even those who are broadly supportive might say this should be done in a postgraduate course or to undertake it in the last year of an MEng after a CS course. However, there are reasons for thinking that this view is misguided. We do not teach students physics for three years then say ‘now do a mechanical engineering conversion in your fourth year’. The nature of engineering and science teaching is different and the transition is not easy.
As a case in point, the University of York teaches an MSc in Safety Critical Systems Engineering (SCSE). This is taught largely to industrial staff who attend one-week modules on a part-time basis. This MSc adopts an engineering approach emphasising principles, using case studies and small group exercises. Some of these modules have been shared with fourth year undergraduates. Generally, the industrial students are very positive about the courses, but the undergraduates are not. Undergraduates have become used to a more scientific approach where many of the problems they deal with are closed. Almost all of what is taught on the SCSE MSc is open-ended. This strengthens the view that we need to get across an engineering ethos much earlier, not as a final year option.
Another perceived problem might be that the proposed outlined here would be a major upheaval for CS departments but still fail to produce the fully rounded professionals that the industry needs. Inevitably this would be right; but this is true of any engineering education. It is expected that an undergraduate SE course as outlined would reduce the gap between what is taught and what is needed. IBM Hursley has an induction programme for new employees lasting around 18 months. It is anticipated that graduates of a degree course based on the principles set out above would need a much shorter induction, although it would never be eliminated as there are always company-specific practices that an employer will need to communicate. Of course the field is fast moving so CPD will remain essential, as in other fields. A course emphasising principles will hopefully better equip software engineers for this than one that teaches just CS or current methods.
Will it happen?
Given the problems of culture shift alluded to above, implementation is unlikely to happen without outside stimulus to university CS departments. This stimulus has to come, at least in part, from industry. This is what the Academy’s report The Challenges of Complex IT Projects recommended and hopefully this article might help clarify what was intended.
There is a further factor. There has been a dramatic reduction in applications to university CS departments. Nationally, applications have gone down by about 50 per cent over the last three years. This might be a reaction to the downturn in industry, or perhaps a deeper problem. Computers are now ubiquitous, much of what is taught in schools does not give a positive view of what it would be like to work as a computing professional, so perhaps the ‘glamour’ has gone. This decline in applications has afflicted other disciplines and some have responded by considering application domains. For example, there are now courses on sports science that include materials science but might consider its application to the design of tennis rackets. Perhaps computing needs to follow this model. It might be that courses on automotive software engineering, software engineering for e-business, and so on, would have greater attraction and could reverse the decline in applications to study CS.
Thanks are due to Michael Jackson and Dave Parnas who have strongly influenced my thinking, and to Ian Nussey for encouraging me to write this article.
An extended version of this article and a full reference list can be found at: http://www.cs.york.ac.uk/hise/pub/TailoringSoftwareEngineeringEducation.pdf. A copy of the Royal Academy of Engineering’s report on The Challenges of Complex IT Projects can be downloaded from http://www.raeng.org.uk/policy/reports/
Professor of Software Engineering, University of York
John McDermid has been Professor of Software Engineering at the University of York since 1987. He leads a large research group studying safety critical systems and software, and has strong links with the aerospace industry, especially BAE SYSTEMS and Rolls-Royce. He was one of the study team that produced the Royal Academy of Engineering and BCS report The Challenges of Complex IT Projects.