magicmouse

Luna project received an additional million in funding recently. still cranking away in Poland on that project. It is a very challenging project, they are trying to make a hybrid text and graphical form language, where you can switch between them. That's a very complicated thing to build. Wish them luck, they will need it.

Absolutely no chance. NASA spent 20 years designing this new super rocket, never even built a single one of them; so it only exists on paper, and when you look closely at the design it is basically the Saturn 5 with some slight modifications.

The reason so many engineers jumped ship from NASA and went to work for SpaceX is that at least Elon is doing something with some alacrity. NASA is just a bunch of paper shuffling time wasters at this point (especially at the top). People forget that they subcontracted most of the Apollo project. Having civil servants who never get fired is not the way to achieve excellence in any product or service!

I have been watching this project for a while, but now i can see the full source code. A very ambitious project as so many of the "low code" products today are basically fixed ecosystems where the components are sourced by the company, and you basically mix and match pie chart drawing modules with line graphs, etc., to make dashboards. This is more like VB6 which i understand was the goal. Many people consider VB6 to be the peak of power * ease of use.

Scala and Perl are even worse, i agree with you there. Some people love Haskell too, but i think it's awful.

MIT has replaced Lisp with Python, because even though they pushed forced it upon their students for decades they had to admit Lisp was archaic and not particularly readable. The Pharo IDE is arguably the most sophisticated IDE around today, but the fact remains that Lisp doesn't permit easy interchangeable parts, which is a major goal of the new programming languages being developed. Although very bright people can get very good at Lisp, the average person finds it extremely hard. Remember you are reading it from the inside-out which is highly unnatural to someone who reads books which read left-to-right.

I disagree that measuring program length by the size of the parse tree is a good measure of conciseness. To an author and reader, it is the number of words you read that matters, so i use word count as the benchmark value. People who write newspaper articles are given a word count to hit, you type a certain number of words per minute, and people read at a certain speed. So words are the units of measurement that are easily counted and there will be no dispute.

A parse tree is not particularly comparable between languages; most modern languages make extensive use of powerful runtimes to handle complex things that are part of the OS. There is typically over a million lines of code behind a simple text entry field.

In my Beads language for example, i go to great lengths to allow declarations to have a great deal of power, but they are not executable code, and thus have hardly any errors. Lisp is not a particularly declarative type of language and is thus more error prone. The more code you don't execute the more reliable the software will be, so declarative programming is even better than Lisp.

Lisp derivative languages are notorious for their poor readability; hence the avoidance of Lisp by companies who fear "read-only" code bases that cannot be transferred to a new person. Lisp, Forth, APL, all win contests for fewest characters, but lose when it comes to the transfer phase. But like a bad penny, Lisp keeps coming back over and over, and it always will, because 2nd level programming, where you modify the program (creating your own domain specific language basically for each app), is the standard operating methodology of Lisp programmers. That one cannot understand this domain specific language without executing the code makes Lisp very unsuitable for commercial use.

Yes there are a few notable successful commercial products (AutoCad) that used Lisp to great results, but for the next 5-10 million programmers coming on board in the next few years, I laugh at anyone with the audacity to imagine that Lisp would be remotely suitable. Lisp is an archaic language is so many ways. It cannot run backwards. It has no concept of drawing; it is firmly rooted in the terminal/console era from which it sprang. With no database or graphics or event model, you have to use API's that are not standardized to make any graphical interactive products, which is what the majority of programmers are making.

the slack group is https://futureofcoding.slack.com/

Also, there is a slack group dedicated to future programming languages. I am the acting char of the next gen language developer's association, and am trying to get all the next gen language designers to be in communication with each other. Right now there is the Luna project (poland), Red, Parasail, Beads, Elm, Dark, and others. i will be sure to add an entry in our database for Bosque.

