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.



Chris Upchurch
Ook! has real world applications?
+6  A: 

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.

Chris Nelson
Supposedly called that because it's effect on the programmer is similair to another RPG (rocket propelled grenade)
Martin Beckett
Ran into it but never actually dealt with it--we abandoned the whole system before it got that far.
Loren Pechtel
I once heard of a Star Trek game written in RPG. Never did find out anything further about it.
David Thornley
+3  A: 

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

LabView isn't bad for what it does, similar to it is SciTegic Pipeline Pilot.
+1  A: 

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

Lewis Jubb
+2  A: 

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.

+4  A: 

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.

+1  A: 

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!


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

I work with a guy who programmed in MUMPS back in the day. He still waxes nostalgic about it since there were no data locking issues (supposedly) and it was all much simpler than the current N-tier application layout.
Jason Z
@Jason - No data locking made things easier? Did they have to code for race conditions, or did MUMPS handle that for them?
+4  A: 

AppleScript is pretty weird I think. Examples


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

... which is exactly why I listed it as a bad example of a "strange" language ;)
Anders Sandvig
+10  A: 

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

Joel Coehoorn
The original MS-DOS batch language was quite limited, yes, but both Windows NT/2000/XP/2003 and 4DOS/4NT have some neat extensions that make it all more usable.
Anders Sandvig
MS-DOS batch was interpreted, line by line. You could do interesting stuff by getting the batch file to rewrite its own lines as it ran. I don't know if this still holds for Windows, fortunately I have better options available now.
David Hicks
Batch files are pretty powerful and can help do soem amazing things. Yes powershell, vbscript, and jscript are more powerful... but they also haver a higher learning curve and external dependancy.
Matthew Whited
I'm not saying you can't do anything -- only that it's painful.
Joel Coehoorn
@David Hicks: Yes, if you change the .cmd or .bat file while it's running it'll continue executing from the same offset it left off at. So you can have it rewrite itself. Be careful if you edit it manually while it's running!
Drew Noakes


Hated it from the first go.

ABAP initially seems pretty archaic, but it's really efficient for database driven stuff. Sure it's a bit of a shock if you're coming from something like Java or Ruby, but take another look - there are many jobs to which ABAP is really well suited.
Chris Carruthers
+9  A: 

Forth - bonkers. Brilliantly bonkers.

Rik Garner
You can't find a link for Forth?Actually I don't think Forth is all that strange.
I don't either. But everyone else does.
Lotsa luv for FORTH. A couple of colleagues had developed an assembler in FORTH (where you also wrote the assembler in FORTH, then X-compiled) that was strange at first, but soon a thing of beauty. Used it quite extensively some 25 years ago. Would not mind using FORTH again if I ever came that close to writing assembler again.
+3  A: 

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.

I was going to say this. Occam has PAR and SEQ keywords that you could put around statements (run parallel or in sequence) and functions could have more than one return value (first time I ever saw that).
Lou Franco
+3  A: 

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

Weird, maybe. Painful, definitely. I am using it now. Just today had to delete a set of records. Oh, the pain...
Grant Johnson
+2  A: 

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.

Lots of people are using Haskell - you can check out Hackage to see what they are doing. There is also a very active Haskell IRC channel on freenode.http://hackage.haskell.org/packages/archive/recent.html
+39  A: 

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.

Interesting story. Exactly the kind of "war story" I was looking for. :)
Anders Sandvig
I just left a market research job... quancept - and it's processing companion Quantum - are special little languages
http://www.thinkgeek.com/tshirts-apparel/unisex/frustrations/374d/ This t-shirt fits very well.
Ólafur Waage
+16  A: 


I have enjoyed it though :)

prolog must die!!!! The problem is, XSLT is almost the same thing..
Yes :)
Tim Matthews
@Alex -they're completey different: xslt is just another functional language, but prolog is a logical* language, orders of magnitude more complex
+5  A: 

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.

Paul Reiners
I'm just starting to play with ChucK myself, and love the time paradigm it uses too. I'm hoping I can stick with it long enough to get over the learning curve…
+20  A: 

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.

