什么是你曾经使用过的最糟糕的编程语言？
如果你有一个有趣的故事要分享， 请发表一个答案 ，但不要滥用这个问题来抨击一种语言。
我们是程序员，我们的主要工具是我们使用的编程语言。
虽然有很多关于最好的讨论， 我想听听你曾经使用的最糟糕的编程语言的故事 ，我想知道你究竟是什么恼火。
我想收集这个故事的一部分，以避免在devise一种语言（特别是DSL）时常见的陷阱，部分是为了避免将来的古怪语言。
这个问题不是主观的 。 如果一种语言只支持单个字符标识符（请参阅我自己的答案 ），这是一个不可争议的方式 。
编辑
有人提出这个问题吸引巨魔的担忧。 通过所有的答案涉水清楚一件事。 大部分的答案是适当的，有用的，写得很好。
更新2009-07-01 19:15 GMT
语言概述现已完成，涵盖了来自102个答案的103种不同的语言 。 我决定对于什么是一种编程语言并且包括任何合理的东西而放松。 感谢大卫对此的评论。
这里是迄今为止涵盖的所有编程语言（按字母顺序排列，与答案链接，新条目以粗体显示）：
ABAP ， 所有20世纪的语言 ， 所有拖放语言 ， 所有专有语言 ， APF ， APL （1） ， AS400 ， Authorware ， Autohotkey ， BancaStar ， BASIC ， Bourne Shell ， Brainfuck ， C ++ ， Centura Team Developer ， Cobol （1） Cold Fusion ， ColdFusion ， CRM114 ， Crystal语法 ， CSS ， Dataflex 2.3 ， DB / c DX ， dbase II ， DCL ， Delphi IDE ， 门DXL ， DOS批处理 （1） ， Excelmacros语言 ， FileMaker ， FOCUS ， Forth ， FORTRAN ， FORTRAN 77 ， HTML ， Illustra Web刀片 ， Informix第四代语言 ， Informix Universal Server Web刀片 ， INTERCAL ， Java ， JavaScript （1） ， JCL （1） ， karol ， LabTalk ， Labview ， Lingo ， LISP ， 徽标 ， LOLCODE ， LotusScript ， m4 ， Magic II ， Makefiles ， MapBasic ， MaxScript ， Meditech Magic ， MEL ， mIRC脚本 ， MS Access ， MUMPS ， Oberon ， C对象扩展 ， Objective-C ， OPS5 ， Oz ， Perl （1） ， PHP ， PL / SQL ， PowerDynamo ， PROGRESS 4GL ， prova ， PS-FOCUS ， Python ， 正则expression式 ， RPG ， RPG II ， Scheme ， ScriptMaker ， sendmail.conf ， Sma 本文档中的所有信息均经过我公司 授权 ， 未经书面 许可 ， 任何人不得以任何forms 复制 ， 转载 ， 摘编或在非商业性的目的使用本网站信息 。 基本 （1） ， Visual C ++ ， Visual Foxpro ， VSE ， Webspeed ， XSLT
涵盖80386汇编器，VB6和VBScript的答案已被删除。
PHP（没有特定的顺序）
- 函数名称和参数顺序不一致
- 因为有一个zillion函数，每个函数似乎都使用不同的命名约定和参数顺序。 “让我们看看…是foo_bar还是foobar或者fooBar …而且是针，草垛还是干草堆针 ？” PHPstring函数就是一个很好的例子。 其中一半使用str_foo ，另一半使用strfoo 。
- 非标准的date格式字符
- 以
j为例- 在UNIX中 （顺便说一句，其他人都用它作为datestring格式的指南），
%j以前导零返回一年中的第一天。 - 在PHP的date函数
j返回一个没有前导零的月份的date 。
- 在UNIX中 （顺便说一句，其他人都用它作为datestring格式的指南），
- 以
- 仍然不支持Apache 2.0 MPM
- 这不是build议。
- 为什么不支持？ “当你通过没有完全独立的执行线程，完全独立的内存段和强大的沙盒来让底层框架更复杂时，粘土的脚被引入到PHP系统中。 链接所以…它不被支持，因为它使事情更难？ 因为只有那些容易做的事才值得做对吗？ （公平地说，正如Emil H指出的那样，这通常是由于不好的第三方库不是线程安全的，而PHP的核心是。
- 没有本地的Unicode支持
- 本地Unicode支持将被定为PHP6
- 我很高兴我们还没有生活在一个全球化的环境中，我们可能需要用过去18年的时间与其他语言的人交谈。 等一下。 （公平的说，这个时代所有不使用Unicode的事实的确让我很烦恼，我的意思是我不应该做任何额外的工作来使Unicode发生，这不仅仅是 PHP的问题。 ）
我有其他的牛肉与语言。 这些只是一些。 杰夫·阿特伍德有一个关于为什么PHP糟透了的旧post 。 他也说没关系。 我不同意，但我们是。
XSLT。
- XSLT是莫名其妙的，首先。 这个比喻与我所知道的其他东西完全不同。
- 这个东西是由一个如此尖锐的尖锐括号的委员会devise的，它是一个离奇的弗兰肯斯坦（frankenstein）。
- 指定输出格式需要奇怪的咒语。
- 内置的，不可见的规则。
- 奇怪的东西，就像脚本一样。
- 依赖于XPath。
- 直到最近，工具支持都相当渺茫。 在早期debuggingXSLT是在完全黑暗中进行导航的练习。 这些工具改变了，但仍然XSLT顶部我的列表。
XSLT很奇怪，大多数人都忽略它。 如果你必须使用它，你需要一个XSLT萨满来给你魔法咒语。
DOSbatch file。 不知道这是否符合编程语言。 这并不是说你不能解决你的问题，但是如果你习惯于bash …
只是我的两分钱。
不知道它是否是一种真正的语言，但我讨厌Makefiles。
Makefile在空间和TAB之间有着明显的区别，所以即使两行显示完全相同，它们也不会相同。
Make也依赖于许多语言的复杂隐式规则集，这些语言很难学，但是经常被make文件覆盖。
Makefile系统通常分布在许多目录中的许多文件中。 几乎没有范围或抽象，更改一个make文件几个目录可以防止我的来源build设。 然而，错误消息总是一个compliation错误，而不是关于make或makefile的一个有意义的错误。
我所在的任何使用makefile的环境都有一个全职Make专家。 而所有这一切刮了几分钟编译??
我所见过的糟糕的语言来自工具praat，这是一个很好的audio分析工具。 在使用脚本语言之前，它做得相当不错。 感叹糟糕的回忆。
微小的praat脚本教程初学者
函数调用
我们列出了至less3种不同的函数调用语法：
-
经常的
string = selected("Strings")这里没什么特别的，你可以给variablesstring赋值所选函数的结果。 不是很可怕…
-
“我正在调用一些带有参数的GUI命令”
Create Strings as file list... liste 'path$'/'type$'正如你所看到的，函数名称从“创build”开始并以“…”结束。 命令“创buildstring作为文件列表”显示在button或菜单上的文本（我怕吓倒检查）praat。 这个命令需要2个参数liste和一个expression式。 我将深入探讨expression式
'path$'/'type$'嗯。 是的。 没有空间。 如果引入空格，则会是单独的参数。 你可以想象，括号不起作用。 在这一点上，我想指出variables名称的后缀。 我不会在这一段中开发它，我只是在逗弄。
-
“哦，但我想在我的variables中获得GUI命令的结果”
noliftt = Get number of strings
是的，我们可以在这里看到一个模式，很长很奇怪的函数名称，它必须是一个GUI调用。 但是没有“…”，所以没有参数。 我不想看看parsing器是什么样的。
令人难以置信的types系统
（也就是Haskell和OCaml，praat正在给你）
-
简单的本地人types
windowname$ = left$(line$,length(line$)-4)那么，那里发生了什么？ 现在是时候看看expression的惯例和types，所以在这里我们得到了：
- 剩下$ ::（String，Int） – > String
- lenght ::（String） – > Int
- windowname $ :: String
- 行$ ::string
正如你所看到的，variables名称和函数名称的后缀是它们的types或返回types。 如果它们的后缀是'$'，那么它返回一个string或者是一个string。 如果没有什么是一个数字。 我可以看到types前缀到一个variables，以缓解实施的重点，但后缀，没有抱歉，我不能
-
数组types
为了显示数组types，让我介绍一个“微小的”循环：
for i from 1 to 4 Select... time time bandwidth'i'$ = Get bandwidth... i forhertz'i'$ = Get formant... i endfor我们得到了我是一个数字和…（不，这不是一个函数）
bandwidth'i'$
它所做的是创buildstringvariables：bandwidth1$，bandwidth2$，bandwidth3$，bandwidth4$并给它们赋值。 正如你所期望的，你不能以这种方式创build二维数组，你必须这样做：band2D__'i'__'j'$http://img214.imageshack.us/img214/3008/scaredkittylolqa2.jpg
-
特殊的string调用
outline$ = "'time'@F'i':'forhertznum'Hz,'bandnum'Hz, 'spec''newline$'" outline$ >> 'outfile$'string很奇怪（至less）是用语言来处理的。 “”用于调用全局“”string中的variables的值。 这很奇怪 它违背了从bash到PHP通过powershell的许多语言构build的所有约定。 而且看，它甚至有redirect。 不要被愚弄，它不像你心爱的shell那样工作。 不，你必须得到variables值与''
-
Da Wonderderfulfulful执行模型
我将通过与您讨论执行模式来最后一次介绍这个奇迹般的介绍。 因此，在每一种程序语言中，你都得到了从上到下的指令执行，variables和graphics用户界面。 那就是你编写了一些关于guat的代码，你可以调用菜单/button上的命令。
praat的主窗口包含一个项目列表，可以是：
- 档
- 文件列表（由一个长奇妙的长名字的函数创build）
- Spectrogramm
- string（不要问）
所以如果你想对给定的文件进行操作，你必须以编程的方式select列表中的文件，然后按下不同的button来采取一些行动。 如果要将parameter passing给GUI操作，则必须遵循表单的GUI布局，例如“
To Spectrogram... 0.005 5000 0.002 20 Gaussian”就是这样，因为它遵循以下布局：
毋庸置疑，我的噩梦充斥着围绕着我跳舞的歌剧，高喊着“DEBUG MEEEE !!”。
在praat网站上的更多信息，在“易于编程的脚本语言”
那么因为这个问题拒绝死亡，因为OP确实促使我回答…
我虚心地提供您的考虑Authorware （AW）作为可能创造的最坏的语言。 （我在这里回忆起，这是我用了AW的6年，这当然意味着有一些我甚至不记得的可怕的事情）
恐怖，恐怖http://img.brothersoft.com/screenshots/softimage/a/adobe_authorware-67096-1.jpeg
让我们从一个事实开始，它是一个Macromedia产品 （-10分），一个专有语言 （50多个），主要用于创build电子学习软件，此外，可以由非程序员和程序员创build的软件作为一个标志性语言和文本语言（-100）。
现在，如果最后一条语句没有吓倒你，那么你就不必修正所见即所得的代码（你好Dreamweaver和Frontpage的开发者！），但是最重要的是AW有一个大约12个元素的库，可能是拖入stream。 像“页面”元素，animation，IFELSE和GOTO （-100）。 当然，从stream中移除对象会产生任何数量的断开的连接和工件，而IDE有不同程度的成功应对。 自然，内置的巫师 （-10）是这些的主要来源。
幸运的是，你总是可以进入一个代码视图，最终你将不得不这样做，因为有了一些有限的标志性元素，有些事情是不可能的。 这个语言本身是基于TUTOR （-50） – 最差的语言本身的候选人，如果只有它的野心和范围达到AW的深度会努力 – 关于哪个维基百科说：
… TUTOR语言不容易学习。 事实上，甚至有人提出，在程序员build立值得保留的程序之前，需要多年的语言经验。
那么在互联网崛起之前几年就build立起来的一个很好的基础，什么都没有。 绝对没有一个数组结构超出数组结构 （-100），当然没有糖 （真正的男人不使用开关语句？）（-10），和大量的语法醋飞溅（“ – ”是评论指标没有减你的操作符！）（-10）。 语言参考文档是以文件或压缩文件格式（-100）提供的，但至less您得到了开发人员运行usegroup的支持，并且可以快速build立解决scheme，您的问题是使用AW的DLL或SWF导入function来启用你用真正的语言来做实际的编码。
AW是由一个stream（带有必要的PAUSE命令）驱动的，因此具有线性而不是基于事件的系统（-50）的所有伴随问题，并且尽pipe文档的直接营销谎言不是面向对象的 （-50）无论是。 所有的代码重用都是通过GOTO实现的。 没有范围，很多全局 （-50）。
这不是直接的语言错误，但显然没有源代码控制集成是可能的 ，当然也没有TDD，文档生成或任何其他你可能喜欢的附加工具。
当然，Macromedia面对互联网头的挑战，顽固拒绝多年，最终产生了Shockwave （-100）的安全梦魇，通过所需的插件实现了软件的桌面版本（-10）。 AS HTML上涨了，所以AW停滞不前，即使面对IEEE SCORM javascript标准，仍然坚持着冲击波交付。
最终，经过多年的乞讨和承诺，Macromedia宣布了一个激进的新版本的AW开发来解决这些问题，几年后离岸开发，然后取消了项目。 虽然当然Macromedia仍然在销售它 （EVIL BONUS -500）。
如果还有什么需要说的话， 这是允许variables名称 （-10000）的空格的语言 。
如果您想体验真正的痛苦，可以尝试阅读别人的非注释匈牙利语符号，并使用不区分大小写的语言，并允许使用可变名称空间。
安纳卡塔总数任意分数（AAS）：-11300
调整个人经验：OutOfRangeException
（道歉的长度，但它是泻药）
严重：Perl。 对于初学者，甚至对于每天使用perl的半专业人员来说，这只是一个痛苦的代码。 我可以不断地看到我的同事们正在用语言进行斗争，编写最糟糕的脚本，比如2000行，而不考虑任何公认的编码标准。 这是我在编程中看到的最糟糕的一幕。 现在，你可以总是说，那些编码不好的人（尽pipe现在有些人已经使用perl了很多年了），但是语言只是鼓励所有那些让我尖叫的东西由其他人阅读一个脚本。
MS Access Visual Basic for Applications（VBA）也很糟糕。 访问是完全不好的，因为它迫使你陷入一个薄弱的范例，看起来简单易行，但却是一个噩梦。
没有答案关于Cobol呢？ ：o
具有行号的旧skool BASIC将是我的select。 如果在行号之间没有空格来添加新行，则必须运行重新编号实用程序，这会导致您失去所需的任何精神位置。
结果，你最终挤压了太多的陈述（用冒号隔开），或者你在别的地方做了一个goto或gosub来做你无法填补的工作。
stream行性腮腺炎
我在这里工作了几年，但是从那以后，我完成了一个彻底的转变。 我真正记得的是没有文件（在我的位置）和神秘的命令。
那太差了。 可怕！ 可怕！！！
只有两种语言：每个人都抱怨和没有人使用的语言。
Bjarne Stroustrup
我还没有使用过许多语言，主要处理脚本语言。 这些VBScript是我最不喜欢的一个。 虽然它有一些方便的function，有些事情真的让我感到厌烦：
-
对象分配使用
Set关键字进行：Set foo = Nothing省略
Set是运行时错误最常见的原因之一。 -
没有这样的事情结构化exception处理。 错误检查是这样的：
On Error Resume Next ' Do something If Err.Number <> 0 ' Handle error Err.Clear End If ' And so on -
将过程调用参数括在括号内需要使用
Call关键字：Call Foo (a, b) -
它的英语语法太冗长了。 （我是花括号的粉丝。）
-
逻辑运算符是长时间的。 如果您需要testing复合条件，而后续条件依赖于前一条件的成功，则需要将条件放入单独的
If语句中。 -
缺less参数化的类构造函数。
-
要将语句包装成多行，您必须使用下划线：
str = "Hello, " & _ "world!" -
缺less多行评论。
编辑：find这篇文章： 讨厌VBScript的Flangy指南 。 作者总结他的投诉是“VBS不是Python”:)
Objective-C的。
注释是混乱的，使用括号来调用方法仍然不能在我的大脑中计算，更糟糕的是，C中的所有库函数都是使用C， – 和。中的标准运算符调用的，只有推动这种语言的公司是苹果。
我承认我在编写iPhone时只使用了这个语言（并且正在研究OS X的编程），但是感觉好像C ++只是分叉的，添加了注释，并且强制实现和头文件分离会使得很多更有意义。
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
Counterfield in the current record in theStatetable, you just sayState.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 asIndexor asIndor even asI. (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 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.
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. 罗。
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 CALLSAlthough not earthshaking, the style of arithmetic reflects ordinary usage, ie, 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. 例子：
- … 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. 或类似的东西。 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.
真棒！ 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). 为什么？ 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? 简单：
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
啊。
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.
从手册：
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 (eg 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
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 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.
- 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.
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 🙁
Visual Foxpro
Regular expressions
It's a write only language, and it's hard to verify if it works correctly for the right inputs.
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??"
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. 或两者。
Worse, neither exposed a text language that you could hack directly.
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.
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;
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!
;){kind=link}
;){kind=link}
;){kind=link}