i challenge the decision to not have explicit loops. the beauty of the original C construction was that it allowed for 3 events to occur inside each iteration: 1) normal execution of the body, 2) skip over the body but increment the counter, 3) exit the loop. When you have nested loops JS and AS3 let you name the outer loop and break out of it (thus re-introducing the FORTRAN GOTO which although that crank Dijkstra hated so much, occasionally is needed for this purpose). How are you going to stop a loop that might go on too long? sometimes you want to stop early. I don't see how you can stop the map().. or filter() operators. Just because early abort of a loop is not common doesn't mean it doesn't come up; it does inevitably so.

There are many buzzwords in the programming profession. These terms are bandied about with great regularity, and mean almost nothing. Fundamentally, we only have one kind of computer with two variations: the Intel and ARM instruction sets which drive 99.9% of all computers used today. Everything on top of these two hardware platforms is software, and since the hardware's only commonly used instructions are arithmetic, copy, load/store, compare, branch and call/return, the most powerful instruction is the function call and return, and every language from Assembler onward has striven to wring as much utility out of the call/return instruction. Functional programming is where you try to give functions more weight, as opposed to the move instruction which was COBOL's stock in trade. So one cannot be against functions, it is one of the only power tools we have. What i am against is waving these banners around, like OOP, Functional Programming, Top Down Design, etc., when what we really want is reliable software that is easy to understand. We are evolving towards better notations, but unless you change the hardware (and adding more cores does very little to help) you are pretending these terms actually mean something.

Umple was a huge amount of work. The bidirectional nature of the text form and the graphical form is very impressive. However, it is fatally flawed system IMHO because it adopted wholeheartedly the doomed OOP paradigm, and when you see how many classes you end up using, it makes it hard to understand programs. But a very powerful project, and probably thousands of hours of work to build it. I would be very interested to know how many man-years were put into the program.

I think DynamicLand should abandon their color-dots based encoding system, and use a modified QR Code. QR code is a completely debugged barcode system that doesn't require a color printer. I happen to own a nice big 50lb Canon Color Laser right next to my desk, but in academic environments, black and white lasers are only available, for the simple reason that color lasers cost 4x per page of monochrome printers. My toner cart set is more than the printer cost!

The Latin language was destroyed by pompous academicians who refused to allow the language to grow organically. The Academie Francaise has set in motion the destruction of the importance of the french language, because if you don't allow flexibility in your language, eventually people abandon it. Dante's Inferno was i believe one of the first novels done in the vernacular Italian. They can claim they are protecting it, but it will be washed away like a sandcastle because they don't see the forces at work from their little chairs.

They won't even let words in like "Computer". or CPU. Sorry, but when was the last time anyone cared about computer research in the french language? They are crippling themselves by not adopting some english. The Japanese managed to adopt Elevator (e-re-be-ta), because didn't have the concept before Mr. Otis, so acknowledging inventions external to your country is part of not living on an island.

well, instead of trees of the classical S-expression type that you are referring to here, which are what LISP is built on. I suggest you investigate a graph database like Neo4J which is way more fun than lousy S-expressions. But what are in the trees are numbers or strings (which are arrays of numbers). Frankly all the computer has are bits which form numbers, so that is not something you are going to get away from.

CSS is utter crap. In the history of computers, one programmed in a single language at a time. You had punch cards, then a text file in a terminal, then a text file in a PC written in a language like FORTRAN, COBOL, PL/1, Java, etc. And it was fine. Then they invent a bizarre 3 language sandwich where you switch back and forth between 3 completely incompatible languages (CSS, HTML, JS), which don't even agree on how comments are entered. It is one of the worst designed languages ever, surpassing the previous abomination RPG. I can't wait to deep six the whole HTML stack, as it is a huge time waster. We need a single, well-designed language that can all the general purpose coding we need (and generate websites). Maybe the output will be JS because that is what browsers support today, but seriously let's not put lipstick on a pig and call it pretty. That CSS can draw but not compute, and JS can compute but not draw, and HTML can't do IF, what kind of nutty design is this? Chaotic rapid growth was the cause, but the cure is to dump it entirely.

