[programming-languages] What is the worst programming language you ever worked with?

If you have an interesting story to share, please post an answer, but do not abuse this question for bashing a language.

We are programmers, and our primary tool is the programming language we use.

While there is a lot of discussion about the best one, I'd like to hear your stories about the worst programming languages you ever worked with and I'd like to know exactly what annoyed you.

I'd like to collect this stories partly to avoid common pitfalls while designing a language (especially a DSL) and partly to avoid quirky languages in the future in general.

This question is not subjective. If a language supports only single character identifiers (see my own answer) this is bad in a non-debatable way.

EDIT

Some people have raised concerns that this question attracts trolls. Wading through all your answers made one thing clear. The large majority of answers is appropriate, useful and well written.

UPDATE 2009-07-01 19:15 GMT

The language overview is now complete, covering 103 different languages from 102 answers. I decided to be lax about what counts as a programming language and included anything reasonable. Thank you David for your comments on this.

Here are all programming languages covered so far (alphabetical order, linked with answer, new entries in bold):

ABAP, all 20th century languages, all drag and drop languages, all proprietary languages, APF, APL ⁽¹⁾, AS400, Authorware, Autohotkey, BancaStar, BASIC, Bourne Shell, Brainfuck, C++, Centura Team Developer, Cobol ⁽¹⁾, Cold Fusion, Coldfusion, CRM114, Crystal Syntax, CSS, Dataflex 2.3, DB/c DX, dbase II, DCL, Delphi IDE, Doors DXL, DOS batch ⁽¹⁾, Excel Macro language, FileMaker, FOCUS, Forth, FORTRAN, FORTRAN 77, HTML, Illustra web blade, Informix 4th Generation Language, Informix Universal Server web blade, INTERCAL, Java, JavaScript ⁽¹⁾, JCL ⁽¹⁾, karol, LabTalk, Labview, Lingo, LISP, Logo, LOLCODE, LotusScript, m4, Magic II, Makefiles, MapBasic, MaxScript, Meditech Magic, MEL, mIRC Script, MS Access, MUMPS, Oberon, object extensions to C, Objective-C, OPS5, Oz, Perl ⁽¹⁾, PHP, PL/SQL, PowerDynamo, PROGRESS 4GL, prova, PS-FOCUS, Python, Regular Expressions, RPG, RPG II, Scheme, ScriptMaker, sendmail.conf, Smalltalk, Smalltalk , SNOBOL, SpeedScript, Sybase PowerBuilder, Symbian C++, System RPL, TCL, TECO, The Visual Software Environment, Tiny praat, TransCAD, troff, uBasic, VB6 ⁽¹⁾, VBScript ⁽¹⁾, VDF4, Vimscript, Visual Basic ⁽¹⁾, Visual C++, Visual Foxpro, VSE, Webspeed, XSLT

The answers covering 80386 assembler, VB6 and VBScript have been removed.

Javascript before the existence of FireBug and coding it using a Notepad.

It was the most horrible code in my life, JS was case sensitive and I had lot of headaches. IE detect errors in a weired way...

VSE, The Visual Software Environment.

This is a language that a prof of mine (Dr. Henry Ledgard) tried to sell us on back in undergrad/grad school. (I don't feel bad about giving his name because, as far as I can tell, he's still a big proponent and would welcome the chance to convince some folks it's the best thing since sliced bread). When describing it to people, my best analogy is that it's sort of a bastard child of FORTRAN and COBOL, with some extra bad thrown in. From the only really accessible folder I've found with this material (there's lots more in there that I'm not going to link specifically here):

• VSE Overview (pdf)
• Chapter 3: The VSE Language (pdf) (Not really an overview of the language at all)
• Appendix: On Strings and Characters (pdf)
• The Software Survivors (pdf) (Fevered ramblings attempting to justify this turd)

VSE is built around what they call "The Separation Principle". The idea is that Data and Behavior must be completely segregated. Imagine C's requirement that all variables/data must be declared at the beginning of the function, except now move that declaration into a separate file that other functions can use as well. When other functions use it, they're using the same data, not a local copy of data with the same layout.

Why do things this way? We learn that from The Software Survivors that Variable Scope Rules Are Hard. I'd include a quote but, like most fools, it takes these guys forever to say anything. Search that PDF for "Quagmire Of Scope" and you'll discover some true enlightenment.

They go on to claim that this somehow makes it more suitable for multi-proc environments because it more closely models the underlying hardware implementation. Riiiight.

Another choice theme that comes up frequently:

INCREMENT DAY COUNT BY 7 (or DAY COUNT = DAY COUNT + 7)
DECREMENT TOTAL LOSS BY GROUND_LOSS
ADD 100.3 TO TOTAL LOSS(LINK_POINTER)
SET AIRCRAFT STATE TO ON_THE_GROUND
PERCENT BUSY = (TOTAL BUSY CALLS * 100)/TOTAL CALLS

Although not earthshaking, the style of arithmetic reflects ordinary usage, i.e., anyone can read and understand it - without knowing a programming language. In fact, VisiSoft arithmetic is virtually identical to FORTRAN, including embedded complex arithmetic. This puts programmers concerned with their professional status and corresponding job security ill at ease.

Ummm, not that concerned at all, really. One of the key selling points that Bill Cave uses to try to sell VSE is the democratization of programming so that business people don't need to indenture themselves to programmers who use crazy, arcane tools for the sole purpose of job security. He leverages this irrational fear to sell his tool. (And it works-- the federal gov't is his biggest customer). I counted 17 uses of the phrase "job security" in the document. Examples:

• ... and fit only for those desiring artificial job security.
• More false job security?
• Is job security dependent upon ensuring the other guy can't figure out what was done?
• Is job security dependent upon complex code...?
• One of the strongest forces affecting the acceptance of new technology is the perception of one's job security.

He uses this paranoia to drive wedge between the managers holding the purse strings and the technical people who have the knowledge to recognize VSE for the turd that it is. This is how he squeezes it into companies-- "Your technical people are only saying it sucks because they're afraid it will make them obsolete!"

A few additional choice quotes from the overview documentation:

Another consequence of this approach is that data is mapped into memory on a "What You See Is What You Get" basis, and maintained throughout. This allows users to move a complete structure as a string of characters into a template that descrives each individual field. Multiple templates can be redefined for a given storage area. Unlike C and other languages, substructures can be moved without the problems of misalignment due to word boundary alignment standards.

Now, I don't know about you, but I know that a WYSIWYG approach to memory layout is at the top of my priority list when it comes to language choice! Basically, they ignore alignment issues because only old languages that were designed in the '60's and '70's care about word alignment. Or something like that. The reasoning is bogus. It made so little sense to me that I proceeded to forget it almost immediately.

There are no user-defined types in VSE. This is a far-reaching decision that greatly simplifies the language. The gain from a practical point of view is also great. VSE allows the designer and programmer to organize a program along the same lines as a physical system being modeled. VSE allows structures to be built in an easy-to-read, logical attribute hierarchy.

Awesome! User-defined types are lame. Why would I want something like an InputMessage object when I can have:

LINKS_IN_USE INTEGER
INPUT_MESSAGE
   1 ORIGIN             INTEGER
   1 DESTINATION        INTEGER
   1 MESSAGE
      2 MESSAGE_HEADER  CHAR 10
      2 MESSAGE_BODY    CHAR 24
      2 MESSAGE_TRAILER CHAR 10
   1 ARRIVAL_TIME       INTEGER
   1 DURATION           INTEGER
   1 TYPE               CHAR 5

OUTPUT_MESSAGE CHARACTER 50

