Morally kinda similar to ArchJava, apparently.

Objective-S is an architecture-oriented programming language based loosely on Smalltalk and Objective-C. It currently runs on macOS, iOS and Linux, the latter using GNUstep. By allowing general architectures, Objective-S is the first general purpose programming language. What we currently call general purpose languages are actually domain specific languages for the domain of algorithms. Objective-S includes an Objective-C compatible runtime model, but using a much simpler and consistent Smalltalk-based syntax. Unlike Smalltalk, Objective-S has syntax for defining classes and so can be file-based and is "vi-hackable".

Paper: Tyranny of call-return

Paper: Procedure Calls Are the Assembly Language of Software Interconnection: Connectors Deserve First-Class Status

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Some comments

From the point of view of abstraction tiers model:

1. They still stay in OO paradigm, but allow additional mechanisms of lower abstraction tier, so there is no abstraction tier advancement.

2. For UI they want to configure streams. But this is lower-level abstraction than reactive UI (react, angular). So, there is no advancement in usability either. Configuring connections in UI much more complex than reactive approach (reactive system of components). The reactive UI is on initial phases the tier 5 approach, but Objective-S is trying to do the best that it can in the tier 2 (flat patterns). Usability difference are quite large.

Doing the lower tier mechanism usable is useful, but these mechanisms do not scape well on the scale of cognitive complexity. So, they applicable only for organizing small isolated pieces of the code. The mechanism could be still useful as lower-level implementation approach, but why it is not a significant language advancement.

On other side they naturally feel pressure from OO complexity, but they are seeking solution on lower abstraction tiers, when the solution is actually on higher abstraction tiers (dependency injection, reactive systems, etc.). Lower abstraction tiers provide lower cognitive load for individual element, but they have higher total cost when number of elements grows (bad cognitive scaling).

The good experiment would have been is implementation of some complex UI with reactive UI approach and their framework. Email client or pet shop would work. Their example is too small to see cognitive complexity scaling problems.

Some answers

> They still stay in OO paradigm,

That is not true. Software architecture generalises from other paradigms to components (state and computation) and connectors (communication). If you check the software architecture literature, you will see that this is all-encompassing.

Current "general purpose" programming languages are anything but general purpose, they are DSLs for the domain of algorithms. See also: ALGOL.

> but allow additional mechanisms

Again, no. The mechanisms are not "additional", as in "bolted on". Instead, once you generalise to components and connectors, you can specialise to lots of different architectural styles by selecting and adapting the components and connectors you need.

> of lower abstraction tier,

Whatever "lower abstraction tier" actually means. In general you want the least abstract mechanism that will do the job. See the Rule of Least Power and the Principle of Least Expressiveness.

Making the language flexible enough to allow different architectural styles means that you can express yourself directly, rather than having to wrap them in adapters to fit the architectural style of your language, which is often arduous enough that instead an inappropriate architectural style is chosen.

> so there is no abstraction tier advancement.

While I find the abstraction tier model somewhat dubious, Objective-S actually fits right in and provides a significant advancement. The Black Box tier is one that is typically occupied by black box frameworks. Black box frameworks tend to have a "grammar" for how those black box objects can be composed, and so the framework is equivalent to a DSL, and is in fact, sometimes accompanied by such a DSL, because configuring correct compositions into systems is otherwise very arduous.

The DSLs, however, come with their own problems, in that you need new syntax, semantics, tooling etc. which is significant effort. In addition, if every framework comes with its own DSL, that leads to a proliferation of incompatible DSLs that have to somehow integrate and communicate with each other and the base language. A mess (talked about at length in the paper and the Nierstrasz paper referenced).

What's more these DSLs are usually quite similar, so you have significant duplication. Objective-S is a generic "DSL language for black box frameworks", and it shows this by treating the language implementation itself as a framework for which it provides a thin linguistic wrapper. Naked objects but for the linguistic UI rather than the graphical UI.

> For UI they want to configure streams.

No. The UI connection shown in the paper is dataflow constraints. These have some similarities to streams but are not the same. Furthermore, it is not what Objective-S "wants", but simply a demonstration of how the call/return architectural style (or Algorithm DSL) breaks down when dealing with something that is not an algorithm, such the communication patterns between GUI and model.

> But this is lower-level abstraction than reactive UI (react, angular).

No. "Reactive UI" is an attempt to pretend that a UI is a pure function of the model. This isn't actually true, but convenient because functions/procedures are the only thing we can actually write down directly in our Algorithm-DSLs. Everything else requires indirection. Alas, the fiction that it is a function breaks down quickly, hence the amazing churn in those frameworks.

> Configuring connections in UI much more complex than reactive approach

That turns out not to be the case. So-called "Reactive" UIs are ok-ish for trivial UIs, they break down quickly due to the inherent contradictions of the approach. Connecting things up is trivial with the right abstractions and actually models what is happening, rather than pretending that things are completely different from what they are.

> these mechanisms do not scale well on the scale of cognitive complexity.

The opposite is true. Software architecture is how you describe the largest grain of your large systems. Objective-S scales this down so it also works for programming-in-the-small, and in fact eliminates the distinction.

> higher abstraction tiers (dependency injection, ...)

Dependency injection is...well once you get beyond the fact that it's just adding parameters to methods and consider what it is trying to achieve...just an ad-hoc, not-entirely thought-through variant of system definition in software architecture.

> (reactive systems)

Once again, pretending that UIs are functions is not a "higher abstraction tier", no matter what definition of abstraction tiers you use. In the hierarchy of programming paradigms as presented in Concepts, Techniques, and Models of Computer Programming, functional programming is a lower-level abstraction than, for example OO. And that is good, because you want the lowest level you can get away with that leads to a natural program.

And so the reactive frameworks are to be applauded for trying to get by with a lower-level of abstraction, this is a good thing if it actually works. However, I don't think it has worked, the resulting programs are not natural except for the simplest examples.