The promise of extensibility is that we can build levels upon levels of code starting with existing languages until we reach true artificial intelligence and then sit back and drink wine coolers while the AIs rule over us;)
Object oriented languages (and other kinds of extensibility) were supposed to make it so that we could build levels upon levels of objects. These levels would be available to everyone so that people could keep contributing levels.
I don't see this happening. Yes we have libraries, but we have no clearly defined levels to build on. I go to work every day and work with my object oriented language. Most of my time is spent writing loops and conditions and filling variables and so on. I am in the education industry and I should have an 'education level' to code from, not just language constructs. I have heard that some people have managed to get perhaps a level up, so that they work with things that were written in these languages. Still, nothing has stood out to the extent that people use such and such 'level'.
Outside of user interfaces, there is no community devoted to even one built-up level. And let's face it, as important as UI is, it isn't what the program really does. It displays things and accepts interaction, and yet it is not the core of the program. I see attempts in other areas, but little success.
On the whole, our programs still mainly just push data around, perhaps analyze it, store it, allow access to it, but not much else.
Why is this?
Why haven't we built a major well-known level, then built another major well-known level on top of that, then built another on top of that?
Where is the advancement in software development?
Why hasn't this happened?
Top comments (1)
Actually it happens a lot. And they have success.
The object oriented languages that you are talking about, are General purpose programming language.
The ancestor of the actual computers were the Automatons. They had a very specific hardware for a very specific task (e.g.: writing a letter by hand). Nevertheless, they were allowed some flexibility, they were programmed by little holes on a rotating cylinder that were translated by a mechanical system into the task steps(e.g.: moving the pencil to a position). Those codes in the cylinder were actually a representation of a Domain Specific Language.
The general-purpose computer and languages came with the attempt of selling computers to everybody that could be used for most of the people in their daily tasks. The market did need to serialize the production of a single type of computers... and then the general-purpose languages arise.
Reusability is a key concept that drive the OOP, and the first stuff to be reused was the hardware. ;-)
Interestingly when a program designed for one specific domain reach a big complexity, its evolution is so that the designers make it flexible in order to reduce coding time when customizing the software to solve specific problems in its application domain.
They stop being a monolithic software and start to have at least to parts (one that operates as a service and one that serves as a user interface to allow the user to access the features). In order to do that, they usually build an Object Model and expose its objects through interfaces. Usually the services are used by the program that interacts with you, but they can be used by other programs also.
Another way commonly used is that they build a Domain Specific Language with keywords and commands that have only sense in that domain (drawing, education, etc). The program translates that into actions.
One way that has evolved is the visual programming languages. They are domain specific languages with visual a representation. Normally the user can draw the specific behavior and that is later translated to a DSL, and later compiled to code or run as script. Of course the amount of things you can draw or connect depend on what you have implemented in the language.
I hope you are aware that a machine can't do any task in the field of Education without programming it at some extend (including needed educational concepts and actions in the DSL).
You can see a practical example of those paradigms of the Education domain used in Scratch.
One example in mathematics / engineering is the language Simulink of MATLAB that allows to make complex mathematical constructs using drag and drop and interface with devices to be controlled.
One that I like a lot is the Project Harpia that allows to define Image processing pipelines via a visual language, although it doesn't have a DSL, it generates directly the C++ code using OpenCV
Another successful example of a DSL is the one of Gamemaker. The language defines all the meaningful operations to describe the computer game interactions.
Some examples don't have a DSL, but they have a DOM and they use a general scripting language. E.g.: Gimp uses Python to do the automation.
If you want to make your own DSL, you can use: ANTLR or one similar tool like Yacc. They will generate the basic code for your compiler or script parser. Code you can call from your software.