For me I think it has to be the scripting language of an old proprietary telephony platform I used in the early 2000s. The language itself was not so bad, but the fact that it was meant to be edited with a drag-and-drop GUI, which did not expose all the functionality I needed, was quite frustrating. I also remember having to manually implement many common functions, such as calculating the length of a string.

Whenever I wanted to use "custom" or "advanced" functions, I had to edit the script files in a text editor, but as soon as I opened the files in the GUI again they were reformatted and restructured, which usually resulted in broken code. And, of course, this was an interpreted language, so I would not know it was broken until I actually ran it—oh, and did I mention that it did not run the same in the simulator as in the live environment?

So, what is the strangest programming language or environment you have used, and why did you use it?

Note that I'm interested in languages and environments that you have actually used for "real-world" situations, so Whitespace, Brainf**k and friends are not valid—unless you have used them for something "real", of course.


My second job (circa 2003) had me programming web surveys in a scripting language called Quancept. Although the product it was currently in was designed to do web surveys, the language supposedly had its roots in the 1960's, doing phone surveys. Whether this was ever true I never followed up on but it clearly was an ancient language - no functions, no way to reuse code, etc. Every "question" and "answer" you asked people had to be hardcoded into the script. And it was very limited, but it never failed that the client wanted something herculean done with the presentation of the questions that no amount of scripting or CSS was going to be able to pull off (the resulting HTML had no useable pattern). It had some neat stuff, like how it could randomize answers (to offset people who just picked "C" and moved on) but keep track of where the responses go, but I was dying for a "real" language.

Interestingly, the way I moved up in the company was to make a C# program that would generate code for it. Clients would send us the survey in the form of a Word document. I could paste the question into the "question" textbox, paste the answers into the "answers" textbox, click a button and voila - the necessary script was generated, with all the Word stuff (like the apostrophes and dashes and so forth that the compiler would choke on) stripped out. It would even add it to a running script in the bottom pane and increment question numbers automatically.

When I offered it to my coworkers, they declined to use it. They said that they didn't really trust it but I think the real fear was that it might underscore how trivial a job it was and how unnecessary it was to have them sit there and do it.

And since doing this and some other stuff in C# got me noticed, I advanced in the company. And the scripting job I used to do got offshored (all the aforementioned coworkers saw the writing on the wall and jumped ship by then).

So the happy ending to the story is that I automated myself out of that shitty job and into a better position.


APL. I used it in a programming course I took in high school around 1980. Quite mind boggling.

To back up my case, here are some samples from Wikipedia. See if you can guess what they do without reading the wikipedia article:


X[?X+.?' ';]



I'm inviting a flame war, but Perl! Craziest freaking language in the world! I know!!! Its powerful. Yeah, yeah. I get it. But I still think its a crazy, weird language. Just trying to figure out your execution context at any point in a perl script will make you go postal (no offense to any of our fine postal carriers out there).

Also, can't remember the name of it, but there was a dos-based mortgage processing system I used years ago that had its own precompiled language and database format. It was a screwy system. Somebody help me out who knows.


XSLT is a very strange language.

It is purely functional (no side effects) as Haskell, but has a very clumsy syntax (XML) and has a very limited set of abstraction mechanisms. It's a useful template language for text based and XML based output formats.

It is quite readable (to the extent XML can be called "readable") and it's easy to adjust existing XSLT templates. However, creating new XSLT templates from scratch is a real pain.


MUMPS is a very good candidate : 1 letter commands. They never heard of something like mnemonics. You can put as many letters ( errr, commands) in a line as you like. Have you ever heard the term letter soup? Well, this is a MUMPS program. Very probably, one can make all calculations to send a rocket to the moon in a couple of pages program.

MUMPS is an Operational System and language at the same time. Because of this it is extremely powerful and compact, but absolutely weird. Is mostly used to control medicines, stocks and everything related in hospitals, but, due to its size and speed, it is good for any kind of inventories control. Currently it also can be found as an object oriented language with GUI's and all, and not only in the old "DOS" or text style.



I have enjoyed it though :)


Definitely LOLCODE

Example lolcode program:

    UP VAR!!1

Forth - bonkers. Brilliantly bonkers.


Definitely Prolog. Learning that language broke my brain and forced me to completely rebuild my programming skills from scratch, and I'm a better programmer for it.

I had to learn it while working on a control system for a hypermach windtunnel -- thousands of sensors and a complex web of constraints designed to keep the whole thing from exploding. Prolog was the perfect language for it, and actually the system was quite elegant. Just with a terrible UI. :)

I have to say, though, ChucK is awesome, and my canonical example of a domain-specific language done exceedingly right.


DOS batch. It's a pain to do anything significant at all.



And ever since I've denied knowing anything about it. :P



Sed is the strangest language I ever used in real-world situations.

If you just use it for regex search & replace, everything is fine. However, that's just the "s" command. Sed support many more one-letter commands with subtle differences between e.g. "n" and "N". Writing bigger sed scripts is a pain. Reading foreign sed scripts is practically impossible.


