Presentation at the Code Generation 2014 conference at Cambridge.
The Action Language for Foundational UML (ALF) is a standard domain modeling and programming language for the executable (foundational) subset of standard UML (fUML). ALF is used for specifying executable behaviors within an overall graphical UML model.
Executable UML Roadmap (as of September 2014)Ed Seidewitz
The document outlines the past, present, and future of executable UML specifications. It discusses foundational UML (fUML) which defines an executable subset of UML, the Action Language for fUML (Alf) which provides a textual notation, and the Precise Semantics of UML Composite Structures (PSCS) which extends fUML for modeling composite structures. It describes open source and commercial implementations of these specifications and notes ongoing work to finalize the specifications and extend them to cover additional UML elements like state machines. The long term vision is for a suite of specifications that define the precise semantics of different aspects of UML to enable executable modeling.
This document provides an overview of the history and development of the Unified Modeling Language (UML) and Foundational UML (fUML) standard for executable modeling. It discusses how UML evolved from its origins in object-oriented analysis and design in the 1980s-1990s to add formal execution semantics definitions. fUML and the Action Language for Foundational UML (Alf) provide a computationally complete subset of UML with a defined execution model, addressing UML's previous lack of precise semantics. The document outlines the key components and implementations of fUML and Alf and their role in specifying UML's structural and behavioral semantics formally.
Programming in UML: An Introduction to fUML and AlfEd Seidewitz
The document discusses programming in UML using the Foundational UML (fUML) standard and the Action Language for fUML (Alf). It provides an overview of fUML and Alf, which define an executable subset of UML and a textual action language for specifying behaviors in UML models. The document uses a motivating example of an e-commerce ordering system to illustrate key concepts of executable UML including activities, actions, structure, and asynchronous communication.
The Unified Modeling Language (UML) has arguably succeeded in becoming the most commonly used modeling notation for software development. But “modeling” in the software community seems largely to mean simply drawing pictures, either to represent the problem domain or to blueprint a solution, without a precise enough meaning to fully specify the functionality of the system being developed. As a result, the UML standard,S up to and including UML 2.4.1, do not define the semantics of UML models at all precisely.
Nevertheless, there has also long been an interest in models that are more precise, even to the extent that they may be executed in their own right. It has taken a while for this viewpoint to penetrate into the mainstream of UML usage. But there has been in a great deal of work in recent years toward the standardization of the formal semantics of UML models – the “meaning” behind the pictures: the Foundational UML (fUML) specification adopted in 2008; the Action Language for fUML (Alf), adopted in 2010; the UML 2.5 specification (which includes a semantics conformance point for the first time); and the Precise Semantics of UML Composite Structures.
This presentation reviews the state of this work and the implications in practice of bringing real meaning to UML.
This is a one day workshop presentation, primarily on the new OMG Foundational UML specification for executable model semantics, but also discussing extensions for executable SysML (System Modeling Language) models.
Programming in UML: An Introduction to fUML 1.3 and Alf 1.1Ed Seidewitz
Based on a tutorial presentation given at the OMG Executable UML Information Day, this version of the presentation has been updated for fUML 1.3 and Alf 1.1, the latest versions as of this upload.
A presentation on the UML 2.5 specification simplification effort, presented at the 3rd Biannual Workshop on Eclipse Open Source Software and OMG Open Specifications.
fUML-Driven Design and Performance Analysis of Software Agents for Wireless S...Luca Berardinelli
The growing request for high-quality applications for Wireless Sensor Network (WSN) demands model-driven approaches that facilitate the design and the early validation of extra-functional properties by combining design and analysis models. For this purpose, UML and several analysis-specific languages can be chosen and weaved through translational approaches. However, the complexity brought by the underlying technological spaces may hinder the adoption of UML-based approaches in the WSN domain. The recently introduced Foundational UML (fUML) standard provides a formal semantics to a strict UML subset, enabling the execution of UML models.
Leveraging fUML, we realize the Agilla Modeling Framework, an executable fUML model library, to conveniently design agent-based software applications for WSN and analyze their performance through the execution of the corresponding fUML model. A running case study is provided to show our framework at work.
Executable UML Roadmap (as of September 2014)Ed Seidewitz
The document outlines the past, present, and future of executable UML specifications. It discusses foundational UML (fUML) which defines an executable subset of UML, the Action Language for fUML (Alf) which provides a textual notation, and the Precise Semantics of UML Composite Structures (PSCS) which extends fUML for modeling composite structures. It describes open source and commercial implementations of these specifications and notes ongoing work to finalize the specifications and extend them to cover additional UML elements like state machines. The long term vision is for a suite of specifications that define the precise semantics of different aspects of UML to enable executable modeling.
This document provides an overview of the history and development of the Unified Modeling Language (UML) and Foundational UML (fUML) standard for executable modeling. It discusses how UML evolved from its origins in object-oriented analysis and design in the 1980s-1990s to add formal execution semantics definitions. fUML and the Action Language for Foundational UML (Alf) provide a computationally complete subset of UML with a defined execution model, addressing UML's previous lack of precise semantics. The document outlines the key components and implementations of fUML and Alf and their role in specifying UML's structural and behavioral semantics formally.
Programming in UML: An Introduction to fUML and AlfEd Seidewitz
The document discusses programming in UML using the Foundational UML (fUML) standard and the Action Language for fUML (Alf). It provides an overview of fUML and Alf, which define an executable subset of UML and a textual action language for specifying behaviors in UML models. The document uses a motivating example of an e-commerce ordering system to illustrate key concepts of executable UML including activities, actions, structure, and asynchronous communication.
The Unified Modeling Language (UML) has arguably succeeded in becoming the most commonly used modeling notation for software development. But “modeling” in the software community seems largely to mean simply drawing pictures, either to represent the problem domain or to blueprint a solution, without a precise enough meaning to fully specify the functionality of the system being developed. As a result, the UML standard,S up to and including UML 2.4.1, do not define the semantics of UML models at all precisely.
Nevertheless, there has also long been an interest in models that are more precise, even to the extent that they may be executed in their own right. It has taken a while for this viewpoint to penetrate into the mainstream of UML usage. But there has been in a great deal of work in recent years toward the standardization of the formal semantics of UML models – the “meaning” behind the pictures: the Foundational UML (fUML) specification adopted in 2008; the Action Language for fUML (Alf), adopted in 2010; the UML 2.5 specification (which includes a semantics conformance point for the first time); and the Precise Semantics of UML Composite Structures.
This presentation reviews the state of this work and the implications in practice of bringing real meaning to UML.
This is a one day workshop presentation, primarily on the new OMG Foundational UML specification for executable model semantics, but also discussing extensions for executable SysML (System Modeling Language) models.
Programming in UML: An Introduction to fUML 1.3 and Alf 1.1Ed Seidewitz
Based on a tutorial presentation given at the OMG Executable UML Information Day, this version of the presentation has been updated for fUML 1.3 and Alf 1.1, the latest versions as of this upload.
A presentation on the UML 2.5 specification simplification effort, presented at the 3rd Biannual Workshop on Eclipse Open Source Software and OMG Open Specifications.
fUML-Driven Design and Performance Analysis of Software Agents for Wireless S...Luca Berardinelli
The growing request for high-quality applications for Wireless Sensor Network (WSN) demands model-driven approaches that facilitate the design and the early validation of extra-functional properties by combining design and analysis models. For this purpose, UML and several analysis-specific languages can be chosen and weaved through translational approaches. However, the complexity brought by the underlying technological spaces may hinder the adoption of UML-based approaches in the WSN domain. The recently introduced Foundational UML (fUML) standard provides a formal semantics to a strict UML subset, enabling the execution of UML models.
Leveraging fUML, we realize the Agilla Modeling Framework, an executable fUML model library, to conveniently design agent-based software applications for WSN and analyze their performance through the execution of the corresponding fUML model. A running case study is provided to show our framework at work.
The document discusses model-driven development using executable UML models. It addresses perceived issues with making UML models executable and proposes resolutions. The key benefits of executable UML models are that models can be more easily understood than code and kept in sync with development artifacts.
UML has evolved significantly since its origins in the early 1990s through the work of three software pioneers. It is now maintained by the OMG and on its fifth major version. However, UML faces several dilemmas regarding its intended uses and relationship to other modeling languages. Its large and complex specification could be simplified. The future of UML involves standardizing diagram interchange, integrating with other languages through semantic MOF, and "unbundling" UML into smaller, more focused and extensible components.
UML (Unified Modeling Language) was created in the 1990s as a general-purpose modeling language for software engineering. It was developed by Grady Booch, James Rumbaugh, and Ivar Jacobson, known as "the three amigos". UML was later standardized by the Object Management Group and now includes diagrams for modeling software structure, behavior, and architecture. The OMG also established a certification program with three levels to ensure consistent understanding and proficiency with UML.
EclipseCon 2006: Introduction to the Eclipse Modeling FrameworkDave Steinberg
The document introduces the Eclipse Modeling Framework (EMF), which can generate Java implementation code from a model specification to represent object models. EMF includes components for code generation, editing, runtime support, and more. It allows creating models using Ecore, importing models from UML, XML Schema, or Java interfaces. EMF then generates code for the model and provides an API for persistence, editing, validation and other tasks. The document outlines typical usage and how EMF integrates modeling and programming.
EMF is a modeling framework and code generation toolkit for building tools and other applications based on a structured data model. It allows defining a model and mapping it to Java code, providing basic functionality such as loading/saving data and change notification. Models can be defined using Java, UML or XML and EMF provides an API to work with the model programmatically. EMF is used in many Eclipse projects and provides a foundation for model-driven development.
This document provides an introduction to the Unified Modeling Language (UML). It discusses the origins of UML and how it was created through the unification of several object-oriented modeling languages. It then describes the main types of UML diagrams including use case diagrams, activity diagrams, class diagrams, state machine diagrams, and others. For each diagram type, it provides an example diagram and discusses when and how it should be used. The document is intended to teach students about UML and the various diagrams that can be used for software modeling and design.
The TextUML Toolkit is a UML authoring tool that uses a textual notation called TextUML. It focuses on code generation from UML models and is targeted towards developers. The toolkit generates code using code generation tools like Acceleo and supports importing and exporting models from other UML tools. Future plans include bundling Acceleo and addressing feedback for a 1.0 release in June.
EuGENia is a tool that automatically generates the .gmfgraph, .gmftool and .gmfmap models needed to implement a GMF editor from a single annotated Ecore metamodel. EuGENia provides high-level annotations that shield you from the complexity of GMF and lowers the entrance barrier for creating your first GMF editor. While EuGENia is very useful for getting started with GMF, it doesn't stop there and can be used all the way to the final polished version of your editor.
This document discusses a presentation given in 2015 on UML 2.5. It begins with an introduction to why the presentation is being given and references to online resources about UML 2.5. The bulk of the presentation then focuses on providing an overview of the OMG's UML certification process and exams, details on the UML 2.5 specification, and tips for reading the specification and modeling in practice. Examples of certification exam questions are also provided.
Model-driven development uses precise, complete, and executable models as the central artifacts in software development. Technology-independent models can be directly interpreted or used to generate code. The Unified Modeling Language enables model-driven development by supporting the modeling of structure with classes and relationships, dynamics with state machines, and behavior with action semantics - a textual notation for specifying the behavior of basic modeling elements like actions, activities, and data flows.
The document discusses OMG model transformation standards being implemented in Eclipse, including QVT Relations and MTL. It describes Obeo's work on these projects, challenges around standardization and interoperability, and ambiguities in the OMG specifications being addressed.
The document discusses Object Oriented Analysis and Design (OOAD) using the Unified Modeling Language (UML). It provides an introduction to the UML, explaining that it was created to provide a common language for software engineering. The UML can be used within various development processes, such as the waterfall model, spiral model, iterative frameworks, and Rational Unified Process. The document then covers object orientation concepts, an overview of UML diagrams, and how UML can be applied during analysis and design phases of the software development lifecycle.
The Unified Modeling Language (UML) is a family of graphical notations used to describe and design software systems. UML was created in the 1990s to standardize modeling languages for object-oriented systems. It is maintained by the Object Management Group and includes diagram types like class, sequence, activity, and state diagrams. UML can be used for conceptual modeling, software design, code generation, and other applications throughout the software development lifecycle.
UML (Unified Modeling Language) is a standardized modeling language used to visualize, specify, construct, and document artifacts of a software system. It provides a common language for describing systems across different stakeholders. UML includes various building blocks like classes, interfaces, use cases, etc. and relationships between them. It also defines diagram types like class diagrams, sequence diagrams, etc. to group related elements. UML aims to be precise, unambiguous, and complete in modeling systems.
6 - Architetture Software - Model transformationMajong DevJfu
This document discusses model transformations in Model-Driven Architecture (MDA). It defines computation independent models (CIMs), platform independent models (PIMs), and platform specific models (PSMs). It explains that model transformations are used to map between these different abstraction levels and ensure consistency. It also discusses model mappings, approaches to transformations, and tools like EMF and ATL that support transformations in Eclipse.
The document discusses Unified Modeling Language (UML) diagrams. It describes the different types of UML diagrams including class diagrams, package diagrams, object diagrams, use case diagrams, deployment diagrams, statechart diagrams, and activity diagrams. It also outlines the various notations used to represent different modeling elements in UML like classes, objects, interfaces, packages, nodes, actors, states, and relationships between elements.
C++ basics include object-oriented programming concepts like encapsulation, inheritance and polymorphism. Functions can be overloaded in C++ by having the same name but different parameters. Variables have scope depending on whether they are local, global or block variables. Inline functions avoid function call overhead by copying the function code directly into the calling code. Recursion allows functions to call themselves, which can be useful for computing things like factorials.
The document discusses several key principles of domain-driven design:
1. Developers and domain experts should use a shared language to improve communication and understanding. This language should be reflected consistently throughout all documentation and conversations.
2. The domain model code represents the conceptual model and should be kept separate from other concerns like the user interface. It is important for the model to be relevant to both the problem domain and implementation.
3. Understanding the domain comes from implementation experience, not just analysis. The model evolves through collaboration between all teams rather than being handed down separately.
Præsentationen blev holdt ved InfinIT-konferencen SummIT 2013, der blev afholdt den 22. maj 2013 på Axelborg i København. Læs mere om konferencen her: http://www.infinit.dk/dk/arrangementer/tidligere_arrangementer/summit_2013.htm
This document describes a tutorial on advanced ATL techniques including model refactoring. The tutorial agenda includes an introduction to model transformations using ATL, exercises on model visualization, refactoring, and compiling a DSL, as well as discussions of ATL architecture and industrialization. The document provides examples of using ATL to transform a class diagram metamodel to a relational database metamodel.
The document discusses the need for an executable version of the Unified Modeling Language (UML) called xUML. It notes that while UML 1.x describes system behavior, it is not fully executable because it lacks precise semantics for actions. xUML addresses this by defining a precise action semantics language and process to allow UML models to be executed, validated, and automatically generated into code. An executable UML provides benefits like early verification of requirements, improved quality through objective criteria, and more fun for analysts.
This document provides an overview of the Unified Modeling Language (UML) including its history, goals, diagrams, versions, and disadvantages. UML was created in the 1990s through the unification of three older modeling languages and is now managed by the Object Management Group. It uses graphical notations to model software systems and includes diagrams like use case diagrams, class diagrams, sequence diagrams, and state diagrams. The latest version is UML 2.0 and it is used to model large, complex systems across many industries.
The document discusses model-driven development using executable UML models. It addresses perceived issues with making UML models executable and proposes resolutions. The key benefits of executable UML models are that models can be more easily understood than code and kept in sync with development artifacts.
UML has evolved significantly since its origins in the early 1990s through the work of three software pioneers. It is now maintained by the OMG and on its fifth major version. However, UML faces several dilemmas regarding its intended uses and relationship to other modeling languages. Its large and complex specification could be simplified. The future of UML involves standardizing diagram interchange, integrating with other languages through semantic MOF, and "unbundling" UML into smaller, more focused and extensible components.
UML (Unified Modeling Language) was created in the 1990s as a general-purpose modeling language for software engineering. It was developed by Grady Booch, James Rumbaugh, and Ivar Jacobson, known as "the three amigos". UML was later standardized by the Object Management Group and now includes diagrams for modeling software structure, behavior, and architecture. The OMG also established a certification program with three levels to ensure consistent understanding and proficiency with UML.
EclipseCon 2006: Introduction to the Eclipse Modeling FrameworkDave Steinberg
The document introduces the Eclipse Modeling Framework (EMF), which can generate Java implementation code from a model specification to represent object models. EMF includes components for code generation, editing, runtime support, and more. It allows creating models using Ecore, importing models from UML, XML Schema, or Java interfaces. EMF then generates code for the model and provides an API for persistence, editing, validation and other tasks. The document outlines typical usage and how EMF integrates modeling and programming.
EMF is a modeling framework and code generation toolkit for building tools and other applications based on a structured data model. It allows defining a model and mapping it to Java code, providing basic functionality such as loading/saving data and change notification. Models can be defined using Java, UML or XML and EMF provides an API to work with the model programmatically. EMF is used in many Eclipse projects and provides a foundation for model-driven development.
This document provides an introduction to the Unified Modeling Language (UML). It discusses the origins of UML and how it was created through the unification of several object-oriented modeling languages. It then describes the main types of UML diagrams including use case diagrams, activity diagrams, class diagrams, state machine diagrams, and others. For each diagram type, it provides an example diagram and discusses when and how it should be used. The document is intended to teach students about UML and the various diagrams that can be used for software modeling and design.
The TextUML Toolkit is a UML authoring tool that uses a textual notation called TextUML. It focuses on code generation from UML models and is targeted towards developers. The toolkit generates code using code generation tools like Acceleo and supports importing and exporting models from other UML tools. Future plans include bundling Acceleo and addressing feedback for a 1.0 release in June.
EuGENia is a tool that automatically generates the .gmfgraph, .gmftool and .gmfmap models needed to implement a GMF editor from a single annotated Ecore metamodel. EuGENia provides high-level annotations that shield you from the complexity of GMF and lowers the entrance barrier for creating your first GMF editor. While EuGENia is very useful for getting started with GMF, it doesn't stop there and can be used all the way to the final polished version of your editor.
This document discusses a presentation given in 2015 on UML 2.5. It begins with an introduction to why the presentation is being given and references to online resources about UML 2.5. The bulk of the presentation then focuses on providing an overview of the OMG's UML certification process and exams, details on the UML 2.5 specification, and tips for reading the specification and modeling in practice. Examples of certification exam questions are also provided.
Model-driven development uses precise, complete, and executable models as the central artifacts in software development. Technology-independent models can be directly interpreted or used to generate code. The Unified Modeling Language enables model-driven development by supporting the modeling of structure with classes and relationships, dynamics with state machines, and behavior with action semantics - a textual notation for specifying the behavior of basic modeling elements like actions, activities, and data flows.
The document discusses OMG model transformation standards being implemented in Eclipse, including QVT Relations and MTL. It describes Obeo's work on these projects, challenges around standardization and interoperability, and ambiguities in the OMG specifications being addressed.
The document discusses Object Oriented Analysis and Design (OOAD) using the Unified Modeling Language (UML). It provides an introduction to the UML, explaining that it was created to provide a common language for software engineering. The UML can be used within various development processes, such as the waterfall model, spiral model, iterative frameworks, and Rational Unified Process. The document then covers object orientation concepts, an overview of UML diagrams, and how UML can be applied during analysis and design phases of the software development lifecycle.
The Unified Modeling Language (UML) is a family of graphical notations used to describe and design software systems. UML was created in the 1990s to standardize modeling languages for object-oriented systems. It is maintained by the Object Management Group and includes diagram types like class, sequence, activity, and state diagrams. UML can be used for conceptual modeling, software design, code generation, and other applications throughout the software development lifecycle.
UML (Unified Modeling Language) is a standardized modeling language used to visualize, specify, construct, and document artifacts of a software system. It provides a common language for describing systems across different stakeholders. UML includes various building blocks like classes, interfaces, use cases, etc. and relationships between them. It also defines diagram types like class diagrams, sequence diagrams, etc. to group related elements. UML aims to be precise, unambiguous, and complete in modeling systems.
6 - Architetture Software - Model transformationMajong DevJfu
This document discusses model transformations in Model-Driven Architecture (MDA). It defines computation independent models (CIMs), platform independent models (PIMs), and platform specific models (PSMs). It explains that model transformations are used to map between these different abstraction levels and ensure consistency. It also discusses model mappings, approaches to transformations, and tools like EMF and ATL that support transformations in Eclipse.
The document discusses Unified Modeling Language (UML) diagrams. It describes the different types of UML diagrams including class diagrams, package diagrams, object diagrams, use case diagrams, deployment diagrams, statechart diagrams, and activity diagrams. It also outlines the various notations used to represent different modeling elements in UML like classes, objects, interfaces, packages, nodes, actors, states, and relationships between elements.
C++ basics include object-oriented programming concepts like encapsulation, inheritance and polymorphism. Functions can be overloaded in C++ by having the same name but different parameters. Variables have scope depending on whether they are local, global or block variables. Inline functions avoid function call overhead by copying the function code directly into the calling code. Recursion allows functions to call themselves, which can be useful for computing things like factorials.
The document discusses several key principles of domain-driven design:
1. Developers and domain experts should use a shared language to improve communication and understanding. This language should be reflected consistently throughout all documentation and conversations.
2. The domain model code represents the conceptual model and should be kept separate from other concerns like the user interface. It is important for the model to be relevant to both the problem domain and implementation.
3. Understanding the domain comes from implementation experience, not just analysis. The model evolves through collaboration between all teams rather than being handed down separately.
Præsentationen blev holdt ved InfinIT-konferencen SummIT 2013, der blev afholdt den 22. maj 2013 på Axelborg i København. Læs mere om konferencen her: http://www.infinit.dk/dk/arrangementer/tidligere_arrangementer/summit_2013.htm
This document describes a tutorial on advanced ATL techniques including model refactoring. The tutorial agenda includes an introduction to model transformations using ATL, exercises on model visualization, refactoring, and compiling a DSL, as well as discussions of ATL architecture and industrialization. The document provides examples of using ATL to transform a class diagram metamodel to a relational database metamodel.
The document discusses the need for an executable version of the Unified Modeling Language (UML) called xUML. It notes that while UML 1.x describes system behavior, it is not fully executable because it lacks precise semantics for actions. xUML addresses this by defining a precise action semantics language and process to allow UML models to be executed, validated, and automatically generated into code. An executable UML provides benefits like early verification of requirements, improved quality through objective criteria, and more fun for analysts.
This document provides an overview of the Unified Modeling Language (UML) including its history, goals, diagrams, versions, and disadvantages. UML was created in the 1990s through the unification of three older modeling languages and is now managed by the Object Management Group. It uses graphical notations to model software systems and includes diagrams like use case diagrams, class diagrams, sequence diagrams, and state diagrams. The latest version is UML 2.0 and it is used to model large, complex systems across many industries.
The road ahead for architectural languages [ACVI 2016]Ivano Malavolta
5th of April 2016. My presentation done at the 3rd Architecture Centric Virtual Integration Workshop (ACVI) workshop, co-located with WICSA and Comparch 2016, Venice, Italy.
Accompanying paper: http://www.ivanomalavolta.com/files/papers/IEEESoftware_2015.pdf
The document introduces the Unified Modeling Language (UML) as a common language for visual modeling in software engineering. UML can be used to model systems ranging from enterprise systems to embedded systems. It provides standard visual notations for specifying, constructing, and documenting artifacts of a software system, including use case diagrams, class diagrams, sequence diagrams, and state machine diagrams. UML models can be used for forward engineering code from designs or reverse engineering designs from existing code.
This document discusses various common mechanisms in UML structural modeling including specifications, adornments, common divisions, extensibility mechanisms, stereotypes, tagged values, and constraints. It provides examples of how to use notes, stereotypes, tagged values, and constraints in UML class diagrams to annotate elements with additional information.
The document is a slide presentation on UML modeling and profiling from a software engineering course. It introduces UML and the concepts of metamodeling. It explains that UML is used to specify, visualize, construct and document software system artifacts. The presentation then outlines the typical steps in UML modeling: 1) modeling use cases, 2) modeling system structure with classes and components, and 3) modeling deployment to hardware nodes.
The document provides an overview of the Unified Modeling Language (UML). UML is a general-purpose modeling language used in software engineering. It includes various diagram types for visualizing different aspects of a system, such as use case diagrams, class diagrams, sequence diagrams, activity diagrams, and state machine diagrams. The document describes each of these diagram types and provides examples to illustrate how they are used in UML modeling.
This document provides an introduction to object-oriented programming concepts including classes, objects, encapsulation, inheritance, and polymorphism. It defines a class as a blueprint for creating objects with data fields and methods. An object is an instance of a class that stores its own set of data and behaviors. Encapsulation, inheritance, and polymorphism are described as key principles of OOP. Common programming paradigms like procedural, object-oriented, functional, and declarative are also overviewed.
The document introduces Unified Modeling Language (UML) as a standard modeling language used to express and design software systems. UML uses basic building blocks like model elements, relationships, and diagrams to create complex structures for modeling. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, and deployment diagrams. Class diagrams specifically model the static structure of a system by showing classes, interfaces, attributes, operations, and relationships between model elements.
What is UML (Unified Modeling Language)?Eliza Wright
What is UML? Read our guide to learn all the answers, including which diagrams are made with the Unified Modeling Language and how you can create UML diagrams of your own.
Swift is a new programming language developed by Apple as a replacement for Objective-C. It incorporates modern programming language design and borrows concepts from other languages like Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and more. Swift code is compiled with the LLVM compiler to produce optimized native code and works seamlessly with existing Objective-C code and Cocoa frameworks. It focuses on performance, safety, and ease of use through features like type safety, modern control flow syntax, and interactive playgrounds.
Distributed Model Validation with EpsilonSina Madani
Scalable performance is a major challenge with current model management tools. As the size and complexity of models and model management programs increases and the cost of computing falls, one solution for improving performance of model management programs is to perform computations on multiple computers. The developed prototype demonstrates a low-overhead data-parallel approach for distributed model validation in the context of an OCL-like language. The approach minimises communication costs by exploiting the deterministic structure of programs and can take advantage of multiple cores on each (heterogenous) machine with highly configurable computational granularity. Performance evaluation shows linear improvements with more machines and processor cores, being up to 340x faster than the baseline sequential program with 88 computers.
TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. It adds static typing and structuring mechanisms like classes, interfaces, and modules to JavaScript to help catch errors and provide better documentation for large scale JavaScript application development. Some key features of TypeScript include optional static types for functions and variables, classes with inheritance and static methods, interfaces, modules, generics, and type inference.
The document discusses Unified Modeling Language (UML) diagrams. It provides information on static and dynamic UML models and describes common UML diagram types including use case diagrams, class diagrams, sequence diagrams, collaboration diagrams, statechart diagrams, activity diagrams, component diagrams and deployment diagrams. The key purpose of UML modeling is communication and simplification of complex systems through visual representation.
This document provides an introduction to the Unified Modeling Language (UML) and the modeling tool Rational Rose. It defines UML as a standardized modeling language used to communicate software designs. It describes the different types of UML diagrams and their syntax. It also introduces Rational Rose as a tool for creating and maintaining UML diagrams and models. The document discusses how to use various features of Rational Rose like the browser, documentation windows, and specifications. It provides examples of UML use case diagrams and how to add documentation to model elements. It concludes with some pitfalls to avoid when using UML.
The document discusses modeling different aspects of software systems using UML diagrams. It covers modeling events using state machines, the four types of events that can be modeled in UML (signals, calls, time, and state change), modeling logical database schemas using class diagrams, modeling source code using artifact diagrams, modeling executable releases using artifact diagrams to show deployment artifacts and relationships, and modeling physical databases by defining tables for classes while considering inheritance relationships.
This document provides an introduction to CoreML, Apple's framework for integrating machine learning models into iOS, macOS, tvOS, and watchOS apps. It discusses what CoreML is, how to convert existing models into the CoreML format using tools like CoreML Tools and TensorFlow converters, and how to use models with CoreML in apps. Examples are provided of using CoreML for tasks like image classification and text prediction.
Similar to Code Generation 2014 - ALF, the Standard Programming Language for UML (20)
AI Fusion Buddy Review: Brand New, Groundbreaking Gemini-Powered AI AppGoogle
AI Fusion Buddy Review: Brand New, Groundbreaking Gemini-Powered AI App
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-fusion-buddy-review
AI Fusion Buddy Review: Key Features
✅Create Stunning AI App Suite Fully Powered By Google's Latest AI technology, Gemini
✅Use Gemini to Build high-converting Converting Sales Video Scripts, ad copies, Trending Articles, blogs, etc.100% unique!
✅Create Ultra-HD graphics with a single keyword or phrase that commands 10x eyeballs!
✅Fully automated AI articles bulk generation!
✅Auto-post or schedule stunning AI content across all your accounts at once—WordPress, Facebook, LinkedIn, Blogger, and more.
✅With one keyword or URL, generate complete websites, landing pages, and more…
✅Automatically create & sell AI content, graphics, websites, landing pages, & all that gets you paid non-stop 24*7.
✅Pre-built High-Converting 100+ website Templates and 2000+ graphic templates logos, banners, and thumbnail images in Trending Niches.
✅Say goodbye to wasting time logging into multiple Chat GPT & AI Apps once & for all!
✅Save over $5000 per year and kick out dependency on third parties completely!
✅Brand New App: Not available anywhere else!
✅ Beginner-friendly!
✅ZERO upfront cost or any extra expenses
✅Risk-Free: 30-Day Money-Back Guarantee!
✅Commercial License included!
See My Other Reviews Article:
(1) AI Genie Review: https://sumonreview.com/ai-genie-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
#AIFusionBuddyReview,
#AIFusionBuddyFeatures,
#AIFusionBuddyPricing,
#AIFusionBuddyProsandCons,
#AIFusionBuddyTutorial,
#AIFusionBuddyUserExperience
#AIFusionBuddyforBeginners,
#AIFusionBuddyBenefits,
#AIFusionBuddyComparison,
#AIFusionBuddyInstallation,
#AIFusionBuddyRefundPolicy,
#AIFusionBuddyDemo,
#AIFusionBuddyMaintenanceFees,
#AIFusionBuddyNewbieFriendly,
#WhatIsAIFusionBuddy?,
#HowDoesAIFusionBuddyWorks
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
E-commerce Application Development Company.pdfHornet Dynamics
Your business can reach new heights with our assistance as we design solutions that are specifically appropriate for your goals and vision. Our eCommerce application solutions can digitally coordinate all retail operations processes to meet the demands of the marketplace while maintaining business continuity.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
Transform Your Communication with Cloud-Based IVR SolutionsTheSMSPoint
Discover the power of Cloud-Based IVR Solutions to streamline communication processes. Embrace scalability and cost-efficiency while enhancing customer experiences with features like automated call routing and voice recognition. Accessible from anywhere, these solutions integrate seamlessly with existing systems, providing real-time analytics for continuous improvement. Revolutionize your communication strategy today with Cloud-Based IVR Solutions. Learn more at: https://thesmspoint.com/channel/cloud-telephony
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
Odoo ERP software
Odoo ERP software, a leading open-source software for Enterprise Resource Planning (ERP) and business management, has recently launched its latest version, Odoo 17 Community Edition. This update introduces a range of new features and enhancements designed to streamline business operations and support growth.
The Odoo Community serves as a cost-free edition within the Odoo suite of ERP systems. Tailored to accommodate the standard needs of business operations, it provides a robust platform suitable for organisations of different sizes and business sectors. Within the Odoo Community Edition, users can access a variety of essential features and services essential for managing day-to-day tasks efficiently.
This blog presents a detailed overview of the features available within the Odoo 17 Community edition, and the differences between Odoo 17 community and enterprise editions, aiming to equip you with the necessary information to make an informed decision about its suitability for your business.
OpenMetadata Community Meeting - 5th June 2024OpenMetadata
The OpenMetadata Community Meeting was held on June 5th, 2024. In this meeting, we discussed about the data quality capabilities that are integrated with the Incident Manager, providing a complete solution to handle your data observability needs. Watch the end-to-end demo of the data quality features.
* How to run your own data quality framework
* What is the performance impact of running data quality frameworks
* How to run the test cases in your own ETL pipelines
* How the Incident Manager is integrated
* Get notified with alerts when test cases fail
Watch the meeting recording here - https://www.youtube.com/watch?v=UbNOje0kf6E
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
2. 1. Are you familiar with Java or C++?
Java
C++
No
2. Is your focus on technical or legacy software solutions?
Technical (e.g. operating systems, embedded solutions, mission critical systems)
Legacy (e.g. business applications, web applications, desktop / frontend solutions, databases)
3. What is the average software life-cycle duration of your solution?
< 10 years
10 – 20 years
> 20 years
4. What is the average team size of your software projects?
< 10 team members
10 – 30 team members
31 – 100 team members
>100 team members
3. • Models are abstractions of the real world.
• Textual or graphical notations
• Programming may be seen as a kind of modeling.
• A manual written software solution works according to the mental
model of the developer (hopefully).
• “A programming language is a modeling language for creating models
of execution”*.
• “Models are for people, programs are for machines”.
• Goal: better integration of modeling/abstraction and programming
• Better tool support for abstraction, verification, simulation, standardization, code generation, ….
4. • A mission critical application is essential to the
survival of a business or organization.
• A mission critical application
must be rigorously tested ($$$$$).
• A productive software solution that
is essential (or very expensive to be
replaced) will last a long time.
• Well known example:
FORTRAN code for the missions to the moon is still in use. (50 years)
5. • For vitally important scenarios it makes
sense to verify the promised
functionality by a simulation.
• Usually it is very expensive to do a real-
life simulation.
e.g. a crash test dummy costs 100,000.- €
… and a lot of real cars have to be crashed!
• Software allows an upfront testing in a
virtual, non-physical environment.
• Goal: from informal unit tests to
validated and documented simulation
results.
6. • There are some efficient, proprietary simulation
tools for specific technical domains
(e.g. LabView), but there are only a few
platform-independent and standardized
solutions.
• The OMG standards provide well
established notations to specify a platform-
and language independent static and
behavioral software design.
• E.g. static modeling using SysML Block / UML Class diagrams.
• E.g. dynamic modeling using Activity diagrams.
• Problem 1: Graphical notations are not good for detailed modeling.
• Problem 2: The notation needs to be precise enough to be executed.
• Problem 3: It is difficult to make the model detailed enough for execution while keep it
simple enough for human communication.
ALF, a standardized action language based on a standardized
execution model.
7. • Usage of standards participates to cost and risk reduction.
• By making easier communication/exchanges between various
stakeholders involved in the development process.
• Standards enable vendor
independence and tool
interoperability.
• Users have a choice of different vendors
(no vendor “lock-in”)
• A higher availability of
educated engineers
8. • Vision: certified design and simulation tools guarantee a deterministic
behavior of the development and simulation environment.
• Using the certified development tools the behavior of the resulting
software solution can be platform-independently assured and
reproduced.
• Design and behavior specifications can be
interchanged between tools that comply
to a common conformance level.
Delivery of fully-functional, platform-
independent, reusable software components.
9.
10. • In 1998, the OMG issued the RFP for
Action Semantics for the UML.
• In 2003, the OMG issued the first guide to its
Model Driven Architecture (MDA).
• Increased the importance of making models more precise and to validate them
• In 2005, the OMG issued the RFP for the
Semantics of a Foundational Subset for
Executable UML Models (fUML).
• In 2008, the OMG issued the RFP for the
Concrete Syntax for a UML Action Language (ALF).
• In 2011, fUML 1.0 was finalized.
• The fUML specification does not provide any surface syntax.
• In 2013, ALF 1.0.1 and fUML 1.1 were finalized (current versions).
11. • UML2.5 (2013)
• Complete revision of its text description to simplify its presentation and disambiguate as much as
possible its semantics.
• fUML (2013)
• Foundational UML (fUML) is an executable subset of standard UML with formal/operational
semantics.
• Alf (2013)
• Textual surface representation for UML modeling elements with the primary purpose of acting as
the surface notation for specifying executable (fUML) behaviors within an overall graphical UML
model.
• Also provides an extended textual notation for structural modeling within the Fuml subset.
• Precise semantics of UML Composite Structures RFP (2015?)
• Solicit a new specification defining a precise semantics for UML composite structures and their
extensions.
12. The surface syntax ALF is expressively enough to arbitrary switch
between textual and graphical modeling.
13. • Alf has a largely C-legacy (“Java like”) syntax, since that is most familiar to the community that programs
detailed behaviors.
• Alf allows UML textual syntax when it exists
• e.g. colon syntax for typing, double colon syntax for name qualification, etc.
• Alf does not require graphical models to change in order to accommodate use of the action language
• e.g. special characters are allowed in names, arbitrary names are allowed for constructors, etc.
• Alf maps to the fUML subset in order to provide its execution semantics, but it is usable in context of models
not limited to the fUML subset.
• Alf provides a naming system that is based on UML namespaces for referencing elements outside of an activity
but also provides for the consistent use of local names to reference flows of values within an activity.
• Alf uses an implicit type system that allows but does not require the explicit declaration of typing within an
activity, always providing for static type checking, based at least on typing declared in the structural model
elements.
• Alf has the expressivity of OCL in the use and manipulation of sequences of values. These sequence
expressions are fully executable in terms of fUML expansion regions, allowing the simple and natural
specification of highly concurrent computations.
• While the primary goal of Alf is to be an action language, Alf also provides concrete syntax for structural
modeling, largely within the bounds of the fUML subset.
14. UML colon type syntax
with direction specifier
Recursion on a shared
data structure.
15. … but you are also free to use some functional add-ons
16. • Simple names, similar to java
e.g. Example, _example, A1, a1, a__
• Unrestricted names, characters surrounded with
single quotes
e.g. ‘Jürgen Mutschall‘, ‘On/Off switch‘, ‘+‘,
‘escaping * fn‘
• A lot of reserved words
abstract, accept, active, activity, allInstances, any, as, assoc, break, case,
class, classify, clearAssoc, compose, createLink, datatype, default,
destroyLink, do, else, enum, for, from, hastype, if, import, in, inout,
instanceof, let, namespace, new, nonunique, null, or, ordered, out, package,
private, protected, public, receive, redefines, reduce, return, sequence,
specializes, super, signal, switch, this, to, while
17. • Boolean Literals
true, false
• Natural Literals
e.g. 1234, 0, 0b1010111000010000,
0B0100_1010_0101_1011, 0xAE10, 0X4a_5b, 057410,
0_045_133
• Unbounded Value Literal
*
• String Literals
"This is a string.“,
"This is a string with a quote character (") in it."
"This is a string with a new line (n) in it."
18. • Written with the well-known “<“ “>“
• e.g. Set<Integer>
• No partial binding
• The binding must specify an actual element for every template
parameter of the template.
• The element being bound must not have template parameters of its
own.
• Copy Semantics, all templates are expanded by lexical
replacement
• Standardized Name mapping: e.g. Set<Integer> is mapped to
$$Set__UML$AuxiliaryConstructs$PrimitiveTypes$Integer__
19. “//” eol end-of-line comment
lexical comment
“/*” “*/” in-line comment
lexical comment
“//@” eol statement annotation
execution directives (do not confuse with stereotype annotations)
“/**” “*/” documentation comment
stored in the model
“/*@” “*/” inline code block
arbitrary embedded/inline code
20. • A name is used to identify a named element.
• Named elements may be member of a namespace (itself a
named element)
• A named element can be accessed from the outside by a
qualified name
Attention: a local name is never qualified
• The separator of a qualified name may be a “::“ or „.“
• Ordering::Order::customer or Ordering.Order.customer
• FoundationalModelLibrary::BasicInputOutput or
FoundationalModelLibrary.BasicInputOutput
• Set<Integer>
• Map<K=>String, V=>Entry>
• Map<String,Entry>.KeySet
• List< List<String> >
• CollectionClasses::Set<Integer>::add
21. • In the sense of an UML „value specification“
• An expression either has a statically determined type or
can be statically determined to be untyped, denoted by
the keyword any.
• An expression also has a statically determined
multiplicity.
* if unbounded
• Almost all expression can be evaluated concurrently
by design
See ALF Spec: “Local Names and Assigned Sources”,
mapping variables to data flow
22.
23. • Public imports reexport the imported named element as a member of the
containing namespace
public import ProductSpecification::Product as Prod; // Import with alias
package Ordering { // Namespace definition
…
}
• In this case, within the Ordering namespace, the unqualified name for
ProductSpecification::Product is Prod, not Product.
• Since the import is public, outside Ordering the qualified name
Ordering::Prod can be used to refer to the same element as
ProductSpecification::Product.
• Prevents from namespace pollution and the typical name conflicts during mappings
• e.g. mapping from a Xtext grammar to ALF syntax structures to fUML structures
(3 times a “ClassDefinition” with cross-refs in three namespaces)
25. • ALF does NOT support interfaces, but has multiple inheritance!!!
Class
26. • In the above example, the activity getSingleton is nested in the class Singleton. Because of
this, it has visibility to the private constructor for Singleton, which is not visible outside of the
class.
27. • An active class is one whose instances (active objects) have
independent threads of control.
• When a contrast is necessary, a class that is non-active may be
referred to as a passive class.
• An active class may have attributes, operations and nested
classifiers, just like a passive class. However, only an active
class may have receptions as features and only active objects
may receive signals.
Active Classes
active object
instance of
active class A
active object
instance of
active class B
passive
objects
passive
objects
30. • An association is a classifier that specifies a semantic relationship that
may exist between two or more instances. The instances of an
association are known as links. The features of an association must all
be properties.
Association
31.
32. • A property is a structural feature of a classifier.
• The attributes of classes, data types and signals are properties, as are the association ends of an association.
• declares a property that can hold zero or more objects of type Item in an ordered sequence. If the multiplicity is [0..*], then a
shorter form can also be used in which the range 0..* is implicit:
• In addition, the single keyword “sequence” may be used in place of the combination of the two keywords “ordered” and
“nonunique”.
• If a property definition includes the keyword “compose”, then it is considered to be a composition of the values it holds. This
has semantic implications when an instance of the owning classifier of the property is destroyed .
• When an instance of class C is destroyed, the object it holds for attribute b will also be automatically destroyed, but the object
it holds for attribute a will not.
33.
34. Note that, in this case, it would be illegal to redefine only one of A::p
and B::p with an indistinguishable operation, since then the other
superclass operation would still be inherited and would conflict with the
redefining operation in C.
35. let interest : CurrencyAmount = this.principal *
this.rate * period;
In the second form, the type name precedes the local name:
CurrencyAmount interest = this.principal * this.rate
* period;
Also allowed:
interest = this.principal * this.rate * period;
36. • A constructor is an operation, specially identified using the @Create
stereotype annotation and used to initialize a newly created object.
37. • If an object creation expression is not constructorless, then, in addition to creating
an object, evaluation of the expression calls the identified constructor on the newly
created object. If a constructor is explicitly named in the expression, then that is the
constructor that is called.
new Employee::transferred(employeeInfo)
creates an object of the class Employee and calls the constructor transferred
on that object with the argument employeeInfo.
• If the object creation expression names a class, then the constructor called is one
with the same name as the class.
new Employee(id, name)
is equivalent to new Employee::Employee(id, name)
• Finally, if the class of the object being created is active, then the classifier behavior
for that class is automatically started once the object is created and after any
constructor call completes.
38. activity A(in x: Integer, in y: Boolean[0..1])
• Invocation of this activity with a positional tuple
A(1, true)
• Argument 1 corresponds to the parameter x and the argument true corresponds to the parameter y.
This is equivalent to the invocation with the named tuple:
A(x=>1, y=>true)
• With a named tuple, the order of the arguments may be changed
A(y=>true, x=>1)
• Since the parameter y is optional (multiplicity lower bound of 0), no argument needs to be provided for it at all in the named
tuple notation.
A(x=>1)
• is equivalent to
A(1)
• is equivalent to
A(1, null)
39.
40. • A sequence property access expression of the form
primary.name
is equivalent to the collect expression
primary -> collect x (x.name)
• It is not an error for the result of the target expression in a property access
expression to be empty. In this case, the property access expression evaluates to an
empty sequence.
41. • A sequence reduction expression is used to reduce a sequence of values to a single value by
combining the elements of the sequence using a binary operator.
• A sequence reduction expression has a similar syntax to a sequence operation expression in that it
starts with a primary expression followed by the “flow” symbol “->”.
• This is then followed by the keyword reduce and the qualified name of a behavior that acts as the
binary operator over elements of the sequence.
• As for sequence operation expressions, sequence reduction expressions also allow the special
notation in which a class name is used as a shorthand for a class extent expression.
42. Can be efficiently implemented by a parallel and/or distributed computing environment.
Operation Description
select Select a sub-sequence of elements for which a condition is true.
reject Select a sub-sequence of elements for which a condition is false.
collect Concurrently apply a computation on each element of a sequence.
iterate Sequentially apply a computation to each element of a sequence.
forAll Test if a condition is true for all elements of a sequence.
exists Test if a condition is true for at least one element of a sequence.
one Test if a condition is true for exactly one element of a sequence.
isUnique Test if a computation has a different value for every element of a sequence.
43. • A link operation expression is used to create or destroy instances of a named association, known as links.
• A link operation expression has a similar syntax to an invocation expression, consisting of a target association
name, a link operation name and a tuple of actual arguments for the link operation.
Operation Description
A.createLink (e1, e2, …) Create a link of association A with end values e1, e2, …
Association A must not be abstract.
A.destroyLink (e1, e2, …) Destroy a link of association A with end values e1, e2, …
A.clearAssoc(e) Destroy all links of association A with at least one end value e.
44. • An activity is “the specification of parameterized behavior as the
coordinated sequencing of subordinate units whose individual elements
are actions”
• It is the fundamental mechanism for behavioral modeling in Alf.
• Activities are namespaces that may be defined as Alf units. Activities
may also be implicitly defined by the in-line specification of behavior
for active classes or operations.
Activity
45. • A signal is a classifier whose instances may be sent asynchronously to an active
object.
• The ability for an object to receive a certain signal is specified using a reception
declaration in the class of the object.
• The features of a signal must all be properties.
Signal
46. • A reception is a behavioral feature of an active class that declares that instances of
the class are prepared to react to the receipt of a specific signal.
• Only active classes may have receptions as features.
• Normally, the signal is defined separately and referenced by name in the reception
declaration.
• As a convenience, Alf also allows the definition of the signal and a declaration of a
reception of it to be combined into a signal reception definition.
47.
48. • An accept statement is used to accept the receipt of one or more
types of signals.
49. • The execution semantics for activities in fUML are inherently concurrent.
• Alf mapping to fUML takes advantage of this concurrency in many
places, particularly in the mapping of expressions.
• E.g. the argument expressions in an operation invocation or an arithmetic
expression are evaluated concurrently, rather than sequentially.
• Does not require the implementation of actual parallelism in a
conforming execution tool.
• It simply means that such parallelism is allowed.
50. • A cast expression is evaluated by first evaluating its operand expression,
producing a sequence of values.
• Any values of the operand expression whose dynamic type does not
conform to the type of the cast expression are filtered out, so that all
result values of the cast expression are of the given type.
• If the cast expression is untyped, then no values are filtered out.
(Integer)any[]{1,"banana",2}
evaluates to
Integer[]{1,2}
51. • The instanceof operator checks if the dynamic type
of its operand conforms to the given type that is, whether
the argument type is the same as or a direct or indirect
subclass of the given type.
• The hastype operator checks
if the dynamic type of its
argument is the same as
the given type.
54. • The isolation operator indicates that its operand expression should be
evaluated in isolation, similarly to the use of the @isolated annotation
for a statement .
• During the evaluation of the operand expression, no object accessed as
part of the evaluation of the expression or as the result of a
synchronous invocation from the expression may be modified by any
action that is not executed as part of the operand expression or as the
result of a synchronous invocation from that expression.
• An isolation expression has the type and multiplicity of its operand
expression.
• See 8.5.3.1 of the fUML Specification for a complete discussion of the
semantics of isolation.
55. • A classify statement is used to dynamically reclassify an already existing
object.
• The statement identifies an already existing object and the classes from
which and/or to which the identified object is to be reclassified.
56. • The class of the object being created must not be abstract, unless all of the following conditions
hold:
• The object creation expression is not constructorless.
• The namespace that owns the class of the constructor also owns a package with the name Impl.
• The Impl package contains a class with the same name as the class of the constructor.
• The Impl class has a constructor that redefines the constructor (which implies that the Impl class
must be a direct or indirect subclass of the class of the constructor).
• If these conditions hold, then the identified Impl class constructor is used instead of the original
abstract class constructor, and the object that is created is actually an instance of the Impl class.
• The above mechanism is intended to allow for the definition of abstract classes in model libraries
that may be directly referenced by user models and constructed as if they were concrete.
• Different execution tools may provide different actual concrete implementations of the library
classes in the nested Impl package of the model library without changing the library classes actually
referenced in user models. In particular, the Alf standard model library collection package uses this
mechanism.
58. • ALF fUML Execution / Simulation
• Semantics of a Foundational Subset for Executable UML Models (fUML),
Version 1.1 , August 2013
• “… the foundational subset defines a basic virtual machine for the Unified
Modeling Language, and the specific abstractions supported thereon, enabling
compliant models to be transformed into various executable forms for
verification, integration, and deployment.” (Chapter 1, fUML spec.)
• Syntactic Conformance: A conforming model must be restricted to the
abstract syntax subset defined for fUML.
• Semantic Conformance: A conforming execution tool must provide
execution semantics for a conforming model consistent with the
semantics specified for fUML.
59. • Abstract Syntax Conformance
• Only syntactic elements that are included in the fUML abstract syntax metamodel
(conformance level specific).
• Meets all constraints imposed on its syntactic elements by the UML 2
Superstructure.
• Model Library Conformance
• If an execution tool provides elements from the fUML model library, they must
conform to the specified behavior.
• If a platform / tool specific library is provided, the execution behavior of elements
of the models in that library may be entirely defined in fUML at the same
conformance level models accepted by the tool.
• Behavioral modeling of the tool by itself
60. The semantic areas below are not explicitly constrained by the execution model:
• The semantics of time
• The execution model is agnostic about the semantics of time.
• The semantics of concurrency
• The execution model includes an implicit concept of concurrent threading of execution.
• It does not require that a conforming execution tool actually execute such concurrent threads in a
physically parallel fashion.
• So long as the execution tool respects the various creation, termination, and synchronization
constraints placed on such threads by the execution model, any sequentially ordered, or partial or
totally parallel, execution of concurrent threads conforms to a legal execution trace.
• The semantics of inter-object communications mechanisms
• The execution model is written as if all communications were perfectly reliable and deterministic.
This is not realistic for all execution tool implementations.
• Semantics of inter-object communication is not predicated on any assumptions about whether or
not such communication is reliable
i.e., that signals and messages are never lost or duplicated, preserves ordering, happens with deterministic or non-
deterministic delays, …
61.
62. • ALF Reference Implementation at
http://modeldriven.org/alf/
• fUML Reference Implementation at
http://portal.modeldriven.org/content/fuml-
reference-implementation-download
• Java standalone open-source implementation to
do conformance checks
• Translates Alf text input files to fUML and executes the fUML with a token based
petri-network execution engine.
• Good starting point to check the conformance of an own implementation.
63. • Performance and scalability
• The debugger / simulator is allowed to be 10 times slower and may consume 10 times more
memory (disk space), but has to manage real-life sized applications.
• As an ”Execution”-Platform (UML Virtual Machine) the generator must
produce production-ready code.
• No token based graph traversal execution model allowed in a real-life products
• Performance, Performance, Performance !!!!
• Support for a platform specific threading model.
• Platform specific, concurrent implementation of the ALF standard library and sequences.
• Compliant to the fUML execution semantics
• Integration of UML runtime code and platform specific runtime code.
• Allows incremental incorporation of ALF based models in existing development environments.
• Still provide the capability to generate pure OMG standards based, fully-tested ALF/fUML-models
and serialize them to XMI.
64. • IDE/Editor support
• In Eclipse context, similar to Java support
• Editing, cross references, code navigation, code completion, etc.
• Integration of General Purpose Languages
• First of all, Java
• Xtend as a Java superset, switch to Java 8 on general availability
• Library support or embedded use
• Debugging support (in work)
• In Eclipse context, similar to Java debugger
• Set breakpoint, step by step debugging,
inspection of object struture and values
• Integration of Graphical Editors (in work)
• In Eclipse context, support for UML2-EMF-based UML editors
• Tight integration of graphical and textual modeling/programming
Meta
65. • Support for MOF
• Reflection as a library for ALF
• Support for the definition of UML profiles
• Profile definition as MOF library use
• Currently not part of the specification.
• Integration into the MetaModules Language Workbench.
• Addition textual support for other OMG standards
• Will also automatically translate to the appropriate diagram type
• Most important:
• BPMN
• IFML
• Urgent need for the additional specification of composites mapping
• Needed for SysML
• “Precise semantics of UML Composite Structures RFP” (finalization 2015?)