Executable and Translatable UML (xtUML) is a modeling methodology where a system is constructed using a set of UML models and an action language, which can be translated to a target implementation and compiled into an executable program. It allows for good readability and understanding of the workings of the system and relations between its different parts, easy testing and reusability. With a subset of UML diagrams and finite state machines, the actors in the system and the execution progression can be defined. These models are then made into an executable program using a model compiler. Saab Dynamics has developed their own model to C++ compiler, also made using xtUML with the open source tool Bridgepoint. In the current implementation of the compiler, events which trigger a class instance to transition from one state in a state machine to another, are picked from a queue and processed one by one. In theory, a speedup of the execution time for programs could be achieved if multiple events were run simultaneously. To enable parallel execution, additional functionality needs to be added to the compiler to map dependencies between classes and schedule events on threads.To achieve this a parser was implemented, which iterates every state machine and finds statements which access other classes and could result in a potential data race. These shared data accesses are mapped as instances of a Dependency class if at least one writes to it. These are then later used by the compiler to determine for each class to which classes it has a dependency. During execution when events are picked from queue, a check is made for the target class of the event to the currently executing classes on other active threads, to determine if the event is allowed to be processed immediately or if it should be placed in queue again. Threads are created at the start of the program in a thread pool, and are awakened once an independent event is found and added to the thread's own queue. Results from test models compiled using the new version of the model compiler show that the parser finds all data accesses to other classes and accurately maps the dependencies between them. The end results of the programs are equal to that of the serial executions, and the principles of xtUML are maintained. While there are still improvements to be made to increase the parallelization of events, there was a significant speedup in execution time to be seen for models containing time consuming independent state machines.

<p>Executable and Translatable UML (xtUML) is the next abstraction level in software development, where both programming language and software architecture have been abstracted away. xtUML is a well defined UML profile, extended with precise action semantics. This allows the developers to define a problem area, domain, in such a detail that it can be executed. By defining the system with xtUML-models, domains, the system functionality can be verified early in the development process. Translation to code can be done in different ways and this work will be performed in an environment where code is automatically generated with a model compiler.</p><p>The goal with a domain is that it should be independent of other domains, reused without modification and exchanged with another domain solving the same problem. However a domain can make assumptions that certain functionality is available and these assumptions are requirements for another domain.</p><p>To fulfil these goals there must be a minimal coupling between the domains. This can be solved with the technique Implicit Bridging, where the bridge dependency between domains is defined in a bridge. The dependency is in the form of mappings/coupling between elements in both domains. By defining a bridge interface for a server domain a client domain can use the resources offered by the server domain.</p><p>The work performed shows how an implementation of Implicit Bridging could be realized by applying the technique in a microwave oven system. From the system design five different mapping types have been implemented. The applicability and the quality of the implementation have been verified by testing the generated system functionality and also verifying the goals, exchangeability and reuse of domains, of the system.</p>

Executable and Translatable UML (xtUML) is the next abstraction level in software development, where both programming language and software architecture have been abstracted away. xtUML is a well defined UML profile, extended with precise action semantics. This allows the developers to define a problem area, domain, in such a detail that it can be executed. By defining the system with xtUML-models, domains, the system functionality can be verified early in the development process. Translation to code can be done in different ways and this work will be performed in an environment where code is automatically generated with a model compiler. The goal with a domain is that it should be independent of other domains, reused without modification and exchanged with another domain solving the same problem. However a domain can make assumptions that certain functionality is available and these assumptions are requirements for another domain. To fulfil these goals there must be a minimal coupling between the domains. This can be solved with the technique Implicit Bridging, where the bridge dependency between domains is defined in a bridge. The dependency is in the form of mappings/coupling between elements in both domains. By defining a bridge interface for a server domain a client domain can use the resources offered by the server domain. The work performed shows how an implementation of Implicit Bridging could be realized by applying the technique in a microwave oven system. From the system design five different mapping types have been implemented. The applicability and the quality of the implementation have been verified by testing the generated system functionality and also verifying the goals, exchangeability and reuse of domains, of the system.

Executable and Translatable UML (xtUML) is a high level software development method where models are developed using UML diagrams and action language code. Model compilers can translate a model into another programming language which is then executable. When developing xtUML models one of the main benefits is that the documentation of the program is created at the same time as the program in the shape of UML diagrams. It is therefore also important that it is possible to create good UML diagrams that gives the reader a good and clear understanding of how the program works without having to look at the code. One problem is the use of arrays and structured data types in the models because they can make a model more difficult to understand and therefore it would be good to be able to refrain from using them and instead model arrays and structured data types as classes with relations between them. This becomes an issue when an array should be sent to another domain in the system because a lot of action language code must be written which is inconvenient. A solution to this problem would be to send class object instances directly to other domains. In this thesis a solution to the problem has been proposed along with alternate options of solving it. The proposed solution has also been implemented in an existing model compiler and the results show that the performance in compilation time is slower compared to when using the built-in arrays and structured data types, but faster or the same compared to letting the user write its own code for sending object instances. The execution time for a small model using the new solution has increased by a lot compared to using arrays and structured data types, and the size of the executable file has almost doubled but if bigger models are created this difference may become negligible.

The Master's thesis presents specification, analyze and design phase of software development. The most stress is putted on Model Driven Development. It contains brief description of almost all UML 2.0 diagrams (use case diagram, class diagram, sequence diagram, activity diagram, state chart, component diagram and deployment diagram). Those principles have been extended to executable UML which can be used for model-driven software architecture. The design of such architecture is one of the current projects of Faculty of Information Technology, BUT. The part of that project is statechart simulator. The thesis discusses whole design of state chart simulator system step by step. It starts with specification, walk thought use case diagram and class diagram to collaboration diagram. In the last chapter, we mention the biggest implementation problems and specificities of Squeak Smalltalk programming language. Finally, it considers possibilities for extension and it evaluates results.