Actually used and not just seen as a curiosity? RPG (RePort Generator) on IBM System/38 and AS/400 systems. Strangely, it worked a lot like relay ladder logic used to program control systems.


PERQ microcode. (Example of RT13 in microcode) 40 some bits of instruction and you got to hand code them all. If you did it wrong, the machine crashed. If you didn't call the Video interrupt service routine often enough, the machine crashed. For debugging, there was a three digit LED on the front that you could increment (not set!). Beyond that you either used PDP-11 Link boards to hook the machine to another PERQ where you ran the kernel debugger, or you leased a $50k logic analyzer and used that......



RDML/RDMLX is by far the weirdest I've ever used. Conditional statements must be wrapped in single quotes IF they contain certain types of content. This means that literals in conditional statements must have two single quotes around them.

This is a valid statement:


As is

 If COND('#POLN11 *EQ ''ABC12345678''')

And that is just the beginning. There is no concept of scope - ALL variables are global. And, like RPG, if you read a file that contains fields of the same name as the ones you're working with, you lose whatever value you had stored. Unlike RPG, there is no facility to prefix a file (prefixes the field names with what you define) to make the field names unique.


I did a report in college on Icon. Very powerful, yet strange language.



The weirdest language I've ever programmed in is the AI scripting language for Age of Empires 2. The code looks like the following.


I love poking around on the CDs they ship with a game and the 100 page manual for this script is the best think I've found.


AppleScript is pretty weird I think. Examples and excerpt from Learn Mac OS X Snow Leopard

AppleScript is a strange language. It tries to look as much like English as possible, which includes having several different ways of saying the same thing. This makes AppleScript readable even by non-pro grammers. However, many programmers find AppleScript hard to write in, because it?s not actually English. You can't just write English and expect AppleScript to understand you.


ChucK, which is the first 'strongly-timed' programming language I've used. It's a music programming language, so you need to have individual threads play 'on the beat'. Because of this dur (short for "duration") and now are as fundamental to the language as int and 0 are to most languages.

impromptu is a similar language, although I haven't had a chance to play around with it yet.


I used LabView once and found it pretty unusual to me. It's a very graphical, sort of drag and drop, programming language. Wikipedia: LABVIEW


I use to use the R language (and S) for statistical analysis and modelling.

R is open source and there was no set way of doing things. The way functions were called varied greatly depending on the library used. A lot like PH I suppose.


