SHAH, Ankur1, SOSNOWSKI, Janusz2, VAN KATWIJK, Jan3& ZALEWSKI, Janusz1
1
2 Institute of Computer Science, Warsaw University of Technology, Nowowiejska 15/19, 00-665 Warsaw, Poland, jss@ii.pw.edu.pl, http://www.ii.pw.edu.pl/indexe.html
3 Dept. of Technical Informatics, University of Technology, 2628 BZ Delft, The Netherlands, J.vanKatwijk@twi.tudelft.nl, http://sepc.twi.tudelft/~jza
Abstract: This paper discusses issues related to offering a web-based course in software engineering, using a course on "Software Quality Assurance" as an example. A set of web-related requirements for such course is presented and examples of practical solutions are given. Issues related to joint development of modules and course internationalization are also discussed briefly.
Keywords: software engineering, software quality, dependability
The objective of this paper is to discuss issues related to offering a web-based course in software engineering. We selected a course on "Software Quality Assurance" for two reasons. First, it has been our experience that, in contrast to other software engineering courses, for example on requirements, design, or software verification, a course on software quality assurance does not require that intensive team work on software projects. In this sense, holding meetings via the web on software quality assurance is much more productive and less stressful than in other software engineering activities. Secondly, two editions of this course have been already offered via more traditional distance learning facilities (videotape based) at UCF. Shifting the delivery to a web-based course would in this case involve much less risk than in case of developing such a network-based course from scratch.
The technical content of the course focuses on four equally important aspects of software quality assurance: measures and metrics, testing, process improvement, and formal methods, covered throughout the three major phases of the software development cycle: requirements specification, design description, and implementation. Specific attention is put on software reliability and safety in real-time mission-critical systems [2], and on techniques and standards to achieve these goals. In particular, a variety of testing methods, including functional and structural testing, unit and integration testing, test case development and analysis, is discussed, followed by manual techniques such as walkthroughs, inspections, reviews and audits. Reliability modeling and assessment techniques are presented and various methods of software fault tolerance discussed.
A strong motivation for international collaboration is threefold. In the first place, web technology allows students around the globe to benefit from course offerings at a single source, without even knowing where this source is physically located. Students can thus benefit from strengths of a particular site and experiences of faculty, in a manner similar to getting knowledge from a book written by the best experts in a particular field.
Second, developing a web-based course offers an opportunity to invite international faculty, with experience in one particular area, to contribute to this aspect of the course, which they know best. In this respect, the current course, even though offered at UCF, benefits from expertise of colleagues from Warsaw University of Technology in the area of dependability and fault tolerance [4], as well as from expertise of faculty of Delft University of Technology in the area of formal methods [1].
Finally, in a course as specific as Software Quality Assurance, internationalization has another important aspect. Different countries, especially those located on different continents or those of different cultural backgrounds have different, sometimes totally different, approaches to quality assurance, verification of properties, product certification, etc. In a global economy, it is important for graduates of engineering schools of any university to not only to know scientific approaches to respective problems but also be aware of cultural differences. An internationally offered web-based course will definitely provide respective opportunities.
Nowadays web based courses are developed with some additional features such as animation or some kind of user interaction which makes learning and web based course more effective than simple traditional text based on-line services. This particular course needs to be offered via the web, not only via traditional text and images but with a more interactive approach, which will make learning more interesting. In particular, it has been decided to add some 3D graphics and animation that will illustrate regular text and viewgraph-based presentation.
This project will interact with online course system that has already been supported at the University of Central Florida by its course development group, http://reach.ucf.edu. That system is currently using WEBCT software for student interaction. WEBCT will take care of user authentication to validate if the user has the right to login into this course or not. Also WEBCT will take care of all the exercises, quizzes, chat rooms, forums to exchange information online, etc.
Functions provided by this project are as follows.
Output of the final product should be made up of a web page which will be divided into four main distinct areas (Fig. 1):
Figure 1. Illustration of screen requirement
The main building block of a solution is a dynamic HTML page. Each page interacts with others when a particular event occurs. For example when a user clicks on next-slide button, an event occurs that will load a different web page and do other functions. Animation and 3D presentations are written in Java3D, which has a rich hierarchy of classes that can be used to build any complex scene. In addition, Java3D can take advantage of an underlying hardware acceleration if it is available.
Figure 2 shows the context diagram for the project, which includes external interfaces. Specifically, the software interacts with the following external components: user display, user commands and a logical data store. Figure 3 presents the actual design layout of user display.
Figure 3. Actual screen design
Actual animation is hard to show on paper in this article, but generally speaking there are two categories of animated illustrations, which can be used in this course (Fig. 4 and 5). First, two-dimensional or three-dimensional graphs are suitable for animation to demonstrate curve or surface changes corresponding to certain parameter changes. Second, actual data flow in a state machine or other kind of activity representation, such as Petri net, is also a good vehicle to illustrate certain concepts with motion.
|
|
|
|
Figure 4. Sample curves. |
Figure 5. Sample diagram. |
User commands are listed in the following Table. Example of Notes corresponding to a particular single slide is presented in Appendix 1. It is just a text explaining in more details typical contents of a slide. An example of a Link page is shown in Appendix 2. It just includes a list of web pages and articles relevant to a current topic or a particular slide.
|
User Command |
Description |
|
Notes Button |
Allow user to see professors notes or comments about particular slides. |
|
Zoom view Button |
Allow user to see full screen slide. |
|
Link Button |
Allow user to see other web links, which are related to topic in current slide. |
|
Previous slide Button |
Allow user to see previous slide in a particular topic. |
|
Next slide Button |
Allow user to see next slide in a particular topic. |
|
Slide Index |
Allow user to choose which slide or topic to view. |
The main logical data store consists of HTML pages. These pages are statically and dynamically created. All course material slides consist of mainly JPEG pictures stored in a particular directory structure.
The software is logically divided into four modules, represented as a data flow diagram in Figure 6: initialization module, topic index module, slide module, and 3D or animation module.
Figure 6. Basic software design
We are planning to offer this course completely via the web for the first time in the Spring 2000. Currently the contents of the course are continuously evolving, with modules being developed by all three participants. It is assumed that most modules can be used at all three locations, for different courses, such as the one with syllabus presented in Appendix 3.
Regarding internationalization, all participants benefit immensely from:
Problems that are encountered due to internationalization involve:
Regarding web-based delivery, we are expecting that the first edition of the web-based course will shed more light on the following issues:
With respect to the latter issue, we are planning to add voice recordings to the text accompanying viewgraphs.
[1] BUN L., J. VAN KATWIJK, An Astral Specification for a Railroad Controller. Report 95-104, Faulty of Technical Mathematics and Informatics, Delft University of Technology, 1995.
[2] HALANG W., J. ZALEWSKI, A Course on Safety-Related Real-Time Computing Systems. In Real-Time Systems Education. Los Alamitos, Calif.: IEEE Computer Society Press, 1996, pp. 98-107. ISBN 0-8186-7649-3
[3] LAPRIE, J.C., Dependability: Basic Concepts and Terminology. Translated into Polish by S. PIESTRAK. Proceedings of EDCC-2 Companion Workshop on Dependable Computing, Vol. 2. Gliwice: Silesian Technical University, 1996. ISBN 83-906582-1-2.
[4] SOSNOWSKI J, J. SABAK, I. BLUEMKE, Software Reliability Problems. Internal PATIA Project Report (in Polish), Dept. of Computer Science, Warsaw University of Technology, June 1999.
The basic software fault tolerance techniques include recovery blocks and N-version programming, plus their more advanced extensions:
The presented software fault tolerance techniques can be used at different levels. In particular, a complex system may be composed of some smaller components each comprising some fault detection and fault tolerance capabilities. Such component may realize the requested services correctly, signal some problems, or in the worst case deliver wrong results which can be detected and eventually corrected at a higher level. Fault tolerant subcomponents can be used to create higher-level components, etc. It is important to note that modern systems comprise many built-in error detection mechanisms (e.g., access violation) which can signal exceptions during the program execution. Hence classical approaches to software fault tolerance have to be enhanced with appropriate exception handlers.
An important issue is to check the effectiveness of the designed fault tolerant system. This can be done in an indirect way, via analysis of various properties, or directly by inserting faults and observing the system behavior.
|
School: |
Warsaw University of Technology |
|
Program: |
Computer Science |
|
Level: |
Graduate advanced |
|
Lecture: |
30hrs |
|
Lab project: |
15hrs |
|
Instructor: |
Janusz Sosnowski |
1. Basic concepts and definitions
Nature and statistics of faults (hardware and software). Dependability, reliability, safety, security, maintainability, availability, diagnosability, testability, responsiveness, etc. Fault detection, fault tolerance, fault avoidance. Dependability problems in real systems (industrial, medical, telecommunication, etc.; long life, critical computation, maintenance postponed, high availability applications). Examples of wrong designs which resulted in catastrophes, etc.
2. Hardware testing and diagnostics
Fault models (functional, structural). Test strategies (deterministic, pseudorandom). Test algorithms for selected functional blocks (RAMs, microprocessors, ALUs). Design for testability (ad hoc, scan paths, BILBO, etc.) and built-in-self-test (BIST) concepts. Overview of DFT and BIST features in commercially available circuits and systems. Test effectiveness evaluation. Diagnostic models (centralized, decentralized, PMC, KH, etc.), diagnosability features. Overview of diagnostic programs (POST, Checkit).
3. Software reliability features
Test methods (white, black box). Checking test effectiveness (structural coverage, fault injection, etc.). Software reliability modeling (NHPP, Jelinski/Moranda model, Schneidewind, etc., operational profiles). Correlation between software complexity (measures) and reliability. Field data analysis.
4. Fault tolerance techniques
Hardware redundancy: modular (passive, active, hybrid), circuit and data redundancy, time redundancy, program redundancy. Error detection and error correction codes. Self-testing and self-checking circuits. Outline of fault tolerant architectures (DMR, TMR, Tandem, Stratus, FTPP, Delta4, MARS). On-line monitoring techniques (signature monitors, watchdog processors). N-version programming, recovery blocks, N self-checking programming, voting and comparison problems. Diversity and dependence of failures. Error detection and handling. Error recovery (backward, forward), program checkpointing. Reliability problems in distributed system (domino effect). Hardware software codesign issues.
5. Safety and dependability evaluation
Safety analysis (fault trees). Hardware facilities for safe systems. Examples of practical problems and solutions.
