Component Based languages


I am interested in component-based languages. The only one I have found is the Koala component model.

Interested to know if anyone else has experience in other component languages.?


1 Like

Not sure whether this is what you are looking for, but there have been a whole flurry of “architecture description languages” that were intensively researched in the mid-90s or so. This Wikipedia article might be a good starting point: Architecture description language - Wikipedia

Hi @preedman
Not sure if this fits in the category of what you are looking for.
Just in case, Quid deals with components and composition of widgets in the User Interface Space (Web Components), it is not general purpose, but a a DSL (a language for an specific domain).
For more info see tool, docs, video or paper or feel free to ask me directly.

My personal experiences are related to defining ADLs for industry use for companies in automotive, telecom, medical and industry automation.

There is a huge number of architecture description languages (ADLs) targeting different domains and needed. For example, today in automotive there is AUTOSAR (software) and EAST-ADL (functional EE), AADL etc. and these come in different versions and in practice companies also adapt them to their needs (perform language engineering). A good review of ADLs and their nature can be found e.g. A classification and comparison framework for software architecture description languages | IEEE Journals & Magazine | IEEE Xplore. Many ADLs are published as academic so aspects like scalability, tracing, etc. are not necessarily addressed.

When it comes to KOALA, we implemented core parts of it with Rob when working in the same project. If needed, I can try to find its metamodel definition. Koala focuses on structural parts, but these can also address behaviors, like e.g. done in telecom field with SDL, or different DSLs (e.g. in the ports from structural parts are applied when defining behavior).

ToolBus is a prime example. Klint et al 1995

I’ve coded a lot in ToolBus scripts to great satisfaction :slight_smile:

Reo is another component Programming model by Farhad Arbab et al:

Hi Paul,

you may be interested in having a look on my Xtend extension library which implements a component wiring approach.

This follows my article about flow design. It describes a new software design approach with a strict component principle in its heart. We call it the “principle of mutual oblivion”.
In flow design you are wiring components together which are strictly not knowing each other (by not calling each other, because the method call is the main reason for violating this principle).

You can also understand it as another programming paradigm, complementary to the object oriented one and the functional one (it does not replace them!).
It can be applied in every programming language. But of course, as for the functional and for the object oriented paradigms, special language constructs would make the paradigm better readable and recognizable in source code. In my second article I give an outlook how this language constructs could look like (after showing, how it could be applied in Java).

Currently, I’m designing a language (with Xtext) which tries to implement these language constructs in a new language similar to Xtend or Kotlin (as multi-paradigm languages; based in XBase). … But this currently goes forward quite slowly because of other side project like the Gamma compiler generator. :slight_smile:

Disclaimer: Flow Design is not my idea. The idea is from Ralf Westphal. I found his articles about that fascinating and as eye opener for a better SW design.

One last note: Unfortunately, there is an issue in Xtend’s active annotation implementation which prevents my Xtend library from being used with Xtend types defined in the same project. Beside the fact, that using Xtend’s active annotation feature in that way is quite cumbersome from language design point of view… It was more a proof of concept.