I had to deal with it, when I hadto parse Transac-SQL code, and it's not handy. Very difficult to have a single executable file containing everything, it needs a whole subtree.
OCaml is easier with Opam and ocamlbuild tools.
I use to write complex SQL query very usually, and I can say that it's far more concise than imperative code.
Compared to it's own semantics, SQL is actually verbose, but its semantics is so powerful that you gain size.
I think most of the problems come from insufficient semantic power of actual language. Most programming language, even the most advanced don't manage time, don't manage locality, and don't fit in the brain representation human makes of the code.
It's remarkably explained by Blackwell in his paper "Metaphors we Program By: Space, Action and Society in Java"
https://www.ppig.org/papers/2006-ppig-18th-blackwell/
So frameworks try to manage this gap, and the only solution, IMO, is to invent language that integrate more advanced semantics to avoid the necessity of frameworks
15 years ago I had the lighnight idea to interview my grandfather who join the french resistance during the WWII. I interviewed him about the life before the war, in the country and his experience during the war, when he had to become clandestine in his own country because he didn't joined the mandatory german working program (STO). It's the most concrete thing we keep from him, and I just regret I didn't interview him more.
There's an interesting language strongly influenced by Self : Lisaac ( http://www.lisaac.org ). Lisaac is a purely prototype language extending the Self's prototype paradigm with extremely good performance (close to C code, biggest part of the research around this language was about high performance code generated by the compiler).
For instance, you can define a dynamic inheritance : your inheritance can be defined by a function which return an object - so, a prototype - among several.
The author of this language explain me that Self was one of the most important day in his life ;-)
Using MagnetoHydroDynamic, you can. You just have to use parietal Engine invented by Jean-Pierre Petit in 1975[1].
With this technology you can fly at Mach 8, easily..
Every programmers should know something about memory, because software are becoming bloat [1] [2] because of a new generation of programmers who doesn't optimize their code.
So, of course, you had a wonderful career, but it doesn't prove that you write efficient code
Some years ago, I had to write program that extract a foot pressure platform for an orthopedist, and I had to do it with a closed-source Delphi API.
Delphi was already old at that time and difficult to find.
I though about Lazarus and it works perfectly with the Delphi blob file.
It's a very great tool.
AgensGraph is a graph database built on top of PostgreSQL. The ability of PostgreSQL to handle with graph drive the AgensGraph's Team to develop a special index type to manage edges between nodes.
They also implemented the most part of the Cypher language and it is possible to write PL/Pgsql function with Cypher's query inside.
I wonder if this very clever approach is interesting in the energy consumption perspective.
In this work (http://hpc.pnl.gov/modsim/2014/Presentations/Kestor.pdf ) the author shows (slide 11 ) that it cost 100 times more energy to move data from memory to register than to move data from L1 cache.
So, this kind of mechanism could hugely improve the amount of data that could be stored in L1/L2/L3 cache, but what could be the energy cost of compression/decompression step ?
I think all experiments of languages that resembled natural languages will never work until one will try to ascend to a more high-level paradigm.
Actuals programming language are based on a "forklift paradigm" : you describe the path of a forklift in a virtual warehouse where data's are in some places and your forklift move them from places to places.
So a natural language isn't design to express this kind of semantic.
In PPIG ( Psychology of Programming Interest Group ) 2006 was published a very interesting paper where is studied the metaphors which was shared by the core java library authors, the mental model said in another way.
It reaveals very interesting facts : Programmers tend to think the world in term of Belief-Intention agents. Agent are members of a society who trade and own datas and are subject to legal constraints. A method calls is a speech act. The execution is mentalized as a journey in a a spatial world. Etc.
There's a lot of metaphors like that, and it reveals tracks to conceive a more high level language.
So there's a lot of work in this field (Behavior-Tree based language, time dimension include inside the semantics, etc.).
Note that it is also possible to express non ambiguigous semantics in natural language : Attempto Controlled English is an exemple [2].
Here an toy example of what you could do with this language :
"MyWebPage is a webpage.
MyWebPage contains a textfield which a logical name is-named NameTextField.
His label is "Name".
MyWebPage contains a button which a logical name is-named SubmitButton. His label is "Submit".
If User clicks on Submit and NameTextField is empty then NameTextField ' s css class becomes AlertEmptyInput.
"
- A very clever and complete type analysis. The compiler can thus optimize at best the code without runtime type-checking code.
- If possible, a flow analysis : By analysing the bounds of each function, compiler is able to remove a lot of unused code. For instance, if a variable is defined by t = 2*n and long afterwards, there's a test which check primality of t, the compiler can remove the test.
- Compile code by rewriting algorithms that "takes in mind" locality of memory, ie. all things described by U. Drepper in "What every programmers should know about computer memory", ie2. rewriting algorithms to avoid cache miss, etc...
- Automatic template-like mecanism : the compiler is able to make partial execution of the code, even in array, so all the code which can be calculated because you have the datas should be directly compiled. Imagine you have a regular expression library and you write your regexp in your code (just the regexp) : the compiler should be able to produce an automata.
- It is also said : be able to use SIMD instruction.
Because of this, it is better to compile a high-level language with a very clean semantics : you can much easily reason about your semantics and more easily rewrite some algorithms.