Search

Until now, we have glossed over the operations of the translation’s runtime component. We have described some of its functions, but have not said how it accomplishes anything. No longer! In this chapter, we explain how code for managing model execution works and the important role it plays in generating a running program.

We could begin this book with a litany of the failings and sins of software development. We won’t bother with that. If you are a practicing software developer, you know the problems and have lived through them. Instead, we’ll get straight to the point.

We presented the simple ATC application as an extended hello world example to demonstrate the fundamental steps in a pycca translation. That initial application addressed a small portion (workloads and shifts) of an isolated subject matter (air traffic control). It was defined by an integrated set of class, state, and action facets wrapped up in a single executable model package. In this chapter, we begin a new case study that requires coordination of multiple such executable packages which, in Executable UML, are called domains.

In the previous chapter, we presented the Lubrication domain, which is part of an Automatic Lubrication System (ALS). The Lubrication domain delegates to a Signal I/O (SIO) domain controlling and obtaining the necessary data about the lubricated machinery. In this chapter, we describe the SIO domain and show how sensing and control over the external world is accomplished.

This chapter describes the main elements that make up an executable model for a sample application. The application is deliberately small so that we can show how to translate the whole model into running code, with no mysterious gaps. We’ll use the same principles later to build larger, more complex applications.

In this chapter, we discuss how to manage interactions among domains. Because we are bridging the gap from the semantics of one domain to that of another, we call this topic bridging. From a modeler’s perspective, bridging two domains can be relatively simple. This assumes that no semantic content is missing between the two domains. For example, it would be difficult to bridge a video game application directly to the rendering hardware without having at least an intermediate draw engine. We have avoided this kind of trouble by carefully constructing the domain chart for the ALS example.

We took a tour of the key decisions made during translation of an xUML model in the previous chapter. A pycca model script is prepared, and we examine the resulting C code. The subject of this chapter is implementation oriented, and we assume you are familiar with the C language. Space doesn’t permit us to present all of the code here, but if you are interested in reviewing the entire ATC project, including all of the code, feel free to download it from the book’s website.

In the previous chapter, you saw how vague statements can be transformed into a concrete and unambiguous specification of the problem logic realized as a set of executable models. The models contain problem-oriented concepts that you can discuss with your customers and users to make informed decisions about the relevant problem logic. Although completed models define exactly what the implementation should do, they do not say just how to do it.

In this chapter, we discuss the design and implementation of the pycca program itself. Pycca is designed as a language processor that reads DSL statements to populate a platform model and generates code by using a template system that queries the populated platform model. It is implemented in the Tcl language.

In this book, we have shown, by a series of examples, how an executable model can be nondestructively translated into a running program. Our translation technique is one way to obtain code from models. We do not claim it to be the only way to translate models. Nor do we claim it to be the best way to translate. The techniques we have presented, like all software engineering processes, have benefits as well as drawbacks. But we have met our goal of producing running code that satisfies the constraints of our target platform by translation of an executable model. We consider that important because, to excerpt from the Agile Manifesto

Indexed mitochondrial complex activities (MCA;) were determined in biopsies obtained from 52 donor kidneys at the end of cold ischemia (8-32 hr) to see if longer anoxia affected MCA i and accounted for the increased risk of delayed graft function (DGF) in recipients of grafts with longer cold ischemia time (CIT) or from non-heart-beating donors (NHBD). CITs were significantly different between those with and without DGF (P=0.02), being shorter in the latter, but MCA i were similar. CIT was correlated (r=0.43, P=0.003) with the time taken for creatinine concentration to fall to half the perioperative value (Cr t ½) but not with MCA i . Frequency of DGF, greater in NHBD, was significantly different from that of heart-beating donors (P= 0.04), but CIT and MCA i were similar. However, Cr t ½, was significantly different being longer in NHBD. Thus, the frequency of DGF increased and the speed of recovery diminished with longer CIT, whereas MCA, remained stable suggesting other factors determined tissue recovery.

The object-oriented paradigm still faces an open challenge: Delivering huge software systems routinely and cost effectively. To quote Ed Yourdon: “A system composed of 100,000 lines of C++ is not be sneezed at, but we don't have that much trouble developing 100,000 lines of COBOL today. The real test of OOP will come when systems of 1 to 10 million lines of code are developed.” Although the object-oriented community has an opening flirtation with exploratory programming and rapid prototyping by exploiting reuse via inheritance, there is for now, in my opinion, no hope that huge systems can be developed without giving due attention to what a target system is supposed to do. Which should produce an (electronic) (graphical) (Pseudo-formal) document, the requirements, that a customer can initially sign off. We believe as well that for huge systems a programming language independent design activity, that bridges the requirements and the actual programming effort, is mandatory. It goes without saying that we do not suggest that these activities constitute a waterfall sequence. Consequently, the object-oriented community needs to address the question whether well established analysis techniques, like Structured Analysis, Jackson's JSD, etc. can be reused for object-oriented system development or whether a dedicated object-oriented analysis (and design) method is called for. The panel members have been asked to consider the following of question: What is the relationship between Structured Analysis (SA) and Object Oriented Analysis (OOA)? More specifically: Can SA be used effectively to produce the requirements for a system that will be designed and implemented in an OO fashion? If not, is it possible to adjust SA, what needs to be added? If SA cannot be used at all, what is the key obstacle? In case SA and OOA have different applicability ranges, how do we circumscribe — positively and negatively - these ranges? Any overlap? We appreciate that the organizing committee of this conference has selected this crucial topic.