Nesneye yönelik programlamanın rol modelleri ile genişletilmesi

Gerçek dünyada karşılaşılan sistemler durağan ve dinamik olmak üzere iki kümeye ayrılabilir. Durağan sistemlerin aksine, dinamik sistemlerde zamanla değişen ve evrimleşen varlıklar söz konusudur. Bu şekilde zamanla değişen nesneleri nesneye yönelik programlamanın (NYP) sınıf hiyerarşileri ile modellemek zor olacaktır. Bu zorluğun nedeni, dinamik yapıdaki gerçek dünya varlıklarının durağan yapıdaki sınıflar ile modellenmeye çalışılmasıdır. NYP durağan sınıf yapısına dinamizm katacak yeteneklere sahip olmasına rağmen dinamik sistemlerin modellenmesinde karşılaştığı güçlüklerden tam anlamıyla kurtulamaz. Rol modelleri; dinamik sistemlerin nesneye yönelik programlama ile modellenmesinde karşılaşılan güçlüklerin çözümü için önerilen yollar arasında kullanışlı olmaları, NYP kavramları ile iyi uyuşmaları ve problemin çözümü için dolaysız bir yol sunmaları nedeniyle dikkati çekmektedir. Nesne düzeyinde özelleştirmeye dayanan rol modelleri, sınıf düzeyinde özelleştirmeye dayanan nesneye yönelik programlamayı doğal bir biçimde genişletir. Bu nedenlerle dinamik sistemlerin saf NYP yaklaşımı ile sunulandan daha iyi modellenebilmesi gereksinimini karşılamak üzere, Java programlama diline rol desteği kazandıran bir rol modeli olan JAWIRO (Java with Roles) gerçeklenmiştir. Bu çalışma sırasında rollerin diğer çalışmalarda önerilen özellikleri arasına altı yeni özellik kazandırılmıştır. Bu makalede rollerin JAWIRO rol modeli ile nasıl kullanılabileceğinin anlatılmasına ek olarak, JAWIRO’nun güncel rol modelleri ile rollerin gerçeklenen özellikleri ve çalışma anı başarımı açılarından karşılaştırmaları verilmiştir. Sonuç olarak JAWIRO, sahip olduğu özgün yetenekler ve çalışma anı başarımına ek yük getirmemesi sayesinde dinamik sistemlerin modellenmesi için önemli bir gereç haline gelmiştir. Anahtar Kelimeler: Rol modelleri, rol tabanlı programlama, dinamik sistemlerin modellenmesi, nesneye yönelik programlama

A Pure Embedding of Roles: Exploring 4-dimensional Dispatch for Roles in Structured Contexts

Present-day software systems have to fulfill an increasing number of requirements, which makes them more and more complex. Many systems need to anticipate changing contexts or need to adapt to changing business rules or requirements. The challenge of 21th-century software development will be to cope with these aspects. We believe that the role concept offers a simple way to adapt an object-oriented program to its changing context. In a role-based application, an object plays multiple roles during its lifetime. If the contexts are represented as first-class entities, they provide dynamic views to the object-oriented program, and if a context changes, the dynamic views can be switched easily, and the software system adapts automatically. However, the concepts of roles and dynamic contexts have been discussed for a long time in many areas of computer science. So far, their employment in an existing object-oriented language requires a specific runtime environment. Also, classical object-oriented languages and their runtime systems are not able to cope with essential role-specific features, such as true delegation or dynamic binding of roles. In addition to that, contexts and views seem to be important in software development. The traditional code-oriented approach to software engineering becomes less and less satisfactory. The support for multiple views of a software system scales much better to the needs of todays systems. However, it relies on programming languages to provide roles for the construction of views. As a solution, this thesis presents an implementation pattern for role-playing objects that does not require a specific runtime system, the SCala ROles Language (SCROLL). Via this library approach, roles are embedded in a statically typed base language as dynamically evolving objects. The approach is pure in the sense that there is no need for an additional compiler or tooling. The implementation pattern is demonstrated on the basis of the Scala language. As technical support from Scala, the pattern requires dynamic mixins, compiler-translated function calls, and implicit conversions. The details how roles are implemented are hidden in a Scala library and therefore transparent to SCROLL programmers. The SCROLL library supports roles embedded in structured contexts. Additionally, a four-dimensional, context-aware dispatch at runtime is presented. It overcomes the subtle ambiguities introduced with the rich semantics of role-playing objects. SCROLL is written in Scala, which blends a modern object-oriented with a functional programming language. The size of the library is below 1400 lines of code so that it can be considered to have minimalistic design and to be easy to maintain. Our approach solves several practical problems arising in the area of dynamical extensibility and adaptation

Designing Round-Trip Systems by Change Propagation and Model Partitioning

Software development processes incorporate a variety of different artifacts (e.g., source code, models, and documentation). For multiple reasons the data that is contained in these artifacts does expose some degree of redundancy. Ensuring global consistency across artifacts during all stages in the development of software systems is required, because inconsistent artifacts can yield to failures. Ensuring consistency can be either achieved by reducing the amount of redundancy or by synchronizing the information that is shared across multiple artifacts. The discipline of software engineering that addresses these problems is called Round-Trip Engineering (RTE). In this thesis we present a conceptual framework for the design RTE systems. This framework delivers precise definitions for essential terms in the context of RTE and a process that can be used to address new RTE applications. The main idea of the framework is to partition models into parts that require synchronization - skeletons - and parts that do not - clothings. Once such a partitioning is obtained, the relations between the elements of the skeletons determine whether a deterministic RTE system can be built. If not, manual decisions may be required by developers. Based on this conceptual framework, two concrete approaches to RTE are presented. The first one - Backpropagation-based RTE - employs change translation, traceability and synchronization fitness functions to allow for synchronization of artifacts that are connected by non-injective transformations. The second approach - Role-based Tool Integration - provides means to avoid redundancy. To do so, a novel tool design method that relies on role modeling is presented. Tool integration is then performed by the creation of role bindings between role models. In addition to the two concrete approaches to RTE, which form the main contributions of the thesis, we investigate the creation of bridges between technical spaces. We consider these bridges as an essential prerequisite for performing logical synchronization between artifacts. Also, the feasibility of semantic web technologies is a subject of the thesis, because the specification of synchronization rules was identified as a blocking factor during our problem analysis. The thesis is complemented by an evaluation of all presented RTE approaches in different scenarios. Based on this evaluation, the strengths and weaknesses of the approaches are identified. Also, the practical feasibility of our approaches is confirmed w.r.t. the presented RTE applications