I once worked for the IT department in a telemarketing company (I know, it's evil, that's why I'm not there anymore, ok?).

They had a proprietary scripting language called "Magellan" that had special hooks into the dialing system, so you had events firing for "On Pickup" and "On Hangup"... But as a language it was like some kind of hybrid between Excel and Visual Basic 6.

The company that made it went out of business, but you can still see a few references online: http://www.google.com/search?q=melita+magellan


Got to be APL (a TLA which stands for "A Programming Language"). Here is an example from another thread. My actuary friend says it's very powerful, but I always called it "The Martian Language".


TinyMUSH. It is (was?) a pretty complete language, for the problem space. Later, they added Tcl embedding to it, but that was well after my time. I "worked" on a World of Darkness roleplaying game, and we needed a really good set of objects to represent weapons. I spent a few weeks building a new weapons system, and was really proud of it.

All the code (the routines) gets put in object attributes, and those have to be entered by hand in one line. Some people used a program to convert well-formatted code into single lines and then dumped it into TinyFugue, but for some reason that never appealed to me. I entered all my code, branching statements and all, in single lines.

Programming in such a bizarre environment was actually a lot of fun, but after I became a professional programmer and tried to go back and do it again, I was pretty horrified and unable to keep at it.


Prograph which was a visual programming language.


RPL, from the HP 48/49/50 series graphing calculators. It's half FORTH, half Lisp, but it's the most powerful language ever shipped on a handheld calculator. These days, the calculators also ship with a very nice CAS, so they're competitive with Maple and Mathematica for a lot of things, particularly ease of use. (Once you grok RPN.)


Maybe I've lived a simple life but I'm going to say that JavaScript is the stangest programming language I've ever had to use (and still love to use). But really:

alert(typeof(Boolean)); //"function"
alert(typeof(true)); //"boolean"

So a boolean variable doesn't equal the typeof call for Boolean.

Or how about self executing anonymous functions:

var divFound = function(node) {
               if(node) {
                 if(node.id === "what_i_want") {
                   return true;
                 } else {
                   return arguments.callee(node.parentNode);
               } else {
                 return false;

Yep, I've used self executing recusive anonymous before :P


Occam is the strangest language I ever used. It is a parallel language, designed to work on more than one processor, and written in an age when that meant lots of computers chained together, which reminds me of the Replicators from SG-1, actually.


FOCUS for Mainframes is the weirdest one I ever used, I think. Scary to see that it's still in active development.... http://www.informationbuilders.com/products/focus/ibm_overview.html


Using Fortran to read data obtained from Datatakers, and produce HTML and graphs for an almost-realtime website. I wrote the comments in Latin, and when asked about it, I said I was documenting one dead language with another. Had to change jobs to escape.


SNOBOL, from college days, was my strangest language. Its' paradigm was pattern matching, and each statement could have one or more goto references following the pattern match. One for absolute goto, or a single or combo pass-fail set of labels. Not very structured!

It was intriguing to have to think diferently to build a program that met its assigned goal. One challenging assignment for the course was to build a text editor. That was extrememly difficult to complete.

There was also a variant called SPITBOL, which was a subset and compiled version (SNOBOL was, at the time, interpreted).


REXX on OS/2 Warp. I don't even know where to start with that explanation.


Chef would be one at the top. All the programs look like recipes.

Hello World Example:

 Hello World Souffle.

 72 g haricot beans
 101 eggs
 108 g lard
 111 cups oil
 32 zucchinis
 119 ml water
 114 g red salmon
 100 g dijon mustard
 33 potatoes

 Put potatoes into the mixing bowl.
 Put dijon mustard into the mixing bowl.
 Put lard into the mixing bowl.
 Put red salmon into the mixing bowl.
 Put oil into the mixing bowl.
 Put water into the mixing bowl.
 Put zucchinis into the mixing bowl.
 Put oil into the mixing bowl.
 Put lard into the mixing bowl.
 Put lard into the mixing bowl.
 Put eggs into the mixing bowl.
 Put haricot beans into the mixing bowl.
 Liquefy contents of the mixing bowl.
 Pour contents of the mixing bowl into the baking dish.

 Serves 1.

So far the weirdest languages I have worked with tend to be proprietary scripting languages for various business and scientific languages. In some cases the languages are similar to and older version of Visual Basic for Applications or a more advanced version of BASIC which tends to be fairly easy to pick up and work with. While others tend to be extremely bizarre languages that are less of a "macro language" and more of a way of scripting reports.

So far the worst thing about most of these scripting languages is that they are for one off projects, once I figure out how to write something useful with the language I end up never having to use it again.


Haskell is a pretty weird declarative language. As the HaskellWiki says, "it is a polymorphically statically typed, lazy, purely functional language".

You can end up with some pretty impressive stuff from only a couple of lines of code. It does surprise me that with Python and Ruby taking off in recent years, I haven't heard of anyone using Haskell. Then again, if you visit the Haskell site, you'll probably realise it's been a bit neglected in the last few years.


TRAC. Only language I've ever used where you're supposed to write self-modifying code.


PROGRESS: UI + database querying language all wrapped into one. Like many 4GL languages it is very powerful (one line of code to update a record in a database with UI) but as soon as you need to program for real life projects you needs thousands of lines of code, a real gasworks.
They even tried to simulate object-oriented programming with a procedural language - SmartObjects - boy did you have to be smart to program with them.
I used it for 12 years and I am happy to have left it behind.


MEL (Maya Embedded Language). A bit like Perl... But with some strange quirks that tooks some getting used to. Great fun though and very simple to create a nice tool to help with animating 3D objects and so on.

Used it once to tease an artist at work by creating this script that rotates the model by 1 degree every minute. Fun when things irritate people without them noticing it.


We have a production order management system for convertible bonds in K:



I would say that the worst experience I had in matter of programming languages was on early days of computing (my early days) When I had a Sinclair TK-83 (A kind of TK-85 Clone from MICROSIGA) where I used SinclairBASIC. What makes it weird is that I couldn't type the function names like using the five letters to write PRINT, but instead I had to use a combination of keys (SHIFT+FUNCTION P) and it was really awful to debug a 30 lines of code to discovery in the 14th line, a POKE command typed with P, O, K and E instead of SHIFT+FUNCTION K. I can say the language was made of key strokes like:

20 SHIFT+FUNCTION P PRICE;    //(print)
30 SHIFT+FUNCTION G 10;       //(goto)
> SHIFT+FUNCTION R            //(run)

Just in case you are wondering WTF is a TK-83, here you go...


I have to say it APL back in the mid-80's. This was a very symbolic language and was great if you were a mathematician or just a genius. Just in case you want to know more about APL: http://www.thocp.net/software/languages/apl.htm


I wrote an entire simulation of a train using the joyless mind-sapping thing known as ISaGRAF which is an "industry standard" system for creating electronic simulations.

And you can either write hardcore chip logic using something vaguely like Pascal, or with little drag and drop GUI diagrams that look very similar to flowcharts.

I'm sure it's not bad for a small system. But an entire train consisting of ten carriages and their electronics?

This was where I learnt that hardware designers think very differently to software people.


JCL - Job Control Language. Yup, in "Operations" with the wide tie wearing zombies who chose not to go to trucking school and decided that they, too, could have careers in the exciting field of data processing.

This was back in the days when you could have an ash tray at YOUR DESK! AWWWWWEEEESSOME!


In descending order of weirdness (from the languages that I have actually written "production" programs in):

  • APL: A Programming Language -- super powerful and super confusing. Perl is clear in comparison.
  • IBM 1401 assembly language. Optimized for character processing in 4KB of memory. Characters were 8 bits wide: seven for the character and one for the "word mark". The "word mark" bit was used to mark the end of strings (something akin to the null character delimitor for c strings). The copy/move string command would copy characters from A to B until it ran into a word mark in A (and sometimes in B). Bad things happened when you forgot to insert the word mark; the move would wrap around memory and wipe out what passed for the operating system control code in those days.
  • Snobol: a string processing language -- when I used it in the 70's, I was just realizing that not all language had to be procedural.
  • Prolog: Oddly enough much like Snobol in that it matches patterns.
  • AWK: a unix-style pattern-matching package that I used for close to 10 years for mangling characters as part of a file copy. Sort of like regular expressions on sterroids.
  • XSLT: When I was in the XSLT zone, I could do some wonderous things to XML files. But it took a while to get one's head wrapped around the functional approach.

For a serious answer, I've played around with J. There's no question that there's some interesting advantages to the language, but it's hard to see that when navigating the ascii noise syntax and non-existence of structured programming features most take for granted. About the best that can be said of it is that its' modern ascii is better than APL's historic non standard characters.

For a joke answer, it would have to be SKI combinators. Interesting as a learning curiosity, and that learning might lead somewhere valuable, but useless themselves.


One company I worked at used RTL2, they had pretty much the only licence in the country for the compiler.


CLIPS (used for cognitive modelling) its a wierd combo of PROLOG and c and some other languages, powerful but horrible. Im so glad that my university days are over!


STEVE: it's a robot simulation language.


By far, LOLCODE. Never developed a production app, but I've actually written small, sample programs in the language.


NCR-500 machine language: 12 decimal digits per instruction (2-digit opcode, 2-digits for each of 3 operand addresses, 2 digit conditional next instruction, 2-digit next instruction), and 4 planes of 100 memory locations. One can enter these instructions into memory using a console that looks just like a cash register!


TECO. The WPS-8 development group at DEC used software production tools -- Code Library (with locking checkout), Tree-controlled Builder (like MAKE), and a few others -- all written in TECO. I had to maintain them since the original author was no longer available as he had decided to go into another line of work.


I'll put my 2 cents in for Ladder Logic as well. It takes some getting used to, but when you get down to brass tacks, it's brilliant. You can do all the programming you want, and be certain that it can't crash. There's no conditional branching (but plenty of conditionals), so program flow is NEVER interrupted. Who else can write a program that executes every line of code every 8 milliseconds?



CLP for the iSeries / AS400 is the strangest language that I have ever used


used brainfuck.. took 2 days to code a 3 digit incrementor


Robbins-Gioia CAT II 4GL programming language (CAT=Control and Analysis Tool)

I guess it's not that "strange", but when I first started my job, i couldn't find anything about it on google. I don't think anyone actually uses the software besides the government.


One of the first languages I ever worked with was TCL, which is not Tcl. It was Western Union's Teletype Control Language. Mostly, it existed for the techs to be able to carry around strips of paper tape to reset machines that had gone loopy. But, it was powerful enough to allow the TWIX (not the candy) my father had reassembled in my bedroom to act as a very simple printer for my Atari 800XL.

Oh, and PAL--Paradox Access Language, which was a pre-SQL database query tool that you programmed by drawing pictures with ASCII characters. I kid you not.


Lingo. A really bizzare hack of HyperText that never worked how you would expect it to. Macromedia Director projects were a time-draining chore due to the necessity of using it.


I actually had to write a Brainfuck interpreter (in an imaginary assembly language!) for a class once.


In the '80s, I used MIP-2 (I think that's the correct spelling). Management Information Package v2 to write a nightly closeout system (calling it "accounting" would give it too much credit).

It was a proprietary language on National Semiconductor grocery store checkout systems. The syntax was like assembler. E.g. add op1, op2. It also included Basic-like Input and print functions and it was interpreted. The only "data structure" was a one dimensional array. I had to create a 2D table in the code. The icing on the cake was that you had to send the file from the mainframe to a remote system via bisync modem in order to debug the code. If there was a syntax errror, the load would fail. No messages, just failed to load.

Those were the days!


I think the MUMPS answers are unfair. The single letter commands were shortcuts to save program size space - which was an issue in 1978. However, you could spell them out and follow good structured design if you wanted to, certainly by mid-80s when most of the space limitations disappeared. To me the only strange thing about MUMPS was the persistent data which removed the need to interact with a database. It does have a funny name, but certainly assemblers, embedded systems, and experimental/educational things must seem much stranger.

By the way - it's a real world thing. A ton of commercial products based on it.


Frontier. A combination outliner, object database, programing environment. The only language I have ever used where the outline level was a syntactically relevant feature. A lot of fun to play with and I used it quite a bit years ago doing admin work for Macintosh system 7 machines.


Has to be LISP, though the only "real world" use I ever made of it was in a course on LISP and AI, a long time ago.


When I took a course on AI, I learned LISP and Prolog in the same semester. I never could decide which was stranger, but LISP just seemed to be much more difficult for me to understand. Too many parentheses I think.


Not really strange, but I thought having to use Scheme and Oz for university assignments was funny. I do know Scheme is pretty common for learning programming basics, though; yet several of my subsequent professors mocked it since I would never have to use it for anything realistic again. The most different thing I've had to code on would be PIC and AVR Assembly Language, but that's not really strange either, just complicated and mind-bending :p


Not much experience, but I think it was LOGO - it is just a bunch of math functions.


KAREL. It is used in programming education. Basically you control Karel (a robot - does the name Karel Capek ring the bell to somebody?) with simple commands. The thing is, Karel is a dumb robot in its own, so you get to teach him new commands.

For small kids education it's a great thing :-) It's certainly not used for real-world problem solving, but I couldn't resist the temptation to mention it, nostalgically, anyway.


FORTH and Prolog. I enjoyed both, but as far as I know both are pretty much dead languages now. FORTH worked great on my Atari800. Took a little getting used to, but it was fun. Prolog was great for some of the AI work I used to do in school.


I vote Erlang. Partly because a purely functional language is always going to be a shock if you are coming from procedural and OO languages, but also it's focus on concurrent programming reveal a very interesting bias. I think it's a very valuable paradigm to experience.


Ladder Logic is a language used to emulate the functionality of electromechanical relay control circuits. It is generally used in industrial process control systems in programmable logic controllers.


ARexx. Not really "strange", just somewhat obscure.


Must be GWBASIC. At age 6. All those line labels!!


ML and also APL. Both involve writing code that looks like it can't possibly do anything useful.


I don't think you'll ever find referencese to STRATOS. You had to write it in reverse polish, and all functions were horrible three letter acronyms.

I've always thought that it was a school project for creating a parser, and the students who wrote it, adapted and sold it to some stupid company (ours).

It was some kind of assembler, but it was meant to manage databases.


CLU was the first one I thought of, but this was in college and doesn't meet your real-world criteria. Also, CLU is not odd, it's obscure. APL, needing its own keyboard for its own syntax has to be the strangest that I've played with, but again, I've not used it for a real world application. I suppose programming my HP TI-59 calculator would be the weirdest programming language from my past. One guy published the program that allowed the TI-59 to play backgammon and the machine only holds 960 instructions. Genius!


Postscript. I will agree with a previous posting....I also will deny having ever used it.


Actually the language used by the TK-83 and TK-85 (which were Sinclair clones) computers was plain BASIC! I had and still have a fully functioning TK-85 with 48k memory. The problem with them was the keyboad. When typing text, the keys acted as regular nowadays keys. The "L" key meant the "L" letter. But when one was programing, by using key combinations, one would press the shift + the function keys and then any other key, the computer would write on the screen the meaning of this other key. So pressing the shift+function+"L", the computer would understand that you were actually typing "LET", and would write this word on the screen. So in the example given by Fernando Barrocal, once you've finished typing it, would actually be presented in the screen as :

original example :



30 SHIFT+FUNCTION G 10; //(goto)


would appear on screen as :

10 LET PRICE = 12


30 GOTO 10


In the beginning this way of programming was quite slow, because even with all keys having the programming meanings printed on them, it took some time to get used to it. But after a while, as with everything, once one got used with this way of entering commands and functions, the programming was VERY fast. With the left hand you would press the shift+function keys combination and with the other hand one would just keep pressing the keys with the commands and the computer would write the whole thing for you.


Miranda: http://en.wikipedia.org/wiki/Miranda_(programming_language)

Did a programming class where we had to implement a simple program ("fgrep") in a bunch of different languages. I skipped Prolog (left that to my lab partner), enjoyed Smalltalk, but was most impressed with Miranda: 4 lines (of which one was the "#!" line and one blank). Ada code was a few hundred lines spread over three files. :-)

My worst programming experience would have to be "sendmail" though. The configuration language for rewrite rules is in fact a proper lambda calculus. At one point I knew my way around it, three months after leaving that job, I couldn't for the life of me remember a single thing.


WinBatch. I'm not talking about regular windows batch files, this was a proprietary automation scripting product I had to use to write installation scripts at an old job. It could interface with windows native functions, but the whole thing was pretty clunky and it didn't offer much in the way of code re-use between files. I can see where it fits a niche, but if they just added a few modern language features it would definitely be an improvement. Its IDE isn't very helpful either. It's just... odd

I guess they have a CGI web script language out now. A bit scary.


Motorola C-5 Network processor microcode.
After 2 potential products failed miserably due to performance issues and Motorola discontinued the the C-5 management finally realized that this was a nice waste of a year for 5 people but its time move to another platforms.


It never had a name but my current job started out working with a "language" the consisted of a real-time rule enforcement engine based on a graph. It had no explicet sequential operations and allowed arbitrary linking. Also rules were first order objects. It was/is actually a really cool spectacularly flexible system, just totally impractical (system requirements >1GB ram and about 90s boot time).

The current incarnation is way different but is not quite ready for public consumption. ;)




I coded with this for a year in the early 90s. It is mainly strange because it is exotic, and not many people have professionally coded with it.

And, of course, Object Pascal incorporated most of the features of Modula-3.


I enjoyed the horrors of using Siebel 6.2 SmartScript for an online insurance quoting system. What made it interesting is that it was almost VB code that you actually coded into the database, but it could hit the underlying compiled VB/C code. This made the one project where it was used difficult since there were 4 developer all working on the same progression of screens in this work flow. Add to it that the built-in web based Siebel was unable to handle multiple browser windows.


I worked on Microsoft Great Plains.. Which uses Dexterity. For me one of the worst things about the language was the fact there was a limit to the size of the procedures you wrote.. I spent many hours removing comments, and renaming variable to 1 letter to get a few precious extra characters. I'd be interested to know if anyone else ever had to use it.


Cache Object Script.


Caché ObjectScript is a functional superset of the ANSI-standard M (ie, MUMPS) programming language.


About 10 years ago I was at a job that had a PRIME computer (yes, it was completely obsolete), and on it was a language called INFO. It was actually a scripting language and database together, and it was so easy to use, I was using it the first day. And so odd, that it was really easy to completely screw up the process. I don't have any example code, so I'll give you some ideas.

It had line numbers, and if the numbers started with an odd number, the statements were SQL like and worked on the entire set. If they started with an even number, the statements were procedural.

100 select * from table1 where field1 = "value1"

110 select * from selection set where field2 = "value2"

200 for each value in select set

210 field3 = field3 + 5

220 next

300 print field1, field2, field3 from selection set

It used an ISAM database, and it was quick to learn, quick to run, and if compiled code was needed, we could write it in CWIC, which then compiled to a FORTRAN. CWIC was also very easy to learn. But that odd/even line number changing the way the code was used allowed really complex, funky applications. (I'll have to go see if I can find a real example.)


For me, definitely ObjectVision It even beats out Forth.


Word Perfect Macro Language for WP5 for DOS. It was late 80's early 90's as I remember.




Linc 4 GL. Then Cobol was generated as running code.


Lots of possibilities here.

machine languages:

  • DigiComp
    used because:
    1. only language I knew - my first.
    2. only language spoken by the platform.
  • IBM 360/70 channel controller microcode
    used because:
    1. the i/o hardware guys had to steal something,
      and big blue's channel controller was covered in POO.
    2. software guys are, for the most part, completely POO less.


  • A weird AT&T micro implementing an abstract machine (aka a DSL),
    with 3 numeric registers (can do arithmetic),
    a string register or two (can index, substring, and catenate),
    PLUS an entire 256 bytes of RAM - all for data.

    used because:
  • someone, upon seeing the machine,
    cleverly realized it was actually a
    platform for small business accounting software.
    in disguise.
  • hummer winblad would need funding, someday.
  • Cray-1

    Load a register from memory?
    No, no, no, my friend.
    Move an address into one of these registers, over here.
    Now do something else, entirely unrelated, for a while.
    Ok, now look in this other register, over there.
    Tada! - It's that data you wanted from memory.
    See - easy, peezy.

higher level:


    used because:
    1. writing the code to translate a runway coordinate database
      takes the same number of weeks as doing the translation by hand.
    2. writing code is more fun.
    3. fuzzy math is easier than it sounds.
      e.g. what is one times fuzzy risk plus zero times nothing?
      four - 'cuz zero times never again divided by BUFD equals three.
    used again, and again, and again
    1. bootstrapping (a new language)
      without SNOBOL
      is like a day without sunshine.
      30 times in a row.
    2. every time.

How about something a bit weirder?

Severely, grotesquely weird?


  • HTML - Eeou, yuckey weird.
  • C++   - You must be joking weird.
  • Java  - Ok, just stop it. This isn't funny any more weird.

And finally, there's the absolute, hands down, weirdest weirdo of them all:

  • Smalltalk - through the looking glass weird.
                        A lot like nirvana. (The concept, not the band)
                        Having arrived you can never go back, never,
                        and you mustn't even try - for then the weirdness,
                        my god, the weirdness -simply unbearable.
                        Now how weird is that?
  • SAIL
  • XPL

IBM ImagePlus MODCA Image Rendition.

Pretty advanced format in the days when every KB counted - you'd have a complex metamodel with overlays, image data, scale information and a number of variants - IOCA/PTOCA. Very unusual in the world of image processing.


I have never seen something as strange as Centura and its weird IDE Gupta.


I can hardly say i've used it in anger, but for a while, iShell was free for many uses, And it provided better multimedia support than HyperCard (like color!), so we chose it for our final project. The programming 'language' was a visual one, with drag and drop source editing. It was actually fairly natural to use, once you got used to finding the pieces to place.

screencap of iShell Programming

Ultimately, the project suffered from a lack-of vision on all-our parts, and so we never got much farther than a dozen rooms of content with a few interactive elements.

If i had to make a similar presentation-oriented app again, and didn't need anything like a database back-end, xml-rpc or other such silliness, iShell might fit the bill.


The first time I used LISP I felt like I had just been shown the matrix. It was a terrible, overwhelming feeling of hopelessness and parentheses.


Easiest question in a while. The answer is TECO: TECO - Text Editor and COrrector

Lets see what the code formatter makes of this example from Wikipedia:


Back at the height of the .com boom I worked on a project to create a remote testing automation system for network switch as a contractor. The language spoken by the switches was an implementation of MML originally written by a small Russian company. It was so hard to understand the language due to it's lack of constant structure and style that we ended up writing a PERL parser act as an intermediate layer and protect everyone on the projects sanity. All during the project I had flashbacks to my college course on x86 assembly...

On the other hand... I've always enjoyed LISP... emacs or ansi I love parens! Seriously I took the red pill during and AI class in college and have been modifying emacs sense. As an added bonus it makes the noobies eyes hurt.


SIC - The Single Instruction Computer.
The assembly of this theoretical computer has only one command:

SBN - Subtract and Branch if Negative:


if((Memory[A] -= Memory[B]) < 0) goto C  
// Wikipedia has a slightly different definition

This computer is in fact Turing complete. As a university assignment in Compilation (using Scheme), we were given an emulator of such a computer, and had to write a compiler to help us calculate the factorial of a number. Some students though writing the compiler was too hard and coded the entire program by hand, which was OK with the professor as long as it worked (I guess it taught them the value of a compiler).


Around 2005 I programmed in SDL, which is quite a weird environment, mixing flow diagrams with code in a hard-to-debug-and-weird software pieces. It was like having an UML diagram with embedded code.

We used SDT (then Telelogic, now Rational SDL) and they have a lot of strange bugs in the compiler like problems with string concatenation and weird warnings.

For me it was painful but the communications guys seemed happy. Strange people...

For an example: SDL Tutorial


I was working in UNIFACE. Kind of evolved from character-terminal-oriented, platform-independent forms designer, but I was using it for program which was supposed to run on PCs...


The strangest programming language I've ever programmed is the Lisp language. It changes your way of thinking about computation. It's beautiful and amazing :-)


Its got to be.... Var'aq, But if you are a Trekkie you would probably like it.

And if you are truly interested, Intro to Var'aq


It was called INFO, and it ran on an old Prime. It was a database and a language and a IDE. But what was weird was how it was written.

It was so easy to learn, that I was programming the first day, and yet was capable of true oddness. The programs had line numbers, and if the numbers started with an odd number, the commands were SQL like and worked on the entire set. If they started with an even number, the commands were a block that dealt with each item in the set one at a time.

So, a simple type of program could be something like this (I don't recall the syntax either)

100  select * from user_table 
110  join with address_table 
120  exclude duplicate addresses 
200  for each record in set 
205    print firstname, lastname 
210    print addressLine1 
220    print City, State, Zip 
300  display "address labels printed" 

It was capable of quick and impressive applications, that were almost simple to understand, and yet had a sneaky power that I was only beginning to understand after two years at the job.


COBOL was pretty weird - it was like writing prose. The strangest had to be ladder logic for PLC hardware - programming by circuit diagram!


PAL (Playlist Automation) script, its used for automating playlist information inside DJ software.




I did not actually use it but read a lot about MUMPS..


Brainf*ck is pretty weird, but I can't say I've ever used it for anything "real".



Hated it from the first go.


ABAP is a mixture of Clipper, Delphy (Pascal) and C, so it is no so bad.


ERLANG is quite interesting, although as languages go, it's fairly sane. It's scalability is stupidly cool, though.


B or BCPL, the predicesor to C. used C like control statements mixed with assembly. I worked a packet switching network stack in it at Honeywell in the early 80's. Nearly fried my brain trying to debug the system


Verilog, a hardware description language. Which means it compiles into gates. You feed this into a gate-simulator, and if that works an FPGA, and if that works you tape-out and make a chip. What's really weird about it is that everything you write happens at the same time. If you want sequencing, you have to build circuits for that.


Definitely Java.

I mean, I have used MUMPS, Forth, APL, Lisp, ML, various assemblers, Logo, Prolog, even Postscript. And while they might LOOK different than what passes for mainstream languages nowadays, they each had purpose, character. They knew what they were about.

Java... Java is an horrible language in the very field it choses to address. Most non-newbie programmers readily admit that. And, yet, it's widely used. That is SO STRANGE!




mIRC sripting :D


An in-house, proprietary "language" called Nexus.

Creating programs for this systems involved editing a number of INI files. One file would describe all of the forms for the application, something like:


Okay, hopefully you get the idea, without me having to add more. Basically, each line within a section would describe the control you wanted, where it was positioned, captions, etc.

Then there were other INI files. One described the complete database (one section per table). One described broadcast events (each section described an incoming message - possibly from a control, from another event, from the server, and the lines within the section described what new events to raise). One described the over-the-wire messages that were sent to the server (this one was a joy, because each message you wanted to construct to send out had to be crafted by a single SQL statement against the database). All in lovingly hand-crafted INI files.

Of course, there was no compiler. Errors would be raised when the application started up (or possibly later). Of course, depending on what mistake you'd made, you might get an intelligent error message, or you might get an obscure error message from half way down within the custom-built INI file parser...

They kept promissing that an editor was going to be developed...


For me it was Mozart-Oz, a strange language that I used in my 2nd year of uni - Had to develop a maze generator / solver with it.


A few years ago, I was doing some hobbyist work with the OHRRPGCE game creation toolkit. The scripting language bundled with it, Plotscript, was to say, one of the oddest languages I've ever worked with. (Now, this was an older version I used, so things may have been changed.)

For starters, in addition to being case-insensitive, it was also whitespace insensitive. I.E., any and all whitespace, save the newlines needed to work it, was stripped by the compilier.

Functions had to have their signature defined before actually having the function itself defined. For example, at the top of the file, you'd have:

define script (5,chest item,1,0)

And later on you'd put:

script,chest item,item to get,begin
    get item name (1,item to get)
    show text box(63)
    get item (item to get)

Variable declaration was done by calling a function with the name of the variable, and then it could be set. Globals were defined with a different function in the global scope.

variable (hero combined health)
hero combined health := 0
if (hero by slot (0) >> -1) then(hero combined health += get hero stat (hero by slot (0),0)
if (hero by slot (1) >> -1) then(hero combined health += get hero stat (hero by slot (1),0)
if (hero by slot (2) >> -1) then(hero combined health += get hero stat (hero by slot (2),0)
if (hero by slot (3) >> -1) then(hero combined health += get hero stat (hero by slot (3),0)
if (hero combined health << 1) then,begin

That was supposed to check if the player's party still had any HP remaining. Isn't it obvious?

Also, another thing I've noticed looking at my old scripts was that operators were never less than two characters long. Subtraction was --, greater than was >>, etc.




SNOBOL, particularly the C-SNOBOL4 variant by Phil Budne. It is strange by most standards, but incredibly expressive and powerful. I'd use it more if I could.

Some interesting examples are at http://web.archive.org/web/20061003165457/http://lands.let.kun.nl/TSpublic/coppen/DirtySNOBOL.html

P.S. The above url does not format well in []() markup.


PCL - printer control language. We used to hack it to change form data on printers because our PCL generator was a bit wishy washy so we had to manually edit it a lot. Also, we had a printer that didn't quite use official PCL, but it's own variant, which caused all sorts of headaches.

Also, PCL is not very readable.

PCL isn't dead, but it's obscure as all get out IMO


mIRC Scripting

When I was in school I used this to generate some data for some projects (peoples names, birthday dates etc)

I also did a lot of scripts just for fun. It now seems strange and featureless compared to languages I have learned and worked with. Still, I had a lot of fun with it.


C++ templates

are the oddest thing I have ever used.


AMX Axcess. Back in the mid nineties I worked for a videoconferencing company, back in the days of £20K hardware codecs and multiple ISDN lines. We used a control system made by AMX which had a touch screen control panel which you could design screens for using a very basic GUI tool.

The language was a lot like C in some ways, but used all kinds of odd commands for controlling a whole range of plug-in boards which you could control relays/potentiometers/RS232 comms/etc which we used for video switching, camera moving etc.

The strangest thing about the language was that it ran in a constant loop, so once the code reached the end it would start back at the top again, in a kind of never-ending procedural way.


I worked as an APL programmer in 2005-2009. It was definitely a weird choice to build a Windows application in, but as they say: you can write FORTRAN in any language.

It wasn't so bad by then, since the vendor (Dyalog Ltd) had actually implemented if and for, but one of my older colleagues didn't trust this new for loop concept and used conditional gotos instead. That's how he did it in the good old days, and saw no reason to change.

If you had a programming question, there was really only three places to ask: the senior programmers at our company, Dyalog's support or the mailing list. I never tried it, but I can't imagine getting answers at Stack Overflow.

Unfortunately, most Dyalog APL users weren't doing modern Windows apps, which meant that we found lots of GUI bugs that then were ignored. It didn't make sense for Dyalog with 5-10 programmers to fix bugs that only affected one customer (and the language is of course closed-source).

The same thing with the library; noone else seemed to have a need for SSL, encryption and hash functions, XML parsing or other modern techniques. This was very frustrating, and we even discussed sponsoring a full-time developer for Dyalog that would fix "our" bugs and "our" features.

(Oh, and did I mention the developer license is £850 per year, and our customers also had to pay horrible run-time licenses...)

I learned a lot from APL, however, and sometimes miss its powerful array manipulation.


I had to work on a project in PROLOG while still in high school. I had only worked in Basic and Fortran before that. Blew my mind.


Visual Basic 6.0.

Although I have to say that since then I know why about 95% of the "developers" out there are completely incompetent. I usually call them "RAD - victims".

Second worst was this "javascript".

A language that is so full of pointless problems, you need user agent detection all over the place, you have no real type system (my hate for dynamic typing comes mostly from javascript!), etc...

Third worst was C++.

An unreadable mess, mostly to satisfy the needs of narcistic "zomg I'm soooo 1337 lolz" - nerds.


I'm so glad that we have REALLY usable programming languages now. C# and F#.