====== OCL and OCL-like languages for embedded systems ======
Essay by Maria Tsvetkova(maantsvetkova@edu.hse.ru)

==== Introduction====
Creating complex software systems is a complex and resource-intensive process. Visual programming offers to simplify this process by using visual models instead of text code. This approach makes development more intuitive and visual, which makes it easier to perceive and analyze the structure and logic of the program. Constraints in systems can be expressed in two ways: informally, in natural language, and formally, using special languages. Informal descriptions are often ambiguous and difficult for computers to interpret. Formal languages eliminate uncertainty and provide clear semantics, which allows both users and computers to clearly understand the constraints.

==== OCL based information ====

OCL (Object Constraint Language) is one of the most widely used languages for formally defining constraints [1]. OCL is developed as an integrated mechanism in UML and provides a textual interface for describing additional constraints and rules for models. The application of this language to embedded system models ensures early error detection and guarantees that the system meets the specified requirements. This allows developers to precisely specify system requirements and verify their correctness. For example, it can be determined that the fuel level in the car should never drop below a critical value. In the context of embedded systems, where errors can have catastrophic consequences, strict specification using OCL is key to preventing its undesirable behavior.
OCL can be used both for querying objects in the model and for defining logical conditions that must be met during the system's operation. Constraints in OCL are defined using a context, which specifies the type of object or method to which the constraint applies, and a logical expression describing the constraint itself [2]. Logical expressions can represent invariants (for classes), preconditions (conditions that must be met before a method is called), and postconditions (conditions that must be met after the method has completed) [3-4]. Failure to meet a precondition or postcondition indicates a violation of a constraint, which may result in an error message, program interruption, or any other error handling.

Let's consider as an example the check that all students in the university must be over 18 years old. Listing 1 shows the models of the system.

{{:arch:2024:0.png?300|}}

Listing 1 - models of the system


Listing 2 shows the OCL expression for checking students for age.


{{:arch:2024:111.png?400|}}

Listing 2 - OCL expression for checking students for age.

In this example, we have two models: university and student. The lines "context University inv:" define the context for the expression, in this case - university. To check that for all elements in the set "students (self.students)", the age property is greater than 18, the lines "self.students->forAll(s | s.age > 18)" are used.
OCL combines formality with ease of use. Unlike complex formal languages, OCL is accessible to developers with varying levels of expertise [5]. Despite the fact that OCL was originally developed for business modeling, it is widely used in other areas as well, including the development of embedded systems and for defining constraints in UML models [6]. OCL helps create clearer, unambiguous, and verifiable models, making the development process more reliable and efficient.

One of the advantages of OCL is that it allows for rigorous model checks before implementation. This is especially important for embedded systems, where errors can lead to serious consequences. For example, in a car engine control system, OCL can be used to verify that the control algorithm never leads to exceeding the permissible engine RPM level, which could cause it to break down, and in the worst case, lead to an accident.
Thanks to the formalization of requirements using OCL, it is possible to avoid errors at the design stage, which leads to the creation of higher quality and more reliable code that is easy to maintain. This means that in the future improvement of the system, there will be no need to rewrite significant amounts of code to fix errors that could arise from a misunderstanding of the requirements, which will save resources in implementing new system functionality.
OCL provides the ability to document constraints in an understandable form, which facilitates the understanding of the project by other team members. This is especially important in large projects where multiple developers work on the code, allowing them to quickly familiarize themselves with the critical conditions and rules of the system to minimize the risk of incompatible changes in the new functionality being developed.
Since OCL is integrated with UML, developers can use the tools and methods they are already familiar with to create and analyze models. This simplifies the process of introducing OCL into the workflow and allows focusing on implementing constraints rather than mastering new tools.
Besides OCL, there are other languages used for formal specification of embedded systems, each with its unique features. For example, Alloy is a language for specifying and verifying relational models, particularly useful for complex systems with many dependencies [7-8]. It allows developers to describe systems using relationships between objects, making it an ideal tool for modeling embedded systems with many interrelated components and complex interaction rules.
There is also Event-B, a rigorous formal method used for modeling and analyzing systems [9-10]. It is based on set theory, allowing systems to be described as a collection of objects and the relationships between them. Event-B uses the concept of refinement, which allows representing a system at different levels of abstraction, from high-level description to detailed implementation. An important feature of Event-B is the ability to apply mathematical proofs to verify consistency between different levels of refinement. This makes Event-B particularly useful for the development of critical systems where correctness and reliability of implementation must be guaranteed.

==== Conclusion ====
Object Constraint Language is designed to clearly define constraints, making models more understandable and reducing the risk of errors during implementation. Using OCL and other OCL-like languages is a powerful tool for developing embedded systems. These languages allow you to formalize requirements, conduct rigorous model verification, and improve the quality of the final product. With the growing complexity of embedded systems and increasing requirements for their safety and reliability, OCL is becoming an increasingly important tool for developers. OCL is a powerful and intuitive language for defining constraints, similar in syntax to Pascal. It offers a convenient way to formalize rules for system models. However, difficulties may arise when implementing complex constraints, and some OCL concepts may not be obvious to beginners. The main disadvantage of OCL is the lack of visual representation. It is based on text syntax, which contradicts the visual concept of UML and other visual programming languages. It is also worth noting that the effectiveness of OCL depends on proper application and requires certain knowledge and experience.  However, for developers looking to create reliable and secure embedded systems, OCL is a powerful tool that helps improve the quality of development and reduce the risk of vulnerabilities appearing in the system.

==== References ====
  - Warmer J.B., Kleppe A.G.: "OCL in Action"
  - Warmer J.B., Kleppe A.G.: "The Object Constraint Language: Getting Your Models Right"
  - "OCL 2.5 Specification": https://www.omg.org/spec/OCL/2.5/
  - Jorgi Cabot: "OCL Tutorial"
  - "OCL Wiki": https://cio-wiki.org/wiki/Object_Constraint_Language_(OCL)
  - Warmer J.B., Kleppe A.G.: "The object constraint language: Precise modeling with UML. Addison-Wesley"
  - Alloy Documentation (MIT): https://alloy.mit.edu/alloy-documentation.html
  - Daniel Jackson: "Alloy: A lightweight object modeling language": https://www.researchgate.net/publication/221670643_Alloy_A_lightweight_object_modeling_language
  - Jean-Raymond Abrial: "Modeling in Event-B: System and Software Engineering"
  - Official site: https://www.event-b.org/