First-Class Compositions

Bergmans, Lodewijk; Havinga, Wilke; Akşit, Mehmet

doi:10.1007/978-3-642-35551-6_6

Cited by 2 publications

(1 citation statement)

References 45 publications

(72 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Composition operators supporting these semantics can be provided by reusable libraries. In [1], larger complementary examples of behavioral composition are presented.…”

Section: Freeing Field Access Behavior From Abstractmentioning

confidence: 99%

The keyword revolution

Brinke

Bergmans

Bockisch

2011

Proceedings of the 1st International Workshop on Free Composition

View full text Add to dashboard Cite

An ongoing trend is to develop new mechanisms for composing software modules that resemble the relations between corresponding problem-domain entities and thus enable a natural decomposition of software for an increasing number of problem domains. However, we have observed that today's programming languages hard-wire a fixed set of composition mechanisms, usually in terms of keywords. To overcome this limitation, we have proposed the Co-op approach enabling developers to implement an open-ended number of composition mechanisms as first-class citizens. Extending our previous prototype which focused on the composition of behavior, this paper reports on our prototype Co-op/II which facilitates implementing composition mechanisms for data access. We show that our approach is sufficient to realize several styles, e.g., of sharing data between sub classes, of controlling visibility, and of behavioral modifiers like synchronization of data access, converting or persisting data. PROBLEM STATEMENTTo be able to properly decompose a software system into modules which correspond to the entities of the problem domain, sufficient mechanisms must be provided to compose the modules into a running system again. There is a continuous trend [10] in software engineering research to develop programming languages with composition mechanisms that map to relations between problem-domain entities. Thus a natural decomposition of software is enabled for an increasing number of problem domains. The key to these composition mechanisms is abstraction: Program elements can use others without explicitly referring to their implementation; typically, multiple implementations of an abstraction exist and the execution environment selects one according to well-defined rules.A popular example of a composition mechanism is inheritance, where the behavior of a child class is composed with the behavior of the parent. Already for this well known example, many different variants exist [11]. Examples of other Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.

show abstract

“…Composition operators supporting these semantics can be provided by reusable libraries. In [1], larger complementary examples of behavioral composition are presented.…”

Section: Freeing Field Access Behavior From Abstractmentioning

confidence: 99%

The keyword revolution

Brinke

Bergmans

Bockisch

2011

Proceedings of the 1st International Workshop on Free Composition

View full text Add to dashboard Cite

show abstract

Free Composition Instead of Language Dictatorship

Bergmans

Brinke

Bockisch

et al. 2012

Proceedings of the 7th International Conference on Software Paradigm Trends

View full text Add to dashboard Cite

Abstract:Historically, programming languages have been-benevolent-dictators: reducing all possible semantics to specific ones offered by a few built-in language constructs. Over the years, some programming languages have freed the programmers from the restrictions to use only built-in libraries, built-in data types, and builtin type-checking rules. Even though-arguably-such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility is depriving software engineers of the ability to construct proper abstractions and to structure software in the most optimal way. Therefore the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in a language. We discuss several prototypes of the Co-op language, which show that it is possible, with a relatively simple model, to express a wide range of compositions as first-class concepts. MotivationThe software engineering discipline faces many challenges; one of the important challenges is to cope with the changes that need to be incorporated into software systems during their lifetime. A particular difficulty is that small, local changes in the requirements of a system, often lead to non-local changes in the software. This is caused by the fact that the structure of the implementation tends to be significantly different from the structure of the problem domain.Another software engineering challenge is managing the complexity of software (Royce, 2009). We are building increasingly large software systems. Such systems encompass a substantial amount of inherent complexity; partially in the problem domain and partially in the solution domain. However, the realization of these systems also introduces a large amount of accidental complexity (Brooks, 1987), while going from the conceptual solution to a realization model.A key argument adopted in this paper, and previously coined, e.g., by Brooks (Brooks, 1987), is that the limited ability of realization models to accurately represent the concepts and their interdependencies in a conceptual solution is the main cause of accidental complexity. As a result, the complexity of realizations is typically substantially larger than the complexity of the conceptual solution.In software engineering, a key strategy for dealing with change and managing complexity is "divide and conquer": achieve separation of concerns (Dijkstra, 1976) by dividing a solution into building blocks and delivering working systems by expressing proper compositions of these building blocks. The history of programming and design shows a steady movement towards supporting higher-level abstractions of building blocks and more advanced ways of expressing such compositions. For example, object-oriented and aspect-oriented progr...

show abstract

First-Class Compositions

Cited by 2 publications

References 45 publications

The keyword revolution

The keyword revolution

Free Composition Instead of Language Dictatorship

Contact Info

Product

Resources

About