Mario AT
You have to realize where it started though... working on a PDP-9 back in 1971?!? where memory was at a total premium. I worked with MUMPS for 10 years and it gave way to very concise programming when the max sometimes your programs could be was 1000 characters or less :P
I applied to work at Meditech, creator of MUMPS, a couple of times. I remember taking an M/MUMPS test as part of the interview, but can't remember anything about it.
All of the MUMPS commands have mnemonics (S=SET, G=GOTO, W=WRITE). They just aren't used by most programmers since the size of the source code matters for performance, at least on the older platforms. Anyway, there aren't that many commands so this quickly becomes intuitive. The lack of any way to break out of a nested loop (you usually end up setting a quit flag and checking it all the time) is definitely a bigger problem than one-letter commands.
Nate C-K

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

Mario AT
+4  A: 

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

+2  A: 

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


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

+2  A: 

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.

+1  A: 

STEVE: it's a robot simulation language.

For as silly and arbitrary as the syntax is, Steve is incredibly well thought out. when the python binding for breve matured, I never found it really as clear for physical simulations as steve, so avoid it, even when I use python for many other things.
+1  A: 

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

+5  A: 

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......


Seems like fun :)
+6  A: 

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.

Peter LaComb Jr.
Sweet! I wonder what justifications they had for implementing it that way... ;)
Anders Sandvig
+1  A: 

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!

+6  A: 

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


Todd Johnson
Icon was the first language I noticed that had generators and iterators. Awesome.
+1  A: 

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.

+1  A: 

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?


Mike Warot
+1  A: 

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

+2  A: 

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.

Jon Gretar
+1  A: 

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

Abhishek Mishra
+1  A: 

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.

+1  A: 

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.

+4  A: 

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".

Graeme Perrow
Definitely has to be APL, what with its own character set and all. @ Gaeme: Your actuary friend is correct. When it comes to array manipulation, APL is extremely powerful.
+1  A: 

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.

Nathan Chase
+3  A: 

Inform 7. http://www.inform-fiction.org/I7/Inform%207.html

+2  A: 

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


Moose Y Anon
+1  A: 

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


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

+1  A: 

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!

+1  A: 

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.

+10  A: 

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.

+2  A: 

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...

Fernando Barrocal
+1  A: 

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.

+1  A: 

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.

Will M
+1  A: 

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.

Scottie T
+21  A: 

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 can't be sure it even rendered correctly here. I liked the overstrike characters in the first version--very creative. APL set me up for the "carry everything you've built around with you" workspace that I later enjoyed with FORTH.
I liked APL. We used it for Physics class back in college. Don't remember enough to have any idea what the above code does though 8-)
My numerical methods course was in APL. The prof did automated grading of our programs. They had to work and the fewer characters they were, the higher your grade.
+2  A: 

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

+1  A: 

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

Sergio Morales
+13  A: 

Definitely LOLCODE

Example lolcode program:

    UP VAR!!1
But did you *really* used this language?
This really made me laugh ;-)
@Koning Baard XIV: I would really like to se your php interpreter for LOLCODE :)
@Koning - isn't is 'TEH' not 'THA' in lolcode?
Michael Baker
+4  A: 

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.

+1  A: 

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

+1  A: 

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.

petr k.
+1  A: 

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.

+1  A: 

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.

Toby Hede
+1  A: 

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.

+1  A: 

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

Michael Stum
+1  A: 

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

+7  A: 


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


Chris Mazzola
I don't think postscript itself is so bad, but what Adobe puts in their files counts as high treason.
Adobe is the company for which this phrase was coined:"If all you have is a hammer, then everything looks like a nail."
Aww! I noodled around with postscript a bit (enough that i could write loops to plot points from arrays of data, draw grids, etc), and i rather liked it. It seemed to have a pretty clean and nicely homoiconic approach to defining functions and so on.
Tom Anderson
+1  A: 

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

+1  A: 

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.

+1  A: 

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!

Carl Camera
+2  A: 

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.

+1  A: 

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

+1  A: 

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.

Mario AT
I have a vague memory of Vic-20's working this way too
CAD bloke
+4  A: 

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.