You might look at that and think, "Oh, that's pretty nicely formatted, if a bit old-school." Old-school is right. Whitespace is significant-- very significant. And redundant! The 1's must be in column 3. The 1 indicates that it's at the first level of the hierarchy. The Symbol name must be in column 5. You hierarchies are limited to a depth of 9.

Well, ok, but is that so awful? Just wait:

It is well known that for reading text, use of conventional upper/lower case is more readable. VSE uses all upper case (except for comments). Why? The literature in psychology is based on prose. Programs, simply, are not prose. Programs are more like math, accounting, tables. Program fonts (usually Courier) are almost universally fixed-pitch, and for good reason – vertical alignment among related lines of code. Programs in upper case are nicely readable, and, after a time, much better in our opinion

Nothing like enforcing your opinion at the language level! That's right, you cannot use any lower case in VSE unless it's in a comment. Just keep your CAPSLOCK on, it's gonna be stuck there for a while.

VSE subprocedures are called processes. This code sample contains three processes:

PROCESS_MUSIC
    EXECUTE INITIALIZE_THE_SCENE
    EXECUTE PROCESS_PANEL_WIDGET

INITIALIZE_THE_SCENE
    SET TEST_BUTTON PANEL_BUTTON_STATUS TO ON
    MOVE ' ' TO TEST_INPUT PANEL_INPUT_TEXT
    DISPLAY PANEL PANEL_MUSIC

PROCESS_PANEL_WIDGET
    ACCEPT PANEL PANEL_MUSIC

*** CHECK FOR BUTTON CLICK
    IF RTG_PANEL_WIDGET_NAME IS EQUAL TO 'TEST_BUTTON'
       MOVE 'I LIKE THE BEATLES!' TO TEST_INPUT PANEL_INPUT_TEXT.
    DISPLAY PANEL PANEL_MUSIC

All caps as expected. After all, that's easier to read. Note the whitespace. It's significant again. All process names must start in column 0. The initial level of instructions must start on column 4. Deeper levels must be indented exactly 3 spaces. This isn't a big deal, though, because you aren't allowed to do things like nest conditionals. You want a nested conditional? Well just make another process and call it. And note the delicious COBOL-esque syntax!

You want loops? Easy:

EXECUTE NEXT_CALL
EXECUTE NEXT_CALL 5 TIMES
EXECUTE NEXT_CALL TOTAL CALL TIMES

EXECUTE NEXT_CALL    UNTIL NO LINES ARE AVAILABLE
EXECUTE NEXT_CALL    UNTIL CALLS_ANSWERED ARE EQUAL TO CALLS_WAITING
EXECUTE READ_MESSAGE UNTIL LEAD_CHARACTER IS A DELIMITER

Ugh.

Visual Foxpro

If we ask ourselves this question X years down the line (X = 10 or 20 or ?), we would all say in chorus that "all the languages of the 20th century sucked". Such would be the paradigm shift that we would be doing things in a much different way ... though I cant visualize how !

I really don't like Visual Basic, even the .NET versions. Frankly, I find the core of the language way to verbose.

For example:

If condition1 = condition2 Then
  ...
Else If condition1 > condition2 Then
  ...
End If

Public Function SomeFunction(ByVal arg1 As String, ByVal arg2 As Integer) As String
  ...
End Function

But in C#:

if (condition1 == condition2) {
  ...
}
else if (condition1 == condition2) {
  ...
}

public string SomeFunction(string arg1, int arg2) {
  ...
}

And obviously many other languages like F#, Python, etc. are much less verbose. I honestly feel like it takes me twice as long to use VB than other languages because of this.

I know this is quite a shallow answer, in part because it doesn't address some of the language concerns (like PHP's over use of global functions). But from a humanistic, 'experience-oriented' perspective, VB simply makes me grumpy.

DOS Batch files. Not sure if this qualifies as programming language at all. It's not that you can't solve your problems, but if you are used to bash...

Just my two cents.

I haven't yet worked with many languages and deal mostly with scripting languages; out of these VBScript is the one I like least. Although it has some handy features, some things really piss me off:

• Object assignments are made using the Set keyword:

  Set foo = Nothing
  

  Omitting Set is one of the most common causes of run-time errors.

• No such thing as structured exception handling. Error checking is like this:

  On Error Resume Next
  
  ' Do something
  
  If Err.Number <> 0
    ' Handle error
    Err.Clear
  End If
  
  ' And so on
  

• Enclosing the procedure call parameters in parentheses requires using the Call keyword:

  Call Foo (a, b)
  

• Its English-like syntax is way too verbose. (I'm a fan of curly braces.)

• Logical operators are long-circuit. If you need to test a compound condition where the subsequent condition relies on the success of the previous one, you need to put conditions into separate If statements.

• Lack of parameterized class constructors.

• To wrap a statement into several lines, you have to use an underscore:

  str = "Hello, " & _
        "world!"
  

• Lack of multiline comments.

Edit: found this article: The Flangy Guide to Hating VBScript. The author sums up his complaints as "VBS isn't Python" :)

IT baffles me sometimes to why a software company would develop its own scripting language to interface with their software, rather than building a strong API that can interface with your scripting language of choice. My vote goes to TransCAD's scripting language.

Bourne Shell

I once was running a invoicing system for a telecom company. This meant manually running a bunch of commands that would each in order collect, prepare, calculate, format and finally print the invoice. This would typically be done in batch form, so that I was told which customer numbers to make invoices for and I'd do them all in batch.

This was boring. So I started automating it. Unfortunately, the only language allowed on the servers was.... well none. At all. So I had to write everything in shell scripts. And that is a truly absurd and bizarre language. Nothing really much makes sense. It's inconsistent and overly sparse, so two similar things may do completely different things because a ? comes in a slightly different place. And using backquotes as a part of a language is just pure evil. They don't even look different from single quotes in some fonts!

I've had way worse programming experiences. WAY worse. But those has always involved maintaining other peoples bizarre code. But this has to be the worst language I've ever used. Worse than DOS Batch files? Oh yes. DOS Batch files main problem is that they are primitive. You have to find clever ways to make it actually do something useful. But the syntax itself isn't that bad. It just doesn't have enough built in functionality. Worse than Visual Basic? Oh yeah, without a doubt, although admittedly I wrote a UI to this Bourne Shell system in MS Access and that was almost as horrible, but just almost. And they communicated via Sybase, so I needed to learn Sybase SQL, which also is quite horrid. But still not nearly as horrid as sh-scripting.

So Bourne Shell wins the jumbo price for me. Only just, with VB close on it heels, but it still wins.

I was going to bitch and moan about Java, but obviously it isn't THAT bad and that would have amounted to trolling, and besides, I just remembered something far worse:

Magic II.

It just barely qualified as a language. Really, it could be more accurately described as a pre-SQL database system with a data driven programming model. It was based on the astute observation that almost everything you ever do with database tables involves doing something before you start iterating on the data, then iterating on the data, and then maybe doing something after you're done.

"Programming" Magic involves filling in fields in tables that describe those three phases of a program's life. It also had a text mode screen designer that tied in with this whole mess. A trained Magic user could knock out reports and data entry screens at a reasonably fast pace, which made management happy.

The problem for me was that the language had very minimal abstraction facilities. You could define routines that you could call from other routines. That's it. No data structures other than database tables, no in-memory arrays (you could define new tables, though!)

No hash tables, no way to organize variables (which the language did support) in any meaningful way. No lists. Nothing. Of course, no classes or anything resembling an object model, but honestly - I could live without that. And I did.

