Computer Aided Software Engineering Tools for Designing Real-Time Systems
With the increasing use of computers in today's world, the computer software industry has developed some very complex software applications. The need for more robust and diverse software applications, such as real-time systems, has dramatically become more popular and even necessary, yet much more difficult to analyze, design, and implement. Real-time systems are usually defined as special purpose software programs that have timely response requirements; in other words, these systems must have adequate results within certain time constraints. Therefore, real-time systems are fundamentally more complex than other software applications primarily because of their restrictions in acceptable and timely real-time output. It is an obvious conclusion that software engineers need computer aided software engineering (C.A.S.E.) tools specifically constructed to assist in the development of real-time systems during their software lifecycles because of their inherent complexities. Hence, there is a strong need to evaluate the abilities of current C.A.S.E. tools for real-time systems and to determine the abilities that C.A.S.E. tools should already have and will need in the future.
Before the evaluation of C.A.S.E. tools, I believe further explanation of real-time systems is necessary. Real-time systems are becoming more common in everyday life because of their ability to control multiple activities in a timely fashion. For example, they play a major role in safety critical applications, such as air traffic control systems, automated vehicles, patient monitoring systems, mine drainage systems, and many more applications that most people are only vaguely aware of. The importance of these real-time systems is obvious when they must be able to calculate adequate results within a predefined and strict amount of time; or else, people's lives could be in jeopardy. Also note that real-time systems might not necessarily mean software applications that have almost instantaneous results, such as an operating system; but rather, real-time systems have results within an acceptable time period to compute quality output while still within a safety range. This illustrates that securing quick results are just as important as acceptable quality results, yet a compromise between the two must sometimes be taken, depending on the system. Even though this simple illustration does not encompass all of the finer points of real-time software, it does show how the complexity of analyzing and designing such systems quickly becomes quagmired; simply because, real-time systems are special purpose software applications that must be able to adequately handle all possible scenarios while still able to implement their results quickly enough. Evidently, it is the task of software engineers to understand all the aspects of these complex systems, and any tools that can help software engineers to analyze, design, and implement these systems should potentially facilitate software development. This demonstrates the importance of using excellent C.A.S.E. tools as an integral part of the software life-cycle of real-time systems. In addition, there has been a continuously strong demand for more sophisticated and powerful real-time design tools from the software industry, because real-time systems have been and are getting more intricate.
The need to better understand what C.A.S.E. tools are and why they are used is necessary before discussing them with respect to real-time systems. C.A.S.E. tools are simply software applications used to assist and/or automate the software engineering process. One of the primary tasks of C.A.S.E. tools is to organize entire projects, so that the complexity of projects can be parsed into manageable components. Yet at the same time, they are able to coordinate a large number of people without each person in the development team needing to know the entire system in detail. C.A.S.E. tools are also fairly easy to understand and user-friendly. However, the main reason why corporations use C.A.S.E. tools is that they save time by increasing the productivity of software engineering teams; and in today's business world, time is money.
Furthermore, C.A.S.E. tools are used to help develop virtual models of potential systems. These virtual models can in return support specific phases in the software life-cycle by making some tasks clearer, easier, and more efficient.
In the analysis phase, "there are tools for writing requirements specifications" especially designed to help provide writing conventions that in return clarify the requirements for the entire software engineering team (Ghezzi 459).
In the design phase, C.A.S.E. tools provide "a set of strategies for developing a design solution from a well-defined statement of a problem" (Page-Jones 3). This results in an overall design convention with a high level of formality that can be achieved more easily with C.A.S.E. tools (Ghezzi 459). However, this formality does not impose a strict design standardization, because each system has a unique design that cannot be easily or generically categorized (Ghezzi 461). C.A.S.E. tools also provide "a set of criteria for evaluating the quality of a given design solution with respect to the problem to be solved" (Page-Jones 3). Almost instant design modifications and corrections over entire systems can also be done more efficiently using C.A.S.E. tools rather than the slow and tedious task of hand corrections.
There are also tools, with obvious benefits, that assist in editing and/or debugging code in the implementation and testing phases of the software life-cycle (Ghezzi 459). Moreover, automatic prototyping is used to construct "simplified versions or small parts of" the proposed systems "that can be analyzed before further development is done," and using tools is the only way this can be done (Brookshear 236). It could be inferred that most C.A.S.E. tools "only help in some specific activity that is limited to a certain phase of the software life cycle", but some tools "can support a natural and smooth transition through the software development phases" and are called integration tools (Ghezzi 459). As a result, "[a]ll phases of the software process should be computer assisted, in an integrated way. This means that all of the tools for managing, specifying, programming, verifying, etc., software should belong to the same environment, and their interaction should be supported through an appropriate infrastructure" (Ghezzi 507).
"Tools, however, should be based on methods; otherwise, they provide no help in the production of high-quality software. Certain methods may be organized into a coherent set (a methodology) to cover a large portion, or even all, of the software process. Thus, around individual tools, the environment may provide services that enforce the use of tools according to given methodologies" (Ghezzi 510). Since the methodologies of real-time tools are more skewed than ordinary methodologies because of the inherent complexities of real-time systems, the functionality and abilities of current real-time tools need to be examined closely.
C.A.S.E. tools for real-time systems must be able to do everything that they usually do for ordinary software applications, in addition to satisfying all of the requirements of real-time systems. "Since [many] real-time systems operate in the presence of concurrent events, it is only natural to design the software as a set of current processes" (Kavi 543-544). This process of breaking down the complexity of a system is known as system decomposition. System decomposition makes projects easier to manage, at the same time it increases concurrent activity during the software development process. "The system decomposition should include both functional and temporal requirements. Furthermore, the temporal behavior of the components should be analyzed for completeness (i.e., whether all requirements are reflected in design), correctness (i.e., whether there is any conflict or inconsistency in design), and feasibility (i.e. whether it is feasible to achieve the requirements)" (Kavi 544). "However, most of these [real-time] methodologies are based on heuristics, in that a thorough knowledge of the intended system, choice of programming language, and execution characteristics of the underlying architecture play key roles in the decomposition of the system into concurrent tasks" (Kavi 539). All of the benefits of system decomposition are only made possible through real-time C.A.S.E. tools. Since real-time systems are usually unique, C.A.S.E. tools have been developed with the ability to become experts of specific real-time systems usually by analyzing the requirements. This is an obvious enhancement over regular C.A.S.E. tools, because they can only provide generic software development assistance without knowledge of the specific system under development. One of the other abilities that have also been developed for C.A.S.E. tools is to handle the criticality of real-time systems during the design and analysis phases. These are the two most important phases in the software life-cycle, whereby any error during these phases would certainly result with serious malfunction(s) over the entire application. The design phase is relatively straightforward assuming the software engineers have the adequate tools and experience, as seen earlier. However in the analysis phase, there are real-time tools, called real-time logic simulators, that can find the locations and extent of flaws in completed designs by at least analyzing all the potentially critical bottlenecks and paths. Thus, quite possibly saving an enormous amount of time by finding defects (and recording detailed explanations of each defect) in the design before the implementation phase, because it is easier to fix defects earlier in the software life-cycle. And because of the complexity of real-time systems, design corrections over entire systems are almost impossible without C.A.S.E. tools, or at least very prone to error. Thus ‘tweaking’ the design of real-time systems is easier and more reliable using C.A.S.E. tools. In the implementation phase, automatic prototyping is used heavily to insure that implementation is done properly and correctly according the strict requirements of real-time systems. It can be concluded that real-time C.A.S.E, tools are specifically designed expert software applications whose main purpose is to save time and money when developing high quality software with strict real-time requirements.
In contrast, C.A.S.E. tools do not perfectly support the development of real-time system in all the phases of the software life-cycle. In fact, large portions of existing C.A.S.E. tools and methods have difficulty handling the design complexities and consistent quality requirements of current real-time systems, mainly because they were not specifically design to develop real-time systems. For example, most of the existing tools and methods are limited to the mundane syntactical aspects of software development. These methods prove to be inflexible and do not provide the potential for tools to adapt according to the unique features of applications, which real-time tools rely on. In theory, the virtual models that C.A.S.E. tools develop are used to promote "a high degree of maintainability and portability, since it is possible to replace any [virtual model] layer with a new one" (Kavi 546). "In many practical systems, this may not be easy to accomplish because of the dependencies between the ause abstractions at various layers" (Kavi 546-547). Also, analyzing the "... timing requirements of real-time system(s) must be carried out at several phases of development, including specification, design, and implementation, for their completeness, consistency, and correctness. Existing analysis techniques are either too complex or too limited in their scope to be useful in all phases of development" (Kavi 552). The main drawbacks that real-time C.A.S.E. tools currently have and should be immediately resolved is that they are either not up to date with the latest abilities or do not adequately utilize the potential of certain abilities.
"As the environments in which real-time software systems are embedded become more complex, specifying such systems precisely, describing the interactions among the tasks in such systems and with their environment, and designing and verifying the correctness of the code become more difficult" (Kavi 539). Thus, real-time C.A.S.E. tools will need more capabilities to better handle future real-time systems. Since "[n]ot all real-time systems are the same," it will be necessary "to categorize real-time systems such that appropriate design methods, architectures, and fault-tolerance strategies can be identified." It is also necessary to design real-time C.A.S.E. tools with the ability to reuse "software components" from complex systems. Currently, high level reusability of software components in complex systems have not been developed but should be. "It is also necessary for methodologies to optimize the software after integration of reusable components to meet timing and reliability requirements." Furthermore, future real-time C.A.S.E. tools should support "systematic decomposition" including the definitions of interfaces among the components. And finally, specific fault-tolerance techniques need to be developed for implementing multiple versions of a software application to insure that the requirements are continuously satisfied for each version (Kavi 552). As a result, it is obvious that real-time C.A.S.E. tools still have plenty of development needed to further assist software engineers.
In conclusion, real-time C.A.S.E. tools have been proven to be an indispensable part of software development because of the capabilities they provide to software engineers during every phase of the software life-cycle. Even with the capabilities that software engineers are able to use from real-time C.A.S.E. tools, there are still some capabilities that need to be better developed. Furthermore, future real-time systems will be even more complex and will require even more capabilities. However, present and future real-time C.A.S.E. must still even more leve satisfy "functional and performance requirements," must be "reliable and easy to maintain," and "should be able to adaptable to changing (enhanced) requirements and new hardware units" (Kavi 544). Keep in mind that the strong demand for more sophisticated and powerful C.A.S.E. tools only exist because of the potential that these C.A.S.E. tools can save time and money by increasing the productivity and quality of software engineering teams. In addition of having excellent C.A.S.E. tools, good software engineering teams require plenty of experienced professionals and good engineering practices.
- Brookshear, J. Glenn. Computer Science: An Overview. California: Benjamin/Cummings, 1991.
- Ghezzi, Carlo, Mehdi Jazayeri, and Dino Mandrioli. Fundamentals of Software Engineering. New Jersey: Prentice-Hall, 1991.
- Kavi, Krishna M., and Seung-Min Yang. "Real-Time Systems Design Methodologies: An Introduction and a Survey". The Journal of Systems and Software. April 1992: 539 553.
- Page-Jones, Meilir. The Practical Guide to Structured Systems Design. New Jersey: Prentice-Hall, 1988.
by Phil for Humanity