David Locke
The langauge is called CLIPS. I've used it in a class.
Thanks, that's a very cool thing to learn.
David Locke
+1  A: 

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.

+1  A: 

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.

+1  A: 

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.

+7  A: 

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.

Speaking of sed, someone managed to implement Tetris in it: http://uuner.livejournal.com/55238.html -- quite impressive, indeed.
Anders Sandvig
+23  A: 

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.

I actually thought that XSLT was a very elegant way to transform one xml document into another. I used it do do just that as a batch process with a large number of UI pages defined in XML for a (now published) game I was working on. I also created XSLT to create shcmeas from similar component defs.
Tom Leys
If you take a closer look at it, you'll see that templating and transforming tree structures are nearly the same thing. :-) And yes, templating (i.e. creation of HTML and PDF representations of plain XML data) is the one application the whole XSL is designed for.
It's also Turing complete: http://www.unidex.com/turing/utm.htm
+1  A: 

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. ;)

+3  A: 

Prograph which was a visual programming language.

Mark Stock
+3  A: 

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).

My college assignment was to write a LISP interpreter in SNOBOL4. Sigh, good times.
uncle brad
+3  A: 

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

Robert S.
I liked rexx, i missed better math support in it.
I missed the rexx boat in my Amiga days.
Robert S.
Isn't REXX basically what perl would have been if it was invented by a COBOL instead of a C programmer?
Tom Anderson
Oh, those guys who were so frustrated with DOS batch LOVED rexx. It was truly a cult.
+20  A: 

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.

Re Perl - ain't that the truth. Once you get the hang of it, you can do some great stuff very quickly, but it doesn't leave your brain the same as it was before - and not in a good way, like LISP.
Tom Anderson
Perl; the way *I* write it is fine.It's when I read some "guru's" obfuscated "ain't my code economical and awesome" monstrosity, that I find myself wanting to check-in to a rubber room at Arkham. Yes, it's very nice that you can write in one line what takes me 50. Why didn't you write it in ASM? Code has two purposes: Communicate instructions to the machine, and communicate instructions to the other programmers who have to maintain it. Perl is a great language, but can often fail spectacularly at purpose #2.
@NDP Word up! Sorry, I mean: yes, totally. Clever code is about the dumbest thing you can do to your future self, in any language.
+1  A: 



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.

+1  A: 

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.

+1  A: 

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.

+1  A: 

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.

+1  A: 

Cache Object Script.


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

+2  A: 

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!

David Robbins
+1  A: 

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.)

+1  A: 

For me, definitely ObjectVision It even beats out Forth.

le dorfier
+1  A: 

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

+1  A: 


+2  A: 

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.
+1  A: 


+1  A: 

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

Zsolt Botykai
+1  A: 
Jim Sawyer
+1  A: 
  • SAIL
  • XPL
+1  A: 

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.

+1  A: 

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

Paulo Guedes
I though Centura was pretty straight forward. Trying to debug a Nightmare of Multiple Inheritance Spaghetti Code was not.
+3  A: 

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.)

I got so used to this, that when they finally made me buy a 'brand X' calculator that I had to take foreign languages just to have enough curse words to describe it. Why in the world would they give you a language that can do Diff-E but has no high-order functions or first class collections!?!

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.

+1  A: 
+1  A: 

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.

+1  A: 

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:

makes the original emacs seem more impressive.
Roman A. Taycher
+3  A: 

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

+2  A: 

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.

Jason Watkins

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!

*Java is an horrible language* A part of me just died.
Delan Azabani
+1  A: 

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.

+1  A: 

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).



Josh Einstein
+1  A: 

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

Marc Climent
+1  A: 

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...

Srdjan Jovcic

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.


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.

Ed Schembor

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

George Sisco

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.

Snake Plissken
+1  A: 

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 :-)

+1  A: 

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

seems with geocities some klingon knowledge faded away ..
not for esolang: http://esoteric.voxelperfect.net/wiki/Var%27aq ;)
+1  A: 

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.

+2  A: 

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.

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#.

Turing Complete

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.

Ira Rainey