Worse yet, the "program" had bits and pieces that were hidden away in fields that you had to zoom into to be able to see - certain expressions, etc. So you could never just read a screen of code and know what it did.

This thing took data driven programming to its ultimate, sad apex. It's an obsession, manifested in a programming tool. I was glad to put that miserable piece of junk behind me.

Recently, I met a former co-worker who worked with me while I was using Magic. It's been almost 20 years since I've done that, but she was all too happy to tell me how she was tasked with maintaining one of my projects, and that she declared defeat when she found a recursive procedure in there somewhere. She had never seen anyone implement recursion in Magic. No one ever has. It was uncharted territory. I don't think anyone realized the tool was capable of recursion.

The project had to be rewritten in a hurry, before it caused someone's brain to explode.

I'm surprised that no one has mentioned INTERCAL: The Compiler Language with No Pronouncable Acronym. It doesn't have a goto statement. It has a come from statement!

Ok, seriously though, my two candidates are VB, and the combination of HTML, PHP and Javascript I have to work with.

VB because it has 5 different loop constructs. for, while do, and do while I understand. But do you really also need until do and do until??? Really?

HTML/PHP/Javascript not because of any specific feature of any of the languages, but because you can intersperse them in very very confusing ways. Opening an HTML tag, having some Javascript in there, and in the middle, starting a PHP if, closing the javascript and HTML tag, and then later closing the PHP, and having another close of the HTML and JS.... It ends up looking like (([ ) ] [ ) ] )

It might seem as though that's just bad code, but I haven't yet figured out another way to do what we're doing that way.

No answer about Cobol yet? :O

METLIFE ENGLISH LANGUAGE (MEL)!

I worked for a company that wrote tools to automatically find and fix Y2K problems in Cobol and PL/I. MetLife approached us with 2m lines of code they'd written in MEL, a language they developed in the late 50's or early 60's. MEL was a language that helped inspire Cobol, and its procedural code would look reasonably familiar to any modern Cobol programmer.

We had a strong developer take a crack at writing a translator to rip through MEL programs and correct identified dates. He actually got a demo going in a couple weeks, and he thought that another 3-4 weeks of work were all that would be needed to get it into shape for production. Great, we thought, and decided to take on the work.

Unfortunately, he hadn't really studied MEL's very primitive equivalent of the Cobol DATA DIVISION (where declarations go). It turned out each MEL program provided its own view of each input or output file, and it only declared those fields it was interested in. There might be 30 or 40 different takes on what an input file with variant records looked like. Talk about blind men and the elephant!

An exceptionally bright and driven guy then took over and worked out the semantics of identifying which record definitions described what file, a process made much harder by the presence of variant records in many files. He then wrote the algorighms to unify each set of alternate record definitions into a common record definition, and then mapping everything from old emulated Honeywell data types into new IBM mainframe types. It took two person years to get it all working.

Old-skool BASICs with line numbers would be my choice. When you had no space between line numbers to add new lines, you had to run a renumber utility, which caused you to lose any mental anchors you had to what was where.

As a result, you ended up squeezing in too many statements on a single line (separated by colons), or you did a goto or gosub somewhere else to do the work you couldn't cram in.

LISP

Maybe there is nothing wrong with the language but it is just beyond me.

CSS

For basic styling its OK, and selectors are pretty cool, but there's something a little bit sadistic about the box model, floats and clearing.

Hacking the language to make it do fundamental things, such as move one box below another, is all in a days work.

Here we are living in the future and just getting basic design elements to work, like rounded corners or drop shadows, is an exercise in futility.

The concept of 'reusability' pretty much ends with Ctrl-C Ctrl-V. Even a seasoned CSS writer will rarely touch someone else's stylesheet - meaning that basic layouts are routinely rewritten again and again all around the world.

Of course it shouldn't take all the flack - any hope it had of offering something truly useful to the world was cruelly dashed upon the rocks by the de facto 'platform' for the language - Internet Explorer.

I think MaxScript, the scripting language which comes with 3d studio MAX, I never could see any logic to its syntax

I despise proprietry languages like C# and AppleScript whose only reason for existing is to tie developers to a commercial platform or product. This isn't exactly a technical problem, but it is a social one when these languages are then taught in schools. I have a friend who only has Linux installed and he's being taught C# in 1st-Year CompSci. Yes there's Mono, but naturally it's always playing catch-up on features and stability.

Its VB6 NOOOOOOOOOOOOOOOOOO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! You end up like Winston Smith in the ending of 1984....

Nobody said AS400????

I had that at university, and it was definitely the worst...

TCL. It only compiles code right before it executes, so it's possible that if your code never went down branch A while testing, and one day, in the field it goes down branch A, it could have a SYNTAX ERROR!

Regular expressions

It's a write only language, and it's hard to verify if it works correctly for the right inputs.

For me it'd have to be FileMaker.

The ScriptMaker

This screenshot shows the until recently named "ScriptMaker", which had many improvements in FileMaker 9 such as Ctrl+C Ctrl+V shortcuts for copying and pasting, and a non-modal dialog so you could edit more than one script at once.

http://images.macnn.com/macnn/reviews/filemaker/9proadvanced-ice_feature1_main.png

You edit individual Scripts using this dialog box. script "steps" (shown on the left) are added into the list on the left hand side (by double clicking), and are moved up and down (using the little blob to the left of "Set Web Viewer"). Only one line can be moved at once, and commenting for the purposes of temporarily disabling script steps is only available in the Advanced version of FileMaker Pro.

Constructing a Script effectively ruins your wrists, as you're swapping between keyboard and mouse thousands of times an hour typing stuff into the the little config boxes and re-arranging your lines of code.

A script is technically a procedure, and can be passed ONE parameter. Yup, just one. If you want more than one, you have to effectively combine your parameters using some delimiter, pass it to the script, then split the parameters out. Before scripts could have parameters at all (before FM7 IIRC), it was normal to use globals to pass data around.

This guy wrapped most of his hate into a hoax FileMaker 11 sneak preview.

The worse language I've ever seen come from the tool praat, which is a good audio analysis tool. It does a pretty good job until you use the script language. sigh bad memories.

Tiny praat script tutorial for beginners

Nobody mentioned Vimscript yet?

My Vim journey was like Coraline's journey into the other side of the door. It was so cool at first and my fingers were happy but then I didn't want to replace my eyes with VIMScript.

APF. You are eprobably lucky enough never to have heard of this nightmare. It was an expensive add on to IBMs mainframe hierachical database/transaction monitor IMS system. Where to start.

There was no support for arrays. If you had an array of ten items well you coded ITEM1, ITEM2 etc. and wrote ten lines of code to process each item.

Your code was stored in the database and interprated at run time. Do to the internal stucture of the thing your code was broken up and stored in several records. It was absurdly easy to overwrite someone elses code.

Some of you code was associated with the transaction (IMS speak for a service) but some of you code was assoicated with the database record -- if you got it wrong bits of your program ran every time someone accessed a record.

No debugger, the "compiler" only did basic syntax checking most errors appared at run time, with one of it four error messsages.

One of these error messages was 'INVALID DATA TYPE' -- thats all, no variable name, no line number, no clue.

Just plain horrible.

Webspeed and SpeedScript.. Just terrible, no explanation :)

"Visual C++".... So much legacy code interweaved.... everywhere.

Made me love Obj-C.

PowerDynamo

It was a product from Sybase that stored the webapp code right in the database along with your data. There was no variable scope, and the strlen() function was essentially a random number generator.

MUMPS

I worked in it for a couple years, but have done a complete brain dump since then. All I can really remember was no documentation (at my location) and cryptic commands.

