As we have seen, one of the most salient architectural characteristics of MPCS in the initial architecture is that it took different forms in different environments. The ICMD effort aimed to bring the operations environment more in line with the ATLO environment. The main difference essaywriting service between the testing configuration of MPCS and the operations configuration of MPCS essaywriting service was commanding. Timelines were a new data structure proposed for storing streams of time-oriented data throughout AMMOS. Many of the kinds of data that JPL handles on a day-to-day basis fit naturally into this model: telemetry, command sequences, and others. The timeline proposal defined specific formats for storage and transmission of timelines, and also described the architectural infrastructure necessary to support them. Timelines were expected to be useful for many purposes, but one of the most important was comparison of actual telemetry with expected telemetry. Supporting timelines would require substantial architectural infrastructure. Thus, for example, a specially engineered timeline database was planned, which would be designed specifically for efficient storage and retrieval of timelines.
In its initial form, MPCS stored telemetry information in a MySQL database. Ultimately, this database was to be rendered obsolete by the introduction of timelines. After timelines are integrated into MPCS, telemetry would be stored in an AMMOS-wide timeline management system, and the MySQL database would eventually be retired. The CMD system would continue to exist but would no longer be the originator of commands in the operations environment. With the introduction of timelines, this command repository would become obsolete, as command sequences would be stored as timelines and would therefore be stored by the timeline management system. This was an important point of interaction between the two pieces of the evolution, ICMD and timelines. In addition to storing commands, the timeline management system in the end state would be responsible for storing channelized telemetry. Thus, the target architecture lacked the MySQL database that existed in the initial architecture, and the usages of that database by other MPCS components were replaced by connections with the timeline management system.
The timeline management system would be external to MPCS, so these connections would be external collaborations rather than internal connections. I did this by reviewing project documents and speaking with project personnel. During this period, I also selected an evolution to study—the one described in essaywriting service the previous section. Among the options considered were past evolutions (i.
I ultimately selected an evolution that was in progress but had been underway for only a short time. Picking a current evolution had the advantage of being of greatest relevance to JPL. If I had selected a past evolution, it is likely that documentation would have been difficult to find, and there would have been few available personnel who were familiar enough with the evolution to provide useful information.
On the other hand, if I had selected a future evolution for which few firm plans had been made, substantial speculation would have been necessary in order to construct an evolution graph. Another important choice was the scope of the evolution, in terms of both time (i.
I could have picked a much larger scope than I did—for example, by studying the overall evolution of AMMOS rather than focusing on MPCS, or by trying to look further into the future. However, given the limitations of the case study format, it would have been difficult to gather sufficient information about a broader evolution to produce a useful model capable of saying anything useful about the evolution—one that was more than a superficial overview.
Once I had selected an evolution to study, the next task was to model it. At JPL, the dominant modeling language is SysML, the Systems Modeling Language, and the dominant modeling tool is MagicDraw, a commercial tool that can produce SysML models.
In this section, I will describe how I adapted our architecture evolution approach to SysML and MagicDraw. SysML arose from collaboration, beginning in 2001, between the Object Management Group and the International Council on Systems Engineering. It was developed by a coalition of industry leaders and adopted as a standard in 2006. It is an extension in the sense that it adds new syntax and semantics beyond that of UML. It is a restriction in that it excludes many of the elements that do exist in UML, for the purpose of simplifying the language. SysML takes a subset of the diagram types from UML and repurposes them for the domain of systems engineering. I used two diagram types in representing evolution states: BDDs and IBDs. In SysML, a block is the basic unit of system structure. BDDs and IBDs are both representations of an underlying model.
I tailored my use of the diagram types to show those aspects of the architecture whose evolution I hoped to model. The most detailed and important diagram that I produced was an IBD showing the internal structure of MPCS. I also produced a set of three IBDs that served essentially as context diagrams showing how MPCS essaywriting service was deployed in the three different environments (flight software development, ATLO, and operations). For representing this evolution, it was important to see not only the internal changes that were occurring within MPCS, but also the changes in how MPCS interacted with other systems, such as CMD. Recall that such changes were key to the overall evolution, so modeling them was crucial to providing a complete, useful representation of the evolution. More interesting is the question of howto model architecture evolution effectively. Recall that we model an evolution as a graph, in which the nodes are intermediate architectures and the edges are transitions. The simplest strategy would be to create one MagicDraw project for each intermediate state.
A better idea, however, is to include all the intermediate states, and hence the entire evolution graph, in a single project. With everything in one project, it becomes possible to write evolution constraints and evaluation functions with existing tools, simply by using the model constraint and analysis facilities already provided by the tool. More specifically, I placed each intermediate state in its own package.
A package is a UML construct (also available in SysML) that encapsulates related entities. Finally, if we wish, we can add annotate these packages and relationships with additional information to facilitate analysis, such as node properties and edge properties. Since what I was modeling was a gradual evolution rather than an outright retirement and replacement of a system, all the states look mostly the same, except for those pieces that are evolving. I could have created this evolution graph model very easily by simply cloning the initial state and modifying it.
But maintaining this evolution graph would have been painful.
Suppose that after I had finished representing all the states, I had noticed a mistake in the initial architecture that affected all the other states as well (since they were generated by cloning the initial state).