When people first start to learn about computers, they often get the impression that there are a limited number of programming languages available. This is, of course, because they are typically exposed to only a few examples, like C, C++, C#, and Python. In fact, as we discover in this List of Programming Languages, there are 49 whose names start with the letter ‘A’ alone (interestingly, this number includes “Assembly Language” as a single item, but there are almost as many assembly languages are there are microprocessor and microcontroller families).
Furthermore, the aforementioned list doesn’t include any of the so-called Esoteric Programming Languages, like Whitespace, which recognizes only the whitespace characters, space, tab, and return (any other character is treated as a comment); Chicken, which has just three tokens, the word “chicken”, ” “, and “\n”; and the aptly named Brainfuck, which is designed for extreme minimalism and leads to obfuscated code. As an example of the latter, the following program will output “Hello, World!”
++++++++++[>+++++++>++++++++++>+++<<<-]>++.>+.+++++++ ..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.
There’s always something new to learn. For example, I only recently became aware of the programming language called INTERCAL, whose moniker is short for “Compiler Language With No Pronounceable Acronym.”
Do you recall my recent blog about The Birth of BASIC? Many people who started their careers in science, technology, engineering, and math (and myriad other subjects) in the 1960s and 1970s have nothing but good things to say about BASIC. By comparison, a lot of professional programmers hold BASIC in disdain because it includes statements like GOTO, which is used to jump to a specific location or label within the source code.
Admittedly, the use of GOTO can lead to problems in the wrong hands, but it can be jolly useful if you employ it in the right way. I can only imagine what the same professional programmers might have to say about languages (like one variation of INTERCAL) that support the COMEFROM statement, which is the inverse of the GOTO in that (by means of an associated parameter) it can take the execution state from any arbitrary point in the code. Things get even more fun when the COMEFROM parameter is computed on the fly, and don’t get me started on languages that support the DONT statement (which complements the DO loop construct).
The reason I’m waffling on about this here is that there’s an annual conference for software developers called NDC { Oslo }
I just saw a video of a presentation titled The Worst Programming Language Ever, which was given by Mark Rendle at NDC { Oslo } 2021.
As Mark says, the goal of his presentation is to “Take the worst features of all the languages we know and put them together to create an abomination with the worst syntax, the worst semantics, the worst footguns and the worst runtime behavior in recorded history.” (FYI The term “footgun” in this context is programming slang for any feature whose addition to a product results in the user shooting themselves in the foot.)
An impossible task, you might say, but Mark certainly gives it his all. How about you? Do any features of any programming languages spring to mind that you would care to commend or condemn?
I spoke at NDC a couple of times – one of the best and most enjoyable conferences on the planet!
Loved this talk (only skimmed it so far, need to make time to go back and watch it properly…). I remember a colleague in the early 80s who programmed in APL. That has to be the most wonderful, geekiest language I know and one of the few which is completely impossible to read unless you know what all the runes mean and completely impossible to write unless you have the special IBM terminal with all the runes on the keyboard. Wonderful stuff.It has been deacribed as “a mistake carried through to perfection!”
That’s one conference I’d really like to go to, even though I’d probably understand only a fraction of what was being talked about.
I started programming in 1969 with FORTRAN on punched cards, in the following years I learned a lot of languages, including APL, even LISP, up to web languages… In the last 30 years I have worked on parallel programming languages. After so many years I concluded that the SEQUENTIAL PROGRAMMING MODEL has reached its limits for parallel programming.
Parallel threads were introduced in mainframes in the 60s. Processes and threads evolved in the 70s and 80s. In parallel, the personal computer appeared. I own an Osborne suitcase with CPM/80, no thread. In the beginning, the DOS operating system executed a single task. The first, sort of threads, were introduced with Windows. They were hidden in the “event loop”, user events like button click could start different tasks. Evolution, evolution, evolution… lead to Windows NT, a full-fledged multi-threads multi-processes operating system. Then appeared the multi-cores. They were simply integrated in the OSs thread scheduling algorithms.
NOW, THE REAL PROBLEM (I hate threads): asynchronous communications, they required complex mechanisms, like semaphores, to share information. This makes parallel programming difficult, and it requires computing overhead. We programmed applications with more than 10 threads, it was a nightmare to debug. How do you develop parallel application with 1000s of threads truly sharing data?
Knowing the limitation of the sequential programming model, what would be the requirements for a true parallel programming language? A language that would allow the programming of 1000s of threads. In my research of the HOLY GRAIL of parallel programming, I concluded that a new programming model was required. We developed the psC language, to support the PARALLEL AND SYNCHRONOUS PROGRAMMING MODEL. Because all changes are synchronous, this new programming model enables sharing of information without any overhead and allows programmers to code 1000s of threads. We successfully applied this language to the ultimate parallel machine, the FPGA. FPGAs can have millions of instructions executing in parallel. As a benefit, C++ programmers can learn FPGA programming without knowing what an FPGA is.
Well, enough, I think an interesting discussion could take place…
Hi Luc — your psC language sounds very interesting — I’m 100% loaded at the moment (and not in a good way with alcohol), but maybe you can ping me in a couple of weeks’ time (max@clivemaxfield.com) and we can chat about this with the possibility of an article on EEJournal.com