It was horrible. Horrible! HORRIBLE!!!

The .bat files scripting language on DOS/Windows. God only knows how un-powerful is this one, specially if you compare it to the Unix shell languages (that aren't so powerful either, but way better nonetheless).

Just try to concatenate two strings or make a for loop. Nah.

ABAP

It's used to program applications for SAP. And it's bad.

I also forgot to mention prova and yes, it is a mixed language. It is a prolog implementation built on top of java which means that it is damn slow. They sell it by its ability to call java functions, the sad part is that you lose backtracking when you do it. So, all in all, you lose the strengths of both languages. I still don't understand why the authors didn't choose just an implementation of prolog inside java, so you can call prolog code from java instead of build your own interpreter.

Visual Basic. I simply fail to understand its cryptic syntax, since it doesn't follow any programming convention. As a guy used to the syntax of C/C++ I may be partial though. But that doesn't undermine the fact that VB is THE worst language I've worked with.

A half-baked object orientated extension to C. In embedded systems there is still a lot of C only projects. So every now and then somebody thinks his object orientated solution is all that is required to whip this project into shape ... leaving a massive maintenance mess somewhere down the line.

Usually the person starts out with modest and noble aims but it just gets away from him, every time. He hands over to a different programmer that thinks this great. OOP in C, how neat and then butchers the already tragic code he does not understands. Soon it is beyond any repair. The worst one I have seen no driver could compile without including all the headers of the objects that is going to use it as well as the header files for that component user up to the highest level.

Any programming language will become a monster if it is not used as intended.

Without a doubt, it was SmallTalk. But only on a technicality: the actual language was fine, but the IDE we used for it for class was VisualWorks, which is singly the worst IDE for anything I have ever experienced. Here's a few examples of the horrors:

-You can't save the image (which is your whole project wrapped into a single file) unless every bit of code is completely syntactically and semantically correct -It crashes often, and the UI is horribly designed. Buttons would be drawn off the window and such. -One time VisualWorks froze on me after I had done about 2-3 hours of fresh work, unfortunately without saving. Luckily (I thought), the save button still worked. So, with a sigh of relief, I saved my project. But, because of VisualWorks method of saving your project as an image, when I reopened my file, it saved my project in the frozen state. I ended up having to go back to an earlier version of my code and losing a couple hours of work.

And the single worst symptom of horrible IDE design: -There is only a single step of undo. And NOT ONLY THAT. Hear this. If you delete a line of code, move the cursor somewhere else, and then hit "undo," it will paste the line of code where the cursor presently is, not where the line originally was. WTF is that?? I think freakin' LOTUS 1-2-3 had better undo capabilities than that!

P.S. I know I'm not talking about the language, but since this represented my experience working with the language, I felt I could still reasonably give my answer in this thread. :)

JCL - Job Control Language for IBM Mainframes... not quite a programming language, more a batch file thing.

This was based on the punch card which would normally be placed at the start of jobs, i.e. Same syntax, different medium. The 71 column limit and fact that the cards cost money meant verbosity was a sin best left to COBOL source. This attitude carried over to JCL, the non paper counterpart.

I just about figured out how to change the job queue and parameters in the lead card during my time working with it. Wikipedia provides the following fine example:

//IS198CPY JOB (IS198T30500),'COPY JOB',CLASS=L,MSGCLASS=X
//COPY01   EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD DSN=OLDFILE,DISP=SHR
//SYSUT2   DD DSN=NEWFILE,
//            DISP=(NEW,CATLG,DELETE),
//            SPACE=(CYL,(40,5),RLSE),
//            DCB=(LRECL=115,BLKSIZE=1150)
//SYSIN    DD DUMMY

Precisely.

Honourable mention must go to Cincom Mantis, an "application generator" (read: text-based form designer) "powered" by a COBOL-like 4GL. Mantis is the language which helped me decide to go get a degree - the last of several CICS in the ass...

edit Mentions of DCL and the like elsewhere... Datatrieve I also remember. These were indeed awful, but still preferred the VMS stuff to anything mainframe.

FOCUS, touted as a '4GL' (fourth generation language). Some systems could use FOCUS like SQL, doing db queries, the results of which were wrapped in BASIC or some other procedural language, but the system I worked on at Boeing in the 80s didn't have that. Kind of like a very poor excel to run a business enterprise. That was the only programming job I hated.

In terms of languages I've come across, I'll vote for COBOL and Scheme.

COBOL was definitive proof that business majors should never write a programming language (and this is coming from a business major graduate -- CIS). You should not be able to write semi-coherent novels and have it compile into something. I know that it had its use 40 years ago, but someone ported it to COBOL.NET, for crying out loud.

Second place would be Scheme, which had exactly one variable type: the linked list. Trying to learn how to think in it is like trying to learn how to think like a polar bear if you're an American-born Martian. It's totally alien to everything else.

In terms of languages I've used professionally, VBScript hands down. It's like VB only worse. I once tried to implement the MD5 algorithm in VBScript. The first thing I had to do was implement freaking bit-shifting operations. Rather than reinventing the wheel, I went out and looked for an implementation. The one I found, I kid you not, followed the following algorithm:

1. Convert your number to hex
2. Convert your hex to a string, e.g., 0x08 -> "08"
3. Using a giant select case statement, convert each digit to a string of 1s and 0s, e.g., "8" -> "00001000"
4. Now that you have a giant string of 1s and 0s, shift them around as necessary

It was a total mess. And it was the best one I found.

(Caveat: That's the algorithm as best I remember it. It was 6 years ago. :) )

Anyone mentioned the script language used in Autohotkey ?
Worst language I ever used.

I'm surprised no one has mentioned Sybase PowerBuilder

• Confusing syntax
• Confusing object model
• Lack of native regular expression support
• Difficult to use IDE (esp the tool palette)

Symbian C++ Well, it is not C++. It's learning a whole new language altogether and it doesn't work that well.

The worst two languages I've worked with were APL, which is relatively well known for languages of its age, and TECO, the language in which the original Emacs was written. Both are notable for their terse, inscrutable syntax.

APL is an array processing language; it's extremely powerful, but nearly impossible to read, since every character is an operator, and many don't appear on standard keyboards.

TECO had a similar look, and for a similar reason. Most characters are operators, and this special purpose language was devoted to editing text files. It was a little better, since it used the standard character set. And it did have the ability to define functions, which was what gave life to emacs--people wrote macros, and only invoked those after a while. But figuring out what a program did or writing a new one was quite a challenge.

OPS5. Even thinking about it now makes me openly weep.

XSLT.

• XSLT is baffling, to begin with. The metaphor is completely different from anything else I know.
• The thing was designed by a committee so deep in angle brackets that it comes off as a bizarre frankenstein.
• The weird incantations required to specify the output format.
• The built-in, invisible rules.
• The odd bolt-on stuff, like scripts.
• The dependency on XPath.
• The tools support has been pretty slim, until lately. Debugging XSLT in the early days was an exercise in navigating in complete darkness. The tools change that but, still XSLT tops my list.

XSLT is weird enough that most people just ignore it. If you must use it, you need an XSLT Shaman to give you the magic incantations to make things go.

Cold Fusion

I guess it's good for designers but as a programmer I always felt like one hand was tied behind my back.

The worst language? BancStar, hands down.

3,000 predefined variables, all numbered, all global. No variable declaration, no initialization. Half of them, scattered over the range, reserved for system use, but you can use them at your peril. A hundred or so are automatically filled in as a result of various operations, and no list of which ones those are. They all fit in 38k bytes, and there is no protection whatsoever for buffer overflow. The system will cheerfully let users put 20 bytes in a ten byte field if you declared the length of an input field incorrectly. The effects are unpredictable, to say the least.

This is a language that will let you declare a calculated gosub or goto; due to its limitations, this is frequently necessary. Conditionals can be declared forward or reverse. Picture an "If" statement that terminates 20 lines before it begins.

The return stack is very shallow, (20 Gosubs or so) and since a user's press of any function key kicks off a different subroutine, you can overrun the stack easily. The designers thoughtfully included a "Clear Gosubs" command to nuke the stack completely in order to fix that problem and to make sure you would never know exactly what the program would do next.

There is much more. Tens of thousands of lines of this Lovecraftian horror.

I'm going to vote for ColdFusion. It's trying to be a cool scripting language, but being done up in html-like tags was driving me nuts - it's been a little while since I had to deal with it, but as I remember variable declarations could be a bear, and it was easy to have slightly different versions of the server on two different environments which would have code working differently on both.

If you wanted to do anything really impressive with it, it basically involved creating an object in Java and figuring out how to link it in with coldfusion's server so you could invoke it as a tag. I'm working in PHP, and even though PHP has it's problems, ColdFusion was definately worse.

Logo...that damn turtle would never go where I wanted it to.

The worst language I "worked" with, was "karol, the robot" — which was a programming language in German. And could do nothing more than move a robot on screen xD

CodeGear Delphi

Its really not the language I disliked, but the IDE: CodeGear RAD Studio for Delphi. This is easily the worst, most buggy, crash-happy IDE I've ever used. Me and the other Delphi programmers would routinely lose hours of development time everyday because the IDE would crash or freeze.

After we installed CodeRush, the application became virtually unsuable. It crashed in regular 5-15 minute intervals, even without user input. Even worse, mysterious errors were triggered by basic debugging, such as hitting a breakpoint (routinely, the debugger would hit a breakpoint and simply freeze in its tracks on a trivial line, like a variable assignment. Nothing you could do would make it proceed any further). If you left the program alone, it would sit stable for up to a half hours before throwing some kind of memory exception.

So, after we'd spent thousands of dollars on licenses CodeGear RAD Studio, no one wanted to use it. By the time I left the company, all of our Delphi projects were coded with VIM instead.

For me, the answer is Crystal Syntax, the BASIC-like language used by Crystal Reports. Trying to accomplish anything other than mere comparisons is difficult at best and impossible at worst. Granted, they do arrays fairly well:

{some_database_field} IN ["firstValue", "secondValue", "thirdValue"]

But the following doesn't work at all:

{some_database_field} NOT IN ["firstValue", "secondValue", "thirdValue"]

Even though the language does have a NOT operator.

I'm not sure if you meant to include scripting languages, but I've seen TCL (which is also annoying), but... the mIRC scripting language annoys me to no end.

Because of some oversight in the parsing, it's whitespace significant when it's not supposed to be. Conditional statements will sometimes be executed when they're supposed to be skipped because of this. Opening a block statement cannot be done on a separate line, etc.

Other than that it's just full of messy, inconsistent syntax that was probably designed that way to make very basic stuff easy, but at the same time makes anything a little more complex barely readable.

I lost most of my mIRC scripts, or I could have probably found some good examples of what a horrible mess it forces you to create :(

I4GL (Informix 4th Generation Language).

Thankfully, it's pretty much dead. The language was not hard to look at or write, but implementation flaws made it nearly useless.

First of all, it was really two languages- the interpreted (more flexible, slow) and the compiled (nearly useless, the one that actually finished running in your lifetime). Proprietary, of course.

Early versions lacked some arithmetic operators, so you had to push temporary data into the database and use SQL for math.

It was supposed to have multi-user capabilities, but since the backend (Informix Turbo, remember that?) lacked proper locking, instead of a 90 second wait on a locked row followed by a useful error return, you would get an instant return with a non-usable non-error return value. Since I4GL was useless without the backend, I consider that a flaw in the language runtime.

I once had a job hacking all the previous programmer's Unions into series of smaller selects in I4GL loops. The reason, the unions would not complete in your lifetime. Of course, the project manager had removed the index Unique constraints, since they made the inserts crash so much.

I have given the same answer elsewhere, but I think it deserves its place here:

In the late 90s I had to write several web sites in Informix Universal Server web blade (aka Illustra web blade)

For anyone who doesn't know anything about this execrable environment, it forced you to use the most bizarre language I have ever come across. As Joel Spolsky described it

When it did run, it proved to have the only programming language I've ever seen that wasn't Turing-equivalent, if you can imagine that.

More on it here http://philip.greenspun.com/wtr/illustra-tips.html

And an example of a 'simple' if condition:

cond=$(OR,$(NXST,$email),$(NXST,$name),$(NXST,$subject))

I wish I could find the full api document, as looking back now in hindsight it would be hilarious / unbelievable / tragic.

One example of it's dire nature was the fact that it had no loops. Of any kind. It was possible to hack looping functionality by creating a query and iterating through its rows, but that is so wrong it makes me feel sick.

edit: I've managed to find a complete code sample. Behold:

<HTML>
<HEAD><TITLE>WINSTART bug</TITLE></HEAD>
<BODY>
<!--- Initialization --->
<?MIVAR NAME=WINSIZE DEFAULT=4>$WINSIZE<?/MIVAR>
<?MIVAR NAME=BEGIN DEFAULT=1>$START<?/MIVAR>

<!--- Definition of Ranges ---->
<?MIVAR NAME=BEGIN>$(IF,$(<,$BEGIN,1),1,$BEGIN)<?/MIVAR>
<?MIVAR NAME=END>$(+,$BEGIN,$WINSIZE)<?/MIVAR>
<!--- Execution --->
<TABLE BORDER>
<?MISQL WINSTART=$BEGIN WINSIZE=$WINSIZE
    SQL="select tabname from systables where tabname like 'web%' 
        order by tabname;">
    <TR><TD>$1</TD></TR>
<?/MISQL>
</TABLE>
<BR>
<?MIBLOCK COND="$(>,$BEGIN,1)">
    <?MIVAR>
    <A HREF=$WEB_HOME?MIval=WINWALK&START=$(-,$BEGIN,$WINSIZE)&WINSIZE=$WINSIZE>
    Previous $WINSIZE Rows </A> $(IF,$(<,$MI_ROWCOUNT,$WINSIZE), No More Rows,  )
    <?/MIVAR>
<?/MIBLOCK>
<?MIBLOCK COND="$(AND,$(>,$END,$WINSIZE),$(>=,$MI_ROWCOUNT,$WINSIZE))">
    <?MIVAR>
    <A HREF=$WEB_HOME?MIval=WINWALK&START=$END&WINSIZE=$WINSIZE>
    Next $WINSIZE Rows  </A>
    <?/MIVAR>
<?/MIBLOCK>
</BODY>

Prettify doesn't know how to colour it, quelle surprise

In 25+ years of computer programming, by far the worst thing I've ever experienced was a derivative of MUMPS called Meditech Magic. It's much more evil than PHP could ever hope to be.

It doesn't even use '=' for assignment! 100^b assigns a value of 100 to b and is read as "100 goes to b". Basically, this language invented its own syntax from top to bottom. So no matter how many programming languages you know, Magic will be a complete mystery to you.

Here is 100 bottles of beer on the wall written in this abomination of a language:

BEERv1.1,
100^b,T("")^#,DO{b'<1 NN(b,"bottle"_IF{b=1 " ";"s "}_"of beer on the wall")^#,
                          N(b,"bottle"_IF{b=1 " ";"s "}_"of beer!")^#,
                          N("You take one down, pass it around,")^#,b-1^b,
                          N(b,"bottle"_IF{b=1 " ";"s "}_"of beer on the wall!")^#},
END;

Smalltalk.

I had to learn it at the university. Hated every aspect of the language. Maybe our professors just made a dumb choice on the language implementation, but basically it worked like this:

• There was no sourcecode you could browse. There was just a class-tree where you could create and edit the method implementations. No way to save the code other than to cut'n'paste them to a notepad. You could save sessions, but these are binary dumps.

• The entire environment has been written in Smalltalk, and boy - was it slow. You could see the entire screen repaint every time you hit a key. The editor (that you had to use due to lack of load/save sourcecode) lacked basic edit-features like insert/override mode.

• The language was pure in a way that it wasn't possible to terminate a loop early. All things that made programming easy and efficient are forbidden in the language.

• Everything was an object. Override the comparison operator of a boolean and the entire system crashed.

Oh, come on. In 3 pages, no mention of Forth? Seriously?

Sure, like APL, it is powerful and it has its place. But like APL it competes for first place in the Write-Only Language category. I still curse the physics professor who forced this on me in the late 80s because he was convinced it was going to take over the software world.

My heartfelt regrets to the 5 people in the universe who process reality in reverse polish notation. Or should I say something like "apology +"?

Well since this question refuses to die and since the OP did prod me into answering...

I humbly proffer for your consideration Authorware (AW) as the worst language it is possible to create. (n.b. I'm going off recollection here, it's been ~6 years since I used AW, which of course means there's a number of awful things I can't even remember)

the horror, the horror http://img.brothersoft.com/screenshots/softimage/a/adobe_authorware-67096-1.jpeg

Let's start with the fact that it's a Macromedia product (-10 points), a proprietary language (-50 more) primarily intended for creating e-learning software and moreover software that could be created by non-programmers and programmers alike implemented as an iconic language AND a text language (-100).

Now if that last statement didn't scare you then you haven't had to fix WYSIWYG generated code before (hello Dreamweaver and Frontpage devs!), but the salient point is that AW had a library of about 12 or so elements which could be dragged into a flow. Like "Page" elements, Animations, IFELSE, and GOTO (-100). Of course removing objects from the flow created any number of broken connections and artifacts which the IDE had variable levels of success coping with. Naturally the built in wizards (-10) were a major source of these.

Fortunately you could always step into a code view, and eventually you'd have to because with a limited set of iconic elements some things just weren't possible otherwise. The language itself was based on TUTOR (-50) - a candidate for worst language itself if only it had the ambition and scope to reach the depths AW would strive for - about which wikipedia says:

...the TUTOR language was not easy to learn. In fact, it was even suggested that several years of experience with the language would be required before programmers could build programs worth keeping.

An excellent foundation then, which was built upon in the years before the rise of the internet with exactly nothing. Absolutely no form of data structure beyond an array (-100), certainly no sugar (real men don't use switch statements?) (-10), and a large splash of syntactic vinegar ("--" was the comment indicator so no decrement operator for you!) (-10). Language reference documentation was provided in paper or zip file formats (-100), but at least you had the support of the developer run usegroup and could quickly establish the solution to your problem was to use the DLL or SWF importing features of AW to enable you to do the actual coding in a real language.

AW was driven by a flow (with necessary PAUSE commands) and therefore has all the attendant problems of a linear rather than event based system (-50), and despite the outright marketing lies of the documentation it was not object oriented (-50) either. All code reuse was achieved through GOTO. No scope, lots of globals (-50).

It's not the language's fault directly, but obviously no source control integration was possible, and certainly no TDD, documentation generation or any other add-on tool you might like.

Of course Macromedia met the challenge of the internet head on with a stubborn refusal to engage for years, eventually producing the buggy, hard to use, security nightmare which is Shockwave (-100) to essentially serialise desktop versions of the software through a required plugin (-10). AS HTML rose so did AW stagnate, still persisting with it's shockwave delivery even in the face of IEEE SCORM javascript standards.

Ultimately after years of begging and promises Macromedia announced a radical new version of AW in development to address these issues, and a few years later offshored the development and then cancelled the project. Although of course Macromedia are still selling it (EVIL BONUS -500).

If anything else needs to be said, this is the language which allows spaces in variable names (-10000).

If you ever want to experience true pain, try reading somebody else's uncommented hungarian notation in a language which isn't case sensitive and allows variable name spaces.

Total Annakata Arbitrary Score (AAS): -11300
Adjusted for personal experience: OutOfRangeException

(apologies for length, but it was cathartic)

There are just two kinds of languages: the ones everybody complains about and the ones nobody uses.

Bjarne Stroustrup

First, a few caveats: I tend to give a pass to languages that serve their intended purpose well enough, but get shoehorned by the corporate world into doing more than their designers intended. For that reason, I give a pass to VB and its VB-office variants. For quick prototyping, VB was hard to beat. It failed massively when people tried to use it for enterprise-level work. Same for Perl, which is a great scripting utility which somehow got promoted to the CGI language du jour back in the day.

But a language that fails to meet expectations, even on its own terms? For me, that's no contest: JavaScript, for three big reasons:

1. lack of decent debugging capabilities (Firebug helps, but it's not enough),
2. the way it simply halts whenever there's an error, forcing the programmer to add alert("in functionX") just to make sure you made it to functionX, and
3. its infuriatingly obscure error messages.

And if I were allowed to choose a framework, it's likewise an easy choice: JSF and IceFaces.

No-one had mentioned DCL???

Granted, I don't have that much experience with different languages, but I gotta say Python. Even though the language it self is okay, I just hate the " " != "\t" etc. indents. Even though the idea of "automatic" scope ending is fine, this just lead to too many errors / time spent pressing space 200 times to use other peoples code :(

PROGRESS 4GL (apparently now known as "OpenEdge Advanced Business Language").

PROGRESS is both a language and a database system. The whole language is designed to make it easy to write crappy green-screen data-entry screens. (So start by imagining how well this translates to Windows.) Anything fancier than that, whether pretty screens, program logic, or batch processing... not so much.

I last used version 7, back in the late '90s, so it's vaguely possible that some of this is out-of-date, but I wouldn't bet on it.

• It was originally designed for text-mode data-entry screens, so on Windows, all screen coordinates are in "character" units, which are some weird number of pixels wide and a different number of pixels high. But of course they default to a proportional font, so the number of "character units" doesn't correspond to the actual number of characters that will fit in a given space.
• No classes or objects.
• No language support for arrays or dynamic memory allocation. If you want something resembling an array, you create a temporary in-memory database table, define its schema, and then get a cursor on it. (I saw a bit of code from a later version, where they actually built and shipped a primitive object-oriented system on top of these in-memory tables. Scary.)
• ISAM database access is built in. (But not SQL. Who needs it?) If you want to increment the Counter field in the current record in the State table, you just say State.Counter = State.Counter + 1. Which isn't so bad, except...
• When you use a table directly in code, then behind the scenes, they create something resembling an invisible, magic local variable to hold the current cursor position in that table. They guess at which containing block this cursor will be scoped to. If you're not careful, your cursor will vanish when you exit a block, and reset itself later, with no warning. Or you'll start working with a table and find that you're not starting at the first record, because you're reusing the cursor from some other block (or even your own, because your scope was expanded when you didn't expect it).
• Transactions operate on these wild-guess scopes. Are we having fun yet?
• Everything can be abbreviated. For some of the offensively long keywords, this might not seem so bad at first. But if you have a variable named Index, you can refer to it as Index or as Ind or even as I. (Typos can have very interesting results.) And if you want to access a database field, not only can you abbreviate the field name, but you don't even have to qualify it with the table name; they'll guess the table too. For truly frightening results, combine this with:
• Unless otherwise specified, they assume everything is a database access. If you access a variable you haven't declared yet (or, more likely, if you mistype the variable name), there's no compiler error: instead, it goes looking for a database field with that name... or a field that abbreviates to that name.

The guessing is the worst. Between the abbreviations and the field-by-default, you could get some nasty stuff if you weren't careful. (Forgot to declare I as a local variable before using it as a loop variable? No problem, we'll just randomly pick a table, grab its current record, and completely trash an arbitrarily-chosen field whose name starts with I!)

Then add in the fact that an accidental field-by-default access could change the scope it guessed for your tables, thus breaking some completely unrelated piece of code. Fun, yes?

They also have a reporting system built into the language, but I have apparently repressed all memories of it.

When I got another job working with Netscape LiveWire (an ill-fated attempt at server-side JavaScript) and classic ASP (VBScript), I was in heaven.

The old Excel macro-language It was really frustrating to store variables in an excel sheet. VBA was also pretty bad.

For my senior design, we programmed a Canon camera to produce depth maps using CHDK. Most of the code was written in C, but you have to interface to it with this ridiculous language called uBasic. Basically, it wasn't implemented with a proper parser, and so variables can only be 1 letter, it's insanely slow, and if you make a mistake, the camera just shuts off.

Oberon.

In our first year at university, everyone had to program in Oberon. I think the idea was to make sure nobody had a head start. The language was tied to the Oberon OS/GUI which was horrible! I'm not sure if anything changed, but that was definitely my worst programming experience ever.

RPG

Not talking about Role Playing Games here, fellas. I took COBOL in college, as well as RPG IV. If there is any language that makes me want to dig my eyeball out with a fork, it's RPG. It's pretty much "column-based" code, in that you don't just write your code from left to right, you have to make sure you are in the correct columns. The reasoning behind this is that the language was originally created for punch card development.

I can't write to a file! What the heck!

Well duh, dummy, you forgot a capital F in column 68.

Objective-C.

The annotations are confusing, using brackets to call methods still does not compute in my brain, and what is worse is that all of the library functions from C are called using the standard operators in C, -> and ., and it seems like the only company that is driving this language is Apple.

I admit I have only used the language when programming for the iPhone (and looking into programming for OS X), but it feels as if C++ were merely forked, adding in annotations and forcing the implementation and the header files to be separate would make much more sense.

Any language can be the worst in a right hands. And improper teamwork makes it even worse. I mean, if it's not fun enough to shot in your own foot, you can always try shooting some coworkers feet. So far the best language I've seen to do so is C++. You can really hurt colleagues brain with it.

Not sure if its a true language, but I hate Makefiles.

Makefiles have meaningful differences between space and TAB, so even if two lines appear identical, they do not run the same.

Make also relies on a complex set of implicit rules for many languages, which are difficult to learn, but then are frequently overridden by the make file.

A Makefile system is typically spread over many, many files, across many directories. With virtually no scoping or abstraction, a change to a make file several directories away can prevent my source from building. Yet the error message is invariably a compliation error, not a meaningful error about make, or the makefiles.

Any environment I've worked in that uses makefiles successfully has a full-time Make expert. And all this to shave a few minutes off compilation??

Twice I've had to work in 'languages' where you drag-n-dropped modules onto the page and linked them together with lines to show data flow. (One claimed to be a RDBMs, and the other a general purpose data acquisition and number crunching language.)

Just thinking of it makes me what to throttle someone. Or puke. Or both.

Worse, neither exposed a text language that you could hack directly.

Worst Programming Language? - Brainfuck

I haven't worked with it myself, but I would call it the worst. It's generally used as a challenge though, not for production (more like: I'm bored this weekend, let's see if I can re-write tic tac toe in it). Check out it's Hello World program on wiki.

In the mid 90’s I worked in a small management consulting firm using a GIS product called MapInfo which had a weak scripting language called MapBasic.

I don’t remember the specifics, but basically at that time there were objects* which could only be instantiated when hard coded (as opposed to instantiating with variables). This was a total pain in that it appeared to do everything you needed done, until you actually attempted to implement. Implementation was either impossible or very kludge heavy.

I was a novice at that point and had a lot of difficulty a) predicting what could and could not be done, and b) explaining why to my non-programming manager. It was frustrating none the less.

There are a lot of languages and tools which are weak in certain areas, but after dealing with Map Basic, even Visual Basic 3.0 felt liberating!

*-I don’t remember if it was all objects or only certain ones.

• LOLCODE:

HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE

Seriously, the worst programming language ever is that of Makefiles. Totally incomprehensible, tabs have a syntactic meaning and not even a debugger to find out what's going on.

For me the worst experience which tainted my view of the language was Perl. I was asked to support a bunch of perl scripts that have been "supported" by other people who promptly left the company few months after being asked to support it. While the language may be ok, it allows the code to become unreadable and almost unsupportable very quickly (unless only 1 person ever touches them). It was a mess of regexp, pseudo objects, single letter variables and function names. It quickly led me to rewrite it all in python and scrap perl completely (it was that or me quitting). The python version was so much more usable and supportable that 10 years later it is still in use and from what I hear no one is allowed to use Perl at that company again.

FORTRAN 77

To be fair, perhaps that in 1977 it was a pretty good language, but by the time 1999 rolled around I had to maintain a FORTRAN 77 program that was originally started by my advisor when he was a grad student sometime in the 1970's, (on punch cards, orignally). The program was 'enhanced' hacked, plugged for over twenty years by people of various abilities. The oldest code was ALLCAPS, chock full of GOTO statements, global variables, and functions with more parameters than I have fingers. Originally variable names in Fortran were limited to 6 characters, but to save bytes most variables were given such descriptive names as 'A', 'B', 'AA', 'II', etc.

Granted, much of my experience was related to how the program was written, but the language didn't really encourage good programming style:

• Implicit typing depending on the first letter of the variable name (e.g. names that started with an 'I' to 'N' were integers, otherwise the default was REAL)
• Fixed statement layout (a holdover from punch cards: column 0 would indicate a comment line if it had a 'C', labels in columns 1-5, continuation character in column 6, statements in columns 7-72)
• Statement labels (numeric labels at that)
• KEYWORDS WERE ALL CAPS

Thankfully it's been 10 years since I've looked at FORTRAN and I've forgotten more of the annoyances that I remember.

Dataflex 2.3 and VDF4.

VDF 4 is what drove me away from Dataflex.

One of the most stupid things they did was use the Windows message for the third mouse button to communicate between the IDE and the complier. It worked fine unless you had a 3 button mouse.

LabVIEW (is that even considered a language?)

It was horrible. If you want to broaden the term, HTML sucks too, as does XML.

Here is the contribution to my own question:

Origin LabTalk

My all-time favourite in this regard is Origin LabTalk. In LabTalk the maximum length of a string variable identifier is one character. That is, there are only 26 string variables at all. Even worse, some of them are used by Origin itself, and it is not clear which ones.

From the manual:

LabTalk uses the % notation to define a string variable. A legal string variable name must be a % character followed by a single alphabetic character (a letter from A to Z). String variable names are caseinsensitive. Of all the 26 string variables that exist, Origin itself uses 14.

Doors DXL

For me the second worst in my opinion is Doors DXL. Programming languages can be divided into two groups: Those with manual memory management (e.g. delete, free) and those with a garbage collector. Some languages offer both, but DXL is probably the only language in the world that supports neither. OK, to be honest this is only true for strings, but hey, strings aren't exactly the most rarely used data type in requirements engineering software.

The consequence is that memory used by a string can never be reclaimed and DOORS DXL leaks like sieve.

There are countless other quirks in DXL, just to name a few:

• DXL function syntax
• DXL arrays

troff

Tells you how old I am. You could do pretty sweet things in it, but it was rough. You guys that think Perl is unreadable should check it out.

I mean:

.nr *pop-count 0
.while !'\\n(.z'' \{\
.   \"@warning automatically terminating diversion \\n(.z
.   ie d @div-end!\\n(.z .@div-end!\\n(.z
.   el .*div-end-default
.   nr *pop-count +1
.   \" ensure that we don't loop forever
.   if \\n[*pop-count]>20 .@fatal recovery failed
.\}
.while !'\\n[.ev]'0' .ev
.par@reset-env
.par@reset

And believe it or not, after having to do this for years, I stayed with programming.

Good God, you mean no one has used PL/SQL? The spawn from the hell that is Oracle is interpreted, and lives in the context of the Oracle Server. All output is spooled, until the program is done. There is an absolute limit on the amount of output that it can display. It is nearly impossible to debug. Ga... I feel I'll just thinking about it.

My answer is fairly borderline but I think it's worth putting on the record:

HTML

Not a particularly powerful language by any means but given the number of people who have more than a passing familiarity with it and would classify themselves as programmers I think it should qualify.

A lot of the angst (in this thread even) directed at languages such as PHP has its roots in the limitations of HTML. Consider a few of its low-points: it encourages the mixing of content and presentation, it is verbose and repetative, the spec still has areas of ambiguity, and, tellingly, implementations have traditionally suffered from a lack of conformance to the spec. The grand ecosystem of client and server side languages owe a lot to the fact that straight HTML is a pain.

Yes, there are bad quirky languages, but pushing a common language beyond its limits is a greater evil in my book.

System RPL, used by HP 48, 49 and 50 graphing scientific calculators. There were times it seemed to me that the compiler actually had produce a higher-level language for the processor to execute.

JCL (Job Control Language) has to be the worst thing I have ever touched

My vote is DB/C DX which is based on the DATABUS. I am sure most of you guys have never heard of it, and those that have.... I am sorry.....

maybe FORTRAN.... I'm still havinh incubius of it.

SNOBOL had some neat features, and string processing abilities more extensive than Perl's. It also had one type of statement: <base string> <match string> = <replacement string> :S(<label>) :F(<label>) where most of the components could be omitted. Control structures were done by jumping to one label or another (if present) depending on whether the match string could be found in the base string. The strings could include assorted functions and substrings, so a reasonable SNOBOL string could include all the syntax trees mentioned in the back of your favorite programming language standard.

It was trivial to write a parser in it (although it wouldn't necessarily be at all efficient), but anything like arithmetic or loops were pains.

I find myself avoid having to use VBScript/Visual Basic 6 the most.

I use primarily C++, javascript, Java for most tasks and dabble in ruby, scala, erlang, python, assembler, perl when the need arises.

I, like most other reasonably minded polyglots/programmers, strongly feel that you have to use the right tool for the job - this requires you to understand your domain and to understand your tools.

My issue with VBscript and VB6 is when I use them to script windows or office applications (the right domain for them) - i find myself struggling with the language (they fall short of being the right tool).

VBScript's lack of easy to use native data structures (such as associative containers/maps) and other quirks (such as set for assignment to objects) is a needless and frustrating annoyance, especially for a scripting language. Contrast it with Javascript (which i now use to program wscript/cscript windows and do activex automation scripts) which is far more expressive. While there are certain things that work better with vbscript (such as passing arrays back and forth from COM objects is slightly easier, although it is easier to pass event handlers into COM components with jscript), I am still surprised by the amount of coders that still use vbscript to script windows - I bet if they wrote the same program in both languages they would find that jscript works with you much more than vbscript, because of jscript's native hash data types and closures.

Vb6/VBA, though a little better than vbscript in general, still has many similar issues where (for their domain) they require much more boiler plate to do simple tasks than what I would like and have seen in other scripting languages.

CRM114. A language specifically designed for interfacing with a very powerful Bayesian filter, useful for spam-filtering and similar tasks.

I was asked to use it by a client last year and after looking into it, used some simple Bayesian code off of Codeproject.com instead. Later, I found a message posted on a forum somewhere from the original author of CRM114, apologizing for it.

The main problem was Latin-derived grammar. The author admitted that he'd been learning Latin at the time, and so integrated it into his project. Thus, it gets strange operator-order and argument conventions. This also led to using the word 'alius' (Latin for 'otherwise' or 'else) where you'd use 'else' in any other language.

Very difficult to make it do anything at all.

Lingo, for Shockwave Flash (or whatever it was). Quite horrible, basic-ish thing with a bit too dynamic type system. The editor sucked, the debugger sucked. Arghh!

It probably didn't help that the app I had to take upon my shoulders was written by scriptkiddies, which used the type of a variable to steer control flow. (If it's a string, we're in mode A, so it means X, if it's an int, we're in mode B, so it means Y). $£€£@£$#"¤#" !!

I like Python, and I suppose something equally horrible could've been made there, but the community and tools are much nicer and rigorous.

dBase II (that's 2, not 3): Fortunately I didn't use it a lot, and it's been over twenty years, so I don't remember much except the pain! IIRC, its liberal use of special characters in variable names (and other places?) made it almost impossible to read, and it was lacking in flow control. It seemed that 3 got a lot more use (and already did when I was using 2, but my employer was too cheap to upgrade), but I don't know if it was any nicer.

Seriously: Perl. It's just a pain in the ass to code with for beginners and even for semi-professionals which work with perl on a daily basis. I can constantly see my colleagues struggle with the language, building the worst scripts, like 2000 lines with no regard of any well accepted coding standard. It's the worst mess i've ever seen in programming. Now, you can always say, that those people are bad in coding (despite the fact that some of them have used perl for a lot of years, now), but the language just encourages all that freaking shit that makes me scream when i have to read a script by some other guy.

In Unix, m4 scripts and sendmail.conf.

RPG II?? anyone?

It was among the worst checkthis Wiki description for a brief intro to a language that lived long past its expire by date.

On the bright side you could write programs drunk or sober and it didn't make much difference

I can't belive nobody has said this one:

LotusScript

I thinks is far worst than php at least.

Is not about the language itself which follows a syntax similar to Visual Basic, is the fact that it seem to have a lot of functions for extremely unuseful things that you will never (or one in a million times) use, but lack support for things you will use everyday.

I don't remember any concrete example but they were like:

"Ok, I have an event to check whether the mouse pointer is in the upper corner of the form and I don't have an double click event for the Form!!?? WTF??"

MS Access Visual Basic for Applications (VBA) was also pretty bad. Access was bad altogether in that it forced you down a weak paradigm and was deceptively simple to get started, but a nightmare to finish.

Definitely the worst language I've ever used was Oz. It is a failed attempt to create a multiparadigm programming language. As you can imagine it ends up being really obscure and with an extremely complicated syntax. You have different delimiters to mark that you are in working in a functional way or in a imperative way. I always find a little strange defining classes with functional non side effect method parts.

PC-FOCUS

I worked on a warehouse inventory + management system where the back office subsystem was implemented in PC-FOCUS.

All that needs to be said about this language is that there was a 100+ page chapter in the programming manual titled "Workarounds".