Why <X> is not the ultimate programming language (or: Why I hate <X>)

• <X> forces me to duplicate code and effort
• <X> doesn't run my program or my libraries
• <X> ignores my efforts to communicate
  
• <X> is slow and has no way to speed it up
• <X> doesn't have an expressive enough type system
• <X> refuses to accept that it is wrong
• <X> cannot be changed
• <X> prevents itself from being understood
• <X> can't understand what I am doing
• <X> will not tell me what it did or what it is doing

In case you haven't realized, this is a template; substitute a programming language for <X>. (e.g., C++, Haskell, Ruby, ...)
I hope the opposites of these are not mutually exclusive...
I suppose this can be generalized beyond programming languages to software in general.

Pure=Vegan

And Haskell counts as vegetarian because it keeps side effects in monads.

Slashdotted! (Or: a list)

Not really. But at least they discuss the ultimate RISC. Anyway, I've been making a list of the ultimate programming paradigms. Everything is a(n): (carefully sorted alphabetically so you don't feel they are prioritized)

• actor (Erlang)
• algorithm (Python)
• application (iPhone)
• argument (like for a method)
• array (Lisp)
• aspect (AspectJ)
• associative array (JavaScript)
• capability (E)
• code (Lisp)
• component (XPCOM)
• concept (CoP)
• constraint (Prolog)
• coroutine
• data (Lisp)
• delegate (C#)
• documentation (Perl)
• DSL
• enumeration
• environment (bash)
• event (Reactive programming)
• file (GNU/Linux)
• filter
• function (lambda calculus)
• generator
• graph
• Lisp (Lisp)
• list (Lisp)
• macro (Lisp)
• map
• message (Smalltalk)
• module (Ada)
• monad (Haskell)
• object (Smalltalk)
• operator (C++)
• package (Java)
• paradigm
• pattern
• picture
• platform (Java/Mono/CLR/LLVM/Parrot)
• procedure (BASIC)
• program
• prototype (says the entrepreneur)
• query (SQL)
• reference (C)
• rule (Prolog)
• stack
• stream (pLucid)
• string (Tcl)
• syntax sugar (Perl)
• table (SQL)
• template (C++)
• TeX (TeX)
• text (TeX)
• transaction (SQL)
• tree (Lisp)
• type
• value (first-class programming)
• variable
• white box

I also came up with a list of adjectives. Everything is:

• abstract
• Algol-like
• annotated
• cross-platform
• easy (once you know how)
• encapsulated
• explicit
• generic
• high-level
• incomplete
• large
• local
• (un?)provable
• pure
• resource-limited
• scripted

Anyway, expect a post for each one of these eventually.

Software is Change

The title says it all. If a program never changes, it might as well be hardware: set in stone (circuitry?), meant to be worked with rather than meddled with.
So the ultimate programming, since programming is all about software (programming hardware is called engineering, not programming), must support change.
Example changes: (summary of this page, with typing removed)

• Add/remove/replace something
• Name/hide/rename something
• Combine(merge/flatten/cache)/split(structurize?)/move things together/apart/elsewhere
• Convert something

These changes are possible in any language, but I want these to be operations of the language: first-class, polymorphic, statically typed, dynamically typed, runtime, object-oriented, functionally pure, distibuted, atomic, <insert latest programming idea here>.
I see that Google has (finally) found my blog. The good news, fortunately, is that it doesn't yet have all the posts. Perhaps I might get a comment sometime...

Propaganda Immunization

There seem to be a lot of posts on the Internet about programming languages, but most of them seem to assume some incorrect facts. Here are some true ones to keep in mind while reading:

1. Typing (on the keyboard) is bad. (Some people seem to think that programming is a job and performance can be measured in LOC)
2. Coding style should be a choice of the programmer, not of the language designer.
3. Premature optimization is the root of all evil, so comparing languages by performance (a squaring operation) is just plain evil.
4. Everything your program sees is a lie; it is always running in a virtual machine.
5. A picture is worth a thousand words, but can be summarized in less than 10.

Sorry for no searches today; I'm running out. (Maybe I'll post some original content!)

Copycat

Apparently, after a quick Google search or two, I am not the only one to have looked for the ultimate programming. Of course, most of these seem to be of the computer type. But there are few that aren't: (presented for comic relief)

