Towards Simple Reactive OOP; Or, The Trouble With Programming

Programming languages do not deliver, as much as one would hope.

They can do everything, but never in the simplest of ways.

To get one thing done, requires three or more lines.

And to automate this, is one of the biggest mistakes in programming.

Dynamic programming, where you create control flow at run time is a mess.

Not automating things, however, is also a mess.

Dynamic programming creates spaghetti flow, at runtime.

Not automating what needs to get done, creates walls of unreadable code.

Macros are a solution, this is a code generation strategy.

But, you always wrestle them.

Programming languages are good at what they do, and they are not there to help you.

And certainly not with code readability, that language is yet to be created.

We live in a world where stuff needs to get done, without creating confusion.

Every programming language, should ship with reactive OOP.

OOP abstracts away complexity, under neat and readable dotted notation.

But reactive OOP, is a tall order, perhaps an undiscovered country.

It must allow for fine grained property configuration, to ensure security.

An invariant style constraint system, to ensure integrity, a rare find.

And observability, to notify subscribers, before data change, during data change, and of changes to lists.

And someday, it will have automatic life-cycle management.

Kludge, the many a programmer are thinking: kludge.

But it isn't, programming languages must react to changing data.

Precisely because they are in-charge of the syntax, and can make macro like functionality that is in-tune with the rest of the language.

Finally, this is not an explosion of complexity, just change reporting of string and arrays.

That unlike observable, are deeply integrated into OOP.

So that it is both, easy to write, and pleasant to read.

And I repeat, it is not OK, to write your program on top of a framework, that simplifies the language.

As here you are writing two programs and the result, is bound to the first.

Perhaps it is time to consider, that a range of frameworks is not a sign of a healthy ecosystem.

That absence of frameworks, would be a sign of a well made language.

OOP goes far, it is a good idea, in the right direction, but without reactivity at its core, it drags a project down.

My solution for these shortcomings, is the oldest one, string macros.

A readable line of text describing the necessary code, and a pre-processor.

One that converts the terse notation, into that unreadable long winded code that the programming language desires.

The project, will remain readable, the code will run, just fine.

But, we don't need anymore fast and simple languages, We need reactive OOP with a beautiful macro layer.