©1997 IEEE. Personal use of this material is permitted. However,
permission to reprint/republish this material for advertising or
promotional purposes or for creating new collective works for resale or
redistribution to servers or lists, or to reuse any copyrighted component
of this work in other works must be obtained from the
IEEE.
Abstract -
Interactions with industry hiring new software engineers from
undergraduate computer science and engineering programs show, case after
case, that universities do not pay enough attention to practical
aspects of software development. Another well-known deficiency of the
undergraduate programs is in the area of time-critical, reactive
programming. The present paper describes a senior course in a computer
science undergraduate program designed to address some of the above
problems. The real-time course provides the students not only with the
basic concepts of real-time programming, but also provides a vehicle for
development of small class projects which address methods, tools, and
the critical aspects of a modern software development life cycle. The
experience with teaching the course may serve as a model for similar
offerings in other computer science, computer engineering, and software
engineering college programs. The paper describes lessons learned and
future plans.
Incorporating software engineering methodologies into an undergraduate computer science program is critical for the future of the software industry. There are quite a few undergraduate programs offering a real-time systems course. The definition of real-time computing is very broad and covers a diverse spectrum of activities. A real-time course may be an academic chalk and blackboard discussion and analysis of the existing systems (covering everything from avionics instrumentation software to a multiuser airline reservation system). When a course is more practically oriented, often when offered in a school of engineering, it may concentrate on implementation of sensor-based computing and process control. Some computer science and engineering programs may focus on scheduling analysis and design of operating system elements. Others would focus on low-level programming and on writing time critical device handlers. A variety of earlier papers and recent discussion at the IEEE Workshop on Real-Time Systems Education [Zobe88, Hala90, McCo91, Schu92, Zale93, Schw96, Shaw96, Jack96, Goom96, Shep96] prove that there is a wide range of undergraduate real-time course offerings and there is no single accepted standard for describing their contents.
The critical observation we submit in this paper is that the development of a real-time system is an exercise in software engineering. It is widely known that real-time software developers are very often self-taught. They represent disciplines varying from electrical engineering to nuclear physics. They are frequently brilliant computer hackers, real experts in low level programming and operating system details, and wizards of non-standard device interfacing. Too often, however, they do not follow the methodology and established paradigm of the software engineering discipline. Historically, the real-time, embedded systems were small enough for a single developer to work on the entire application. This is not the case in the modern industrial world, where various subsystems of a large time-critical system need to be coupled and synchronized.
There are a number of journal articles and textbooks that offer information and guidance about real-time systems. An extensive bibliography of the subject can be found in [Zale96]. However, these materials do not provide the structure, the consistency, and the completeness in approach necessary to expose the student to the entire well-defined process of real-time system development. Students cannot rely on much personal experience in the development of real-time software, particularly in a team environment. Also, the limited time for development and the part-time nature of undergraduate student work call for a more structured, pre-defined and disciplined process than in a conventional work place. The approach introduced in our undergraduate curriculum, and in particular the presented implementation of the real-time systems class, is an attempt to address these concerns.
The paper describes the status of the real-time component in the undergraduate computer science/engineering curriculum and comments on the software engineering aspects of the course offering. We discuss the implementation of the course in the last few years and the lessons learned.
In ACM/IEEE-CS "Computing Curricula 1991" [Tuck91], the
computer discipline is divided into nine subject areas. Each subject area, in turn, is divided into
several knowledge units, further subdivided into lecture topics. The topics related to real-time systems are
treated marginally as a knowledge unit within the operating systems subject area. In the practical
implementation most of the programs consider real-time systems as an equivalent of operating
systems (and justifiably so, considering the theoretical underpinning and the basic concepts of
concurrency, task scheduling, interprocess communications, etc.). In some electronics, control, and
computer engineering programs a real-time course is treated as equivalent to an interfacing class,
discussing non-standard input/output, device drivers, and simple computer-based control applications.
A complete and comprehensive picture of a real-time system knowledge unit must include
elements of all four real-time layers [Zale94]:
The specification and design layer describes the initial software development life cycle phases
commencing with the requirements collection and progressing through the early design. The
implementation layer takes the next step through language constructs, detailed design, and testing
(including system prototyping and cross-compiling). The kernel layer introduces specific features
of real-time kernels and practical implementation of the system within the hard real-time constraints.
The hardware architecture layer gets to the hardware level, including downloading to the target
systems, debugging, and analyzing timing effectiveness of the system.
Not too many computer science/engineering programs can provide a course (or a sequence
of courses) covering all these aspects. The most important reason is lack of necessary resources. To
cover and explore the material properly it is required to have a well-equipped laboratory with elements
of the four above mentioned real-time layers. Another important obstacle is lack of manpower. Real-time systems require unique faculty multi-disciplinary expertise covering elements of software
engineering, computer science, computer engineering, and often electrical and control engineering.
A well-established expert in one area often lacks background in the other, producing a one-sided
curriculum biased toward either computer science (operating systems) or electrical engineering
(interfacing and control issues). The solution is to promote more interdisciplinary co-operation and
encourage faculty to cross-teach outside their native departments.
We submit here that the basic tenet of a real-time system class, in a computer
science/engineering program, is the development of interactive and time-critical software. Assuming
this approach the real-time class must rely on the discipline of software engineering and discuss the
critical elements of the software development life-cycle, concentrating on elements critical in real-time
applications. Keeping this as the starting point we developed an undergraduate course structure to be
used as an example offering in the real-time knowledge unit.
There is a consensus that the software engineering discipline is required in
development of any software, regardless of the application. The issues of maintanability,
expandability, and reliability are of primary importance. These issues are particularly important in
development of time-critical and reactive software. Such real-time software is used often in
safety-critical applications where the margin for errors is really narrow (e.g.: aircraft avionics, space
shuttle controls, air traffic control, medical equipment, nuclear power stations, etc.). Therefore, it is
critical to indoctrinate future software developers with the importance of using good software
engineering: starting from a requirement and specification document, through design, implementation,
testing, and maintenance.
It is also important for the software developers to pay attention to their development process.
Keeping track of their activities and recording time spend on the project is the first step in establishing
the personal software process. Collecting data on time, number of defects, size of the code (both
planned and actual) allows the individual to establish a base for the future improvement of the
personal process. This leads subsequently to establishing proper institutional processes and eventually
a higher capability maturity level.
On the other hand, real-time system development has its particularities and there is
room for some rapid prototyping and low level unit testing before the actual design takes place.
Lots of practitioners admit that real-time software development is a place of both: an orderly
top-down design as well as occasional elements of bottom-up prototyping and implementation of
low-level hardware specific interface details. Such an approach is often termed "sandwich
development".
The undergraduate computer science curriculum [Hilb95] places emphasis on software
engineering. The students begin with a three course sequence (an introduction to programming and
computer science, an introduction to data structures, a course in advanced data structures and
algorithms) that uses the Ada programming language and emphasizes principles of software
engineering (separation of specification and implementation, modular design, information hiding,
reusability, design for maintenance, etc.). The students are required to follow a simplified version of the
Watts Humphrey Personal Software Process [Hump95]. In the freshman year, they take two
computer organization courses (covering the fundamentals of digital logic, computer organization,
assembly language, and interfacing). In the senior
Real-Time Systems class, Ada tasking allows for
an easy implementation of concurrency and interprocess communication on the language level. It is
critical that future industrial application system developers have hands-on experience not only
with the basic Ada syntax, but also with tasking, operating systems interactions, and low-level
programming.
Ada is a modern programming language designed to support sound software engineering
principles and practices. An excellent exposure to the language can be started from the
Ada Web Server (https://www.adahome.com)
edited by Magnus Kempe. Quoting from Guerby
[Guer96] :
"Modern society is becoming very dependent upon software. Our transport systems, financial
systems, medical systems and defense systems all depend to a very large degree upon software.
As a consequence the safety of many human lives and much property now depends upon the
reliable functioning of software. Moreover, the fall in the cost of hardware has now made
possible the development of large software systems. Ada is a programming language of special
value in the development of large programs which must work reliably. This applies to most
defense applications (from which background Ada evolved) and extends to many application
domains."
The objective of the real-time systems senior undergraduate course, offered for the computer
science majors, is to have students:
As part of the class requirements students are developing significant elements of the software
life cycle for a real-time system. The system implementation is in a workstation environment
(currently IBM RS6000) using PowerAda with multitasking capabilities and real-time system
support. The
Embry Riddle computing facilities operate a network of over fifty UNIX/AIX workstations
with three servers and a wide variety of software tools including compilers, debuggers, CASE tools,
GUI builders, etc.
The course introduces the concepts of real-time systems from the user and the designer
viewpoints. It explores the connection of external processes to a computer by means of hardware and
software interfaces. The structure, programming, and basic properties of real-time systems are
described with an overview of the system software. Such related topics as interrupts, concurrent task
scheduling and synchronization, sharing resources, and reliability factors are discussed.
The early part of the class focuses on discussing theory and building necessary skills. The
material includes real-time design and programming concepts, with a review of software engineering
notation and discussion of the practical aspects of concurrent processing, timing, scheduling, and
intertask communication. In this phase of the course, several
individual assignments build skills
in using Ada for software module building. Attention is initially focused on exception handling,
modularization, information hiding, and reliability. The subsequent assignments deal with
concurrency, intertask communication, resource contention, and timing. To support asynchronous
learning, most of the class materials
are available on the World Wide Web.
In the past, the available laboratory resources allowed us to offer the real-time class only
within the constraints of "soft" real-time [Korn93]. Instruction was limited to the first two
real-time layers (specification/design and language concepts). The implementation platform was
a network of UNIX workstations with scaffolding software that simulated external sources of data
and interrupts. The course has been offered, on average, once each year since 1989. Initially, the student
teams worked on a semester-long project divided into three to four phases, each with separate
deliverables. The final project report compiled the results of the preliminary phases. An integral part
of the project is always a prototype demonstration and a formal project presentation by the
development team. The project was divided into three phases of about four weeks each. Each phase
had pre-defined tasks and deliverables. To keep track of the process, the students were requested
to submit logs of their project activities and records of their meetings and co-operative work. The results for each
phase were discussed and the necessary revisions were requested.
Phase One: Requirements
Task a - Narrative description of the entire system and the environment
Task b - System Context Diagram
Task c - Description of the system functionality
Task d - State Transition Diagram detailing the timing behavior
Task e - Event List and a discussion of timing requirements
Task f - Data/Control Flow Diagrams detailing information flows
Phase Two: Design
Task g - Process/Control Specifications
Task h - Data Dictionary identifying the data shared by the subsystems
Task i - Identification of interfacing processes and data exchange paradigm
Task j - Ada Task Graph and packaging decisions
Phase Three: Implementation
Task k - Listing of Ada code, including specifications, bodies, and interfaces
Task l - Description of the hardware/software base used for project implementation
Task m - Test plan for the prototype
Task n - Class presentation and demonstration of working prototype
The final week was spent on report editing (including revised deliverables from the past
work), code testing, and final project integration. The grading was based on the reports from each
of the phases, the final report, and the project demonstration. Additionally, the instructor requested,
from each team member, a confidential e-mail evaluation of the project in terms of individual
contribution of the team members. The student teams coordinated their work though classroom
discussions, meetings, and a documentation exchange (also on e-mail). They used a formal software
engineering approach for a real-time system based on the works of Ward/Mellor, Hatley/Pirbhai,
Gooma, and Nielsen/Shumate [Ward86, Hatl88, Burn89, Niel90, Cool91, Shum92, Goom93,
Edwa93, Sand94].
In the last two course offerings we introduced
individual programming assignments dealing
with the critical issues of real-time programming (exception handling, concurrency, intertask
communication, resource contention). The
team project was assigned in the last six weeks of classes
and the teams worked from artifacts reused from the past course offerings. The
project was of
shorter duration, consisting of only two phases. The first covered specification and design tasks (a) through
(j) -- as the teams were given specific requirements, in a form of partial artifacts from tasks (a) through (f).
The second
phase covered implementation and testing tasks (k) through (m). Each team, however, after consulting
with the client (the course instructor) had to prepare an updated version of consistent artifacts in the
form of a Context Diagram, Data/Control Flow Diagrams, State Transition Diagrams, an Event List, Ada
Task Diagrams, Data Dictionaries, etc. The major part of the project focused on implementation and
testing, based on the individual programming assignments done in the earlier part of the semester.
The students also were required to collect some personal performance data.
The resulting prototypes are capable of acquiring external data and interrupts, reacting
to user input, and generating output conforming to pre-defined timing specifications. The design
allows exploration of such topics as intertask communication, resource contention, scheduling,
timing, and interface with the operating system software. The implementation language was Ada95,
with its tasking and run-time libraries fully supporting the course material. Examples of developed
projects are a dog-fight aviation video game, space shuttle launch control, AWACS radar control
panel, a reconfigurable aircraft instrument panel, monitoring airport ground traffic from a GPS feed,
etc. All of these projects were implemented in a standard UNIX environment with simple
scaffolding software
that simulated the external data (generated quasi-randomly) and interrupts (UNIX signals),
and a user interface with a standard keyboard and text-based terminal. Using the University
domain-specific resources of the Air Science Simulation Laboratory, a few groups of
students in the past years developed projects on non-standard platforms. Examples of those include:
PC-based real-time data acquisition and processing from the Kavouras weather station, Silicon
Graphics flight simulator with F15 instrument panel, and a visual display controlled from a modified
Boeing 707 flight procedure trainer [Korn95].
Several teams have used CADRE Teamwork in the initial specification and design phase,
even though using CASE tools has not been a course requirement. The overall system was
implemented as Ada95 tasking programs. Subsystems tasks were synchronized to accomplish
timely response of the control and data flows. In early development stages the students concentrated
on the software engineering concepts (abstraction, modularity, uniformity, information hiding). The
applied paradigm resulted in a design supported by the selected implementation language. As Ada
supports concurrency on the language level (multitasking), the class work facilitated the main course
objective, the exploration of principles and methods related to real-time software
development. As a detailed design of a sophisticated graphical user interface was secondary for the
course objectives, we selected a simplistic terminal package (curses on SunOS, VT100
emulator on AIX).
From the instructor perspective the major problems in the course were related to the formal
process presentation, team coordination, system interfaces, and final integration. Generally the
students had a positive attitude toward the course and the project. They generously
commented on the complexity, scope, and realistic nature of the project.
Their criticism focussed on the need for maintaining consistency
between design and implementation - pointing out deficiencies, specifically, in the software development process
definition. Also, the students who did not take the software engineering class (not required, but a
recommended pre-requisite), struggled with the
software engineering concepts
in the early project development stage.
The evident shortcoming of the course offering was limitation to only the first two real-time
layers, and thus restriction to the design of only soft real-time systems with simulated external data and events. In 1995, by
securing funding from the National Science Foundation under the Instrumentation and Laboratory
Improvement Grant, the department prepared a
laboratory infrastructure which currently allows us
to modify and expand the offering by showing the "hard" aspects of real-time software development,
as defined by the two remaining real-time layers (kernels and hardware architecture). In the
new
laboratory we installed a multiplatform
variety of networked real-time operating systems (Lynx,
QNX, VxWorks) with development tools (C/C++/MultiAda) and with target Motorola 68040
processors in standard VME boards. This set-up allows us to implement projects dealing with
cross-development, debugging, and timing analysis on a target system. The environment allows us
also to connect and intercept external data and events as well as control the external devices.
Modern software development requires an extensive knowledge of both reactive and
distributed computing, as well as a teamwork-oriented software engineering process. There is a need
to provide an environment to support such instruction. Many universities cannot provide such
an environment because they lack either a dedicated faculty or the laboratory infrastructure (or both). Potential
solution to these limitations are:
We believe that real-time computing is a critical area for the majority of industrial
applications. Our experience is that the real-time class offerings have provided, and in the future
will provide, the mix of concepts and skills essential for a successful real-time software
developer.
This work has been supported by a 1995/97 National Science Foundation Instrumentation
and Laboratory Improvement Grant. Educational support from Quantum Software and Green Hill
Systems is greatly appreciated.
Burns A., Wellings A., Real-Time Systems and Their Programming Languages, Addison-Wesley, Reading (MA), 1989.
Cooling J.E., Software Design for Real-Time Systems, International Thompson Computer Press,
London, England, 1991.
Edwards K., Real-Time Structured Methods - System Analysis, John Wiley and Sons, Chichester,
England, 1993.
Guerby L.,
Hypertext Ada 95 Rationale,
https://lglwww.epfl.ch/Ada/rat95/ , Copyright ® 1995, 1996.
Gomaa H., Software Design Methods for Concurrent and Real-Time Systems, Addison-Wesley,
Reading, Mass., 1993.
Gomaa H., Courses on Software Design methods for Concurrent Real-Time Systems, in Real-Time
Systems Education, IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 6-12.
Halang W.A. , A Curriculum for Real-Time Computer and Control Systems Engineering,
IEEE Trans. on Educ. Vol. 33, No. 2, May 1990, pp. 171-178.
Hatley D.J., I.A. Pirbhai, Strategies for Real-Time System Specification. Dorset House, New
York, 1988,
Hilburn T., Hirmanpour I., Kornecki A., The Integration of Software Engineering into a
Computer Science Curriculum, Proc. 8th SEI Conf. on Software Engineering Education, R.L.
Ibrahim, Ed., Springer-Verlag, Berlin, 1995, pp. 87-95.
Humphrey W., A Discipline for Software Engineering, Addison Wesley Publishing Co. Reading,
MA, 1995.
Jacker K.H., Real-Time Instructional Technology: Experiences with Multi-User real-Time
Systems, in Real-Time Systems Education, IEEE Computer Society Press, Los Alamitos, CA,
1996, pp. 13-19.
Kornecki A. , Global Positioning System as a Real-Time Software Engineering Project in an
Undergraduate CS Curriculum, Proc. Conf. Software Engineering Research in Florida, SERF'93,
R. Guha, Ed., Orlando, FL, 1993, pp. 126-129.
Kornecki A., Zalewski J., Projects for Real-Time Systems Classes, in Real-Time Systems
Education, IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 80-89.
McCormick J.W., A Laboratory for Teaching the Development of Real-Time Software Systems,
SIGCSE Bulletin, Vol. 23, No. 1, March 1991, pp. 260-264.
Nielsen K., Ada in Distributed Real-Time Systems. Mc Graw-Hill, New York, 1990.
Sanden B., Software Systems Construction with Examples in Ada, Prentice Hall, Englewood
Cliffs, NJ, 1994.
Schultz T.W., Peripheral Hardware and a Hands-on Multitasking Lab, IEEE Micro, Vol. 11,
June 1992, No. 1, pp. 30-33, 80-82.
Schwarz J.J., Skubich J., Maranzana M., Aubry R., Graphical Programming and Real-Time
Design Instruction, in Real-Time Systems Education, IEEE Computer Society Press, Los
Alamitos, CA, 1996, pp. 20-25.
Shaw A., A Course in Real-Time Software Principles (with Practice), in Real-Time Systems
Education, IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 3-5.
Shepard T., Wortley C., Selic B., Using ObjecTime to Teach Real-Time Software in the
Undergraduate Curriculum, in Real-Time Systems Education, IEEE Computer Society Press, Los
Alamitos, CA, 1996, pp. 26-35.
Shumate K., Keller M., Software Specification and Design, John Wiley and Sons, New York,
NY, 1992.
Tucker A. , Ed., Computing Curricula 1991, Communications of the ACM, Vol. 34, No. 6, June
1991, pp. pp. 68-84.
Ward P.T., S.J. Mellor, Structured Development for Real-Time Systems. Vols. 1-3. Prentice-Hall,
Englewood-Cliffs (NJ), 1986.
Zalewski J. , A Real-Time Systems Course Based on Ada, Proc. ASEET 7th Ann. Ada Software
Engineering Education and Training Symp., Monterey, CA, January 12-14, 1993, pp. 25-49.
Zalewski J. , Cohesive Use of Commercial Tools in a Classroom, Proc. 7th SEI Conf. on
Software Engineering Education, J.L. Diaz-Herrera, Ed., Springer-Verlag, Berlin, 1994, pp.
65-75.
Zalewski J., Real-Time Systems Education: An Introduction, in Real-Time Systems Education,
IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. vii-xiv.
Zobel R.N., Real-Time Systems Education in Computer Science at Manchester University,
Microprocessing and Microprogramming, Vol. 24, 1988, pp. 835-840.
Andrew J. Kornecki
Computer Science Department
Embry Riddle Aeronautical University
600 S. Clyde Morris Blvd.
Daytona Beach, FL 32114
USA
Phone:(904) 226-6888
Fax: (904) 226-6678
E-mail:
korn@erau.db.erau.edu