Instead of using a vague term like "power", perhaps the LISP fans should promote the concept "leverage", whereby you can talk about getting a task done with the fewest words of code. Small LISP programs can be incredibly clever, and transformation languages like LISP and FORTH are well known to win every program-shortness contest. However Assembler has always been more powerful in the sense that you can do things in Assembler that you can't do in higher level languages, because there is no direct mapping from a higher level language to many of the special instructions that exist on modern chips. So using "power" is a lamentable word choice. LISP does have problems though, many consider it a "write-only" language which transfers very poorly to other programmers. You can measure transferability of a codebase by assigning a new person to it, giving them a task, and seeing how long it takes, and how much is broken in the process. LISP is avoided by most large companies for this reason alone. Leverage and other factors are heavily outweighed in overall cost to the organization by the difficulty of transferring a code base among people.

Human error is what makes programming difficult. You can watch a computer do billions of calculations flawlessly, while a human cannot type a few hundred words on average before they make an error of some kind. Developing software is not amenable to simple checklists, and is a very creative process. What would be more helpful than checklists are improved languages that make it much harder to make a simple mistake.

Functional programming was invented by Backus to solve the problem of interchangeable parts. Unfortunately, he did not finish his work, and as a result people are still trying to paper over the missing hole in the theory. State monads as described above make the process of storing and manipulating state a very obscure and mysterious process. This additional complexity and abstraction can only add to the lifecycle cost of software generated using this technique, with an attendant increase in maintenance cost. If you were to take a 10 year old, and give them basic training, would they be able to understand this? I doubt it, yet computers at their core are incredibly simple. So a better paradigm awaits.

There are some good points in this article, namely that a very lengthy language specification is a sure sign that the language is overblown and probably the victim of design by committee. Modula-2 had a 100 page description, and i would take it over C++ any day. Heck C++ still doesn't have separate compilation. It is a total pile of crap IMHO.

Another good point is that languages that facilitate domain specific languages create maintenance problems, which they do. Nothing fun about taking over some giant code base that has invented its own syntax, and of course the designers left minimal (or worse, incorrect) documentation.

Lisp is part of the family of languages that J. Backus referred to as 'transformational languages'. Its ability to self-modify creates programs that are almost impossible for people other than the author to understand. This is why after 50 years it is still a niche language, and will remain so. There is little demand for programming languages that are hard to maintain. A working program lasts decades, and passes through many hands, and LISP is dead-end technology that will forever keep being brought up as its temptations are irresistible to some.

It is tragic that the world standardized on Javascript. They are just now discovering some of the module issues that Prof. Wirth solved in his great Modula-2 langauge in 1974. His system allowed separate compilation, and a way to detect when the interface API changed so that it could be cross-checked. I used Modula-2 to great effect on very large projects, and am greatly relieved that the Modula-2 module system has more or less made it into JavaScript.

I really love Jonathan Edward's chart where he shows the big stack of technologies one has to master to build apps today. The goal is to replace that entire stack with one language. That would be the 10:1 improvement that would really make a difference. The burning question therefore, is what can replace that entire stack? Clearly you have to offer a way of storing and structuring data that improves upon the table. otherwise you are back in relational database hell.

I am working on a new computer language called Beads, which is designed to replace the current development stack for both personal computers, mobile devices, and web. You can find out more about this project at e-dejong.com

The focus of my tool is creating graphical interactive software: iphone and Android apps, desktop apps, and things that run in the browser. The notation is compact, readable, and straightforward. It has many innovative aspects: new data structures, physical units (something FORTRAN just got after 30 years in the in-basket), and deductive reasoning which dramatically reduces the length of programs. It is not a design by graphics system, but a language. It isn't that abstract, and is far more straightforward than Haskell or PROLOG. It is not a LISP derivative.