IEEE ©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.

Return to Table of Contents

Real-Time Systems Course in Undergraduate CS/CE Programs

Andrew J. Kornecki

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.


  • Introduction
  • Place of Real-Time Systems in the Undergraduate Curriculum
  • Software Engineering for Real-Time Systems
  • Real-Time Course Implementation
  • Lessons Learned and Future Plans
  • Links and Resources
  • Acknowledgments
  • References
  • Contact Information
  • Biography


  • I. Introduction

    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.



    II. Place of Real-Time Systems in the Undergraduate Curriculum

    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.



    III. Software Engineering for Real-Time Systems

    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 (http://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."



    IV. Real-Time Course Implementation

    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

    Phase Two: Design

    Phase Three: Implementation

    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).



    V. Lessons Learned and Future Plans

    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.



    VI. Links and Resources

  • Real-Time Class Syllabus - ERAU CS450/FA96
  • Real-Time Class Handouts - ERAU CS450/FA96
  • Real-Time Class Assignments - ERAU CS450/FA96
  • ERAU Real-Time Laboratory Description
  • Real-Time Resource Pages
  • ERAU Real-Time Laboratory Server


    Acknowledgments

    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.



    References

    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, http://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.



    Contact Information

    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



    Biography

    Andrew J. Kornecki holds an MSEE (1970) and a PhD (1975) from the Academy of Mining and Metallurgy in Krakow, Poland. Dr. Kornecki has been teaching and doing research affiliated with universities on three continents. He joined the ERAU faculty in 1985 doing research and teaching computer organization, discrete structures, modeling and simulation, and real-time systems. He has contributed to research on Intelligent Simulation Training Systems and served as a visiting researcher with the Operations Research Service of the Federal Aviation Administration (1992). He was granted the Fulbright Scholarship for teaching and research in 1995/96.