• Tips for trombone programming (music again; I should learn some)
• Mind Control, The Ultimate Terror (clearly the Illuminati are coming for us again)
• The Ultimate TI Calculator FAQ (Did I mention TI-BASIC isn't that bad a programming language?)
• Corewar, the ultimate programming game.

So anyway, after you've read these from cover to cover, like I didn't, you should read these next few articles in the proper mindset:

• Real Ultimate Programming consists of DRY (Don't Repeat Yourself), KISS (Keep It Simple, Stupid), and YAGNI (You Ain't Gonna Need It). Apparently NAMBLA (North American Man-Boy Love Association) is supposed to be a joke.
• The ultimate programming language is Visual PyHPerlacle, an object-oriented scripting language in a client-side servlet built for your business-logic backend.
• Programming language design is hard because of the lack of real-world use cases. Really? Try looking at your favorite program - it is a use case! Google actually matched on a comment; it says "the ultimate programming language is one that gives the user as much freedom as possible." So this means that taking things away from the programmer (GOTO's, inline assembly, global variables, side effects) is bad.
• The ultimate setup for pair programming consists of two notebooks VNC'd to one large, powerful desktop station, and both connected to two large LCD monitors. This is cool, since it means dual-everything is the way to go, but first I must find a partner-in-crime who can force help me to implement stuff. Volunteers?
• The Ultimate RISC machine has only one instruction, move. Everything else can be memory-mapped to special addresses: registers, ALU inputs/outputs, and the usual idea of memory-mapped devices. Applied to programming languages, this means that assignment with side effects is the universal operation. (Programming language implementation count: 0)
• Lisp is the ultimate programming experience. No, it has too many parenthesis. (save flamewar posts until you read the rest)
• The ultimate programming language is not a language, but a platform for building things.
• User Experience makes the ultimate programming language. This tells us that: line noise (Perl, anyone?) is bad, white space and letters are good, and popular programming languages have something going for them. (Example given: Python) Note that this is the proper link to the presentation referenced in the notes.
  Anyway, there are some good ideas, but it suffers from hasty generalization, saying that "since language X (Python) lacks static typing and a useful syntax for constructors, you should use our vaporware binary/proprietary data structure which will solve everything!"
  Clearly, he hasn't heard of Lisp's S-Expressions. They're perfect for representing AST's, other than I-expressions, which suffer from a lack of usage. (but fulfill the other two requirements of "readability" and "uses only white space and alphabetic characters") Lisp is the ultimate data format. People seem to have misunderstood (like they did when Lisp was invented) that it was not intended for writing code.

Anyway, there are also some blogs with similar titles, and lots more stuff which is mildly interesting when read, but is probably not worth your time. (and the rest of the results are links to pirated copies of Windows Vista/7 Ultimate) Fortunately, this blog does not appear anywhere in either search (even with quotes), so there is no need to confront problems of self-reference. (yet)

Introduction

This is a blog intended to record thoughts about programming. Some notes:

• I like lists
• and sometimes use nested lists
• This is a search. This means Google, Wikipedia, and other repositories of information will be used.
• I want ultimate programming, not extreme/meta/functional/agile/dynamic//etc. programming
• There are several types of programming, as can be seen on Wikipedia:
• Broadcast/television programming (Don't own a TV)
• Radio programming (My favorite music is white noise)
• Programming (music) (see above)
• Psychological programming (I tried this once; couldn't get anybody to listen)
• Computer programming (none of the above problems)
• Guess which one this blog will be about! Anyway, continuing:
• The word programming ends in an ellipsis, indicating that it is part of a phrase. Let's look at Wikipedia again for some completions:
• Programming languages (obviously I need one)
• Programming productivity (but which one? -> a search!)
• Programming by demonstration/example (any that do this?)
• Programming by permutation (software prototyping language?)
• Programming domain (maybe a language prototyping langauge?)
• Programming paradigms (these tend to be useful; must be supported)
• Programming style (who cares; let the compiler sort it out)
• Programming tool (note the singular; one should suffice)
• Programming language generations (clearly 7th generation or higher)
• Programming language implementation (can't find one yet)
• Programming language reference (maybe deserves a post or two in the future)
• Programming language specification (difference between specification and reference is... (potential for comments))
• Programming language theory (must read up on this; need links)
• Programming complexity (should be a type)
• Programming game (Have I mentioned that I used to play RoboWar before I started this blog?)

Two searches should be enough for one day.

Also, I should state the intended audience of this blog. It should be read by anyone who happens to think these ideas are interesting. (So perhaps it has an audience of 1)