Want to read Slashdot from your mobile device? Point it at m.slashdot.org and keep reading!

 



Forgot your password?
typodupeerror
×
Programming IT Technology

Esoteric Programming Languages 259

led_belly writes: "I came across this interesting page from the #alt.linux IRC chat room topic (irc.keystreams.com). It is an interesting read for all those who have ever been baffled by why/how some people do things. The Yahoo! Webring listing of similar topics is here."
This discussion has been archived. No new comments can be posted.

Esoteric Programming Languages

Comments Filter:
  • My head hurts (Score:3, Interesting)

    by Alien54 ( 180860 ) on Friday October 12, 2001 @10:13PM (#2422919) Journal
    One hallmark of Befunge programming is that all strings are reversed with respect to the IP; the following is the smallest 'Hello, World' program:
    55+".dlrow ,olleH">:#,_@
    Some folks just do not know when to quit
    • Re:My head hurts (Score:5, Informative)

      by Farq Fenderson ( 135583 ) on Friday October 12, 2001 @10:24PM (#2422953) Homepage
      Well, you do have to put stuff on the stack in reverse... since it's FI/LO. Breakdown of the program:

      55+
      put 5 on the stack twice, add the numbers on the stack together, leaving 10, or a newline in ascii.

      ".dlrow ,olleH"
      put "Hello, world." on the stack in reverse, this is so we can pop it off in the proper order.

      >:#,_@
      very nice code to print out everything on the stack. '>' sets the IP velocity to "east", ':' duplicates the last item on the stack. '_' pops an item off the stack and tests it, if true, set IP to west, if false set it to east. The # skips the next instruction, and the comma prints the character off. So you're testing and printing until there's nothing left on the stack. The '@', finally, exits, which is executed when there's nothing left on the stack.

      Makes sense?
      • Makes sense?

        Of course string order can be arbitrary as long as the pattern is parsable by the language.

        • Yeah, of course that would be horribly inefficient. I mean, you could do this instead:

          "H","e","l","l","o",","," ","w","o","r","l","d",".",55+,@

          but that would be nasty. I'd sooner approach from the east, and read it backwards, but read right-to-left instead... that's a lot simpler.

    • > the following is the smallest 'Hello, World' program:

      > 55+".dlrow ,olleH">:#,_@

      Ah! So the notorious seineewerasreenigneepacsteN gig was just some source accidentally shipped with the executable, rather than an attempt at obfuscation.

    • I think this is shorter in perl. Compare:

      55+".dlrow ,olleH">:#,_@
      print"Hello, world.\n"

      Note that the space after print and final semicolon are optional in perl.

      -Ted
    • That hurt your head? Try "Hello, World" in BrainF***:
      I was going to put the code here.... But the Mother F**** lameness filter got the better of me:

      "Your comment looks too much like ascii art."

      Not a bad description of BrainF*** really.... Anyway check it out on this nice little page: http://www.roesler-ac.de/wolfram/hello.htm

    • Re:My head hurts (Score:2, Informative)

      by xmath ( 90486 )
      Here's a short one that has Hello World the right way:

      r:#,_q#:"Hello world!"+55

      (wrote it myself :-)

      -xmath
  • by jrockway ( 229604 )
    From the page:
    It does have some redeeming features, but it is not, on the whole, ... sterling.
    So that's what they wrote Windows with. Explains a lot, doesn't it?
  • INTERCAL (Score:2, Interesting)

    by jeffy124 ( 453342 )
    I'd like to see how Intercal is actually used for anything or if it keeps up with other emerging languages. When new (and useful) languages hit the scene, it probably has to drop some features because they're used in that language. I guess maybe it's the first language with the ability to shrink from it's original set of features, unlike other languages out there today (like Java or even Perl)

    Of course, it appears very inefficint - A search for prime numbers less than 65535 took 17 hours while C can handle that in a about half a second.
    • Re:INTERCAL (Score:5, Informative)

      by stripes ( 3681 ) on Friday October 12, 2001 @10:35PM (#2422978) Homepage Journal
      I'd like to see how Intercal is actually used for anything or if it keeps up with other emerging languages. When new (and useful) languages hit the scene, it probably has to drop some features because they're used in that language.

      They don't bother, but the language isn't static. There is a multi-threading extension for example. Typical of Intercal it is unlike all other threading packages I know of. It doesn't share data, only the code, all messages must be passed by altering the code (disabling and enabling blocks). Trintercal is base-3, there is also a base-N variant (the base-3 one shares some ops with the Klingon programming language...)

  • writing Haskell in the HUGS implementation for my programming language design class. Some of these obscure languages look, possibly, even worse!
    • Haskell is the cleanest language I've ever seen. Elegant whitespace handling, pattern matching, and concise yet clear notation.

      Care to elaborate on what you think is wrong with it?

      • by nellardo ( 68657 ) on Saturday October 13, 2001 @01:06AM (#2423166) Homepage Journal
        I happen to think that Haskell [haskell.org] is one of the semantically cleanest languages out there (I put Self [sun.com] in the same category).

        I mean really, in Haskell, "factorial" looks like this:
        fact 0 = 1
        fact n = n * fact (n - 1)

        Write that, and "fact 20" works just fine:
        Examples> fact 20
        2432902008176640000
        Examples>

        However, implementing Haskell (or Self) on a von Neumann architecture is non-trivial. Implementing an efficient compiler or interpreter is tres difficil. People get Ph. D. dissertations for that sort of thing. For someone deeply used to C, Haskell and Self are perverse.

        To wit:

        • In Haskell, nothing changes. Ever. State change is handled by creating a new state from the old one. Semantically clean, but about as far from C as you can get.
        • In Self, anything can change at any time. Yes, Virginia, you can redefine "if-then" whenever you feel like it. Change the inheritance hierarchy? No problem! Whoops! I made a cycle in the inheritance hierarchy! No problem! (yes, A can inherit from B and B can inherit from A). Think of C without the reliability that any particular operation (function call, operator, whatever) maps to the same place more than once. This kind of thing gives most C-family compilers hives. It used to be that C++ was perceived as significantly slower than C - I don't see anyone complaining about it anymore, but Haskell and Self are more extreme examples. C++ made it easy to use jump tables. Haskell makes it easy to use recursion, lazy evaluation, and a bunch of other things. Self makes it easy to use dynamic inheritance, multiple inheritance, even cyclical inheritance.
        What is most impressive about these kinds of languages is that you can build efficient implementations, without the compromises to the semantics that C (or its derivatives) entails. The fastest FFT library out there is in C, but the C code itself was generated by Haskell code (code that came up with some original optimizations along the way). The Self compiler is the root technology for Java JIT compilers (when Sun killed the Self project, all the compiler people went to work on "virtual machine" compilers). Self was able to hit 50% of the speed of optimized C while maintaining:
        • Full source-level debugging
        • Garbage collection
        • Checks for stack and integer overflow
        • and the ability to change the "class" of any object at any time (I put class in quotes because Self is an object-oriented language without classes - part of the super-simple semantics)..
        In short, there isn't anything wrong with clean linguistic semantics. But essentially every computer sold today is built around the von Neumann architecture, and non-von-Neumann semantics (like that used by Self and Haskell) are non-trivial to implement.

        • Heh, they teach Haskell in computing 1A here at the University of New South Wales, supposedly to teach us good programming style. And having moved on to C, I can say that some things are definitely nicer in Haskell than in C. However, in other's it's a real bitch.

          Being an (almost) purely functional programming language, I imagine that writing mathematical programs in it would be a piece of cake, but for anything else that requires states it's a royal pain in the but.
        • I happen to think that Haskell [haskell.org] is one of the semantically cleanest languages out there
          I was going to say in my earlier post that Haskell had the cleanest syntax and semantics, but I figured that regarding the latter some smart-aleck (which I suppose is now going to be me) would respond with a comment like this: Oh, really? Care to provide the clean semantics for Haskell's run-time space-consumption characteristics? At present the semantics are often best described by, "run it, and see what happens," although after a while one does develop a feel for it (which is incorrect more than one would like).

          For example, consider the expression,

          foldl1 (*) [1 .. 1000]
          which literally means
          (...((((1 * 2) * 3) * 4) * 5) ... 1000)
          and, by the way, is equivalent to your (fact 1000). Now, how much space is going to be consumed by its evaluation?

          Humans can easily see that the expression can be evaluated left to right, treating the operator (*) as strict, and, with the list defined by [1..1000] being built lazily, it is possible to evaluate the expression in constant space:

          = foldl1 (*) [1 .. 1000]
          = foldl (*) 1 [2 .. 1000]
          = foldl (*) 2 [3 .. 1000]
          = foldl (*) 6 [4 .. 1000]
          = foldl (*) 24 [4 .. 1000]
          = ...
          But is this what Haskell guarantees? Nope. An implementation might also do it like this:
          = foldl1 (*) [1 .. 1000]
          = foldl (*) 1 [2 .. 1000]
          = foldl (*) (1*2) [3 .. 1000]
          = foldl (*) ((1*2)*3) [4 .. 1000]
          = foldl (*) (((1*2)*3)*4) [5 .. 1000]
          = ...
          In this case the accumulator in foldl builds up a linear chain of thunks, which is evaluated only after the entire list is consumed.

          You and I can see that the second method is wasteful, but the language definition provides no guidance as to whether a Haskell implementation will choose the second or the more-efficient first. (In fact, GHC would until recently choose the second for this expression.)

          Don't get me wrong. Haskell is, without a doubt, my favorite language. It's what I used for my entry [moertel.com] in this year's ICFP Programming Contest [inria.fr], and I consider it the best hope for a truly great mainstream functional programming language. I love Haskell. But its lack of intuitive space-consumption semantics is a serious weakness.

          And, regarding your fact example, it doesn't really show off Haskell's semantics as much as its syntax. Why not show the classic Fibonacci Series implementation, which highlights Haskell's non-strict evaluation semantics?

          fibs@(_:fibs') = 1 : 1 : zipWith (+) fibs fibs'
          Now, if that isn't a beautiful line of code, I've never seen one.
          The fastest FFT library out there is in C, but the C code itself was generated by Haskell code
          Actually, the FFTW code was generated by code written in O'Caml [fftw.org] not Haskell.

          Cheers,
          Tom

        • The The Evolution of a Haskell Programmer [willamette.edu] (found on the great Lambda the Ultimate [weblogs.com] blog on functional programming) features a dozen funny Haskell functions to implement factorial. The most elegant implemenation, though, is by the "Tenured Professor":

          fac n = product [1..n]
    • You obviously haven't gotten 'it' yet. Haskell is really, really neat. You've just got to learn to think it, just like you learned to 'think' Java or whatever.

      It's more abstract, so it often requires more thought from your side. But once you've gone there and explored and learned you are rewarded with a new way of viewing the world of computation and what goes on in it. Even if you never use it again, you'll at least know it's there and have a chance to understand why you do the things you do.

      But sure, it costs a few hour of pure thought before you see that light. And you don't seem to be interested in bending your mind around something different in this manner.

      Ah well. Your loss. Or mine =)
  • by hackerhue ( 182083 ) on Friday October 12, 2001 @10:30PM (#2422964) Homepage
    As an intellectual challenge, rewrite DeCSS in any of these languages. Feel free to share your results with us.
  • I wonder... if someone were to write an OSS product using one of these more obfuscated languages, I think we should ban from bearing the title OSS. People wouldnt be able to understand the code at all for their own uses or improvements. Hence it'll be Open source, but instead only the original developer would know anything about how it works, make changes, etc.

    Unless of course someone is REALLY skilled at hacking these languages :)
    • by skullY ( 23384 ) on Friday October 12, 2001 @11:30PM (#2423055) Homepage
      I wonder... if someone were to write an OSS product using one of these more obfuscated languages, I think we should ban from bearing the title OSS. People wouldnt be able to understand the code at all for their own uses or improvements. Hence it'll be Open source, but instead only the original developer would know anything about how it works, make changes, etc.
      And that's different from perl how?
      • Because apparently, you're the only person on the face of the planet who doesn't know perl.

        I know perl. My boss even knows perl.

        The lame "I-know-Visual-Basic!" interns where I work even know perl. :)

        (Yes, I know I'm an intern, but... I'm not lame)

        My point is that tons of people know perl. It's not exactly an obscure language... it's easily in the top 10 most used languages.
    • In that case, OSS == Obfuscated Source Software.
    • I don't think the Open Source license has any requirement that the end-user be required to understand the language that the program is written in. Otherwise, you'd have to recode every so that any potential "dumbass" who used it would understand it.

      You've pretty much spelled out the death of programming under the OSS license.
  • Brainfuck! (Score:4, Funny)

    by Anonymous Coward on Friday October 12, 2001 @10:35PM (#2422977)
    Post Comment
    Lameness filter encountered. Post aborted!
    Reason: Please use fewer 'junk' characters.

    Goddamnit, I just want to post brainfuck source.
    • Befunge's mailing list has [brainfuck] as a popular topic.. This feels like link osmosis. I got so engrossed in this stuff that I actually forgot where I found the link to it. Haven't felt like that since I first invented the internet.

    • I'm right in the middle of writing one. Hopefully I'll get free time to go back and work some more on it, after GCC 3.0.2 gets released (in a week).

      Why? Because I can, and it's fun.

  • My Favorite Quote (Score:4, Insightful)

    by istartedi ( 132515 ) on Friday October 12, 2001 @10:40PM (#2422986) Journal

    It has to be a toss up between:

    (from INTERCAL)The Sieve of Erosthenes test for prime numbers up to 65535 took over seventeen hours on a SPARC--it requires only a half second using C.

    and

    (from SMETANA) The language has two instructions: "Swap step n with step m", and "Go to step p".

    • From the Malbolge web page:
      Users are encouraged to make their own, unique homebrew versions of Malbolge and Dis, in order to achieve the kind of portability problems normally associated with major languages; therefore, I renounce copyright on everything on this page, all the archives, the languages, and related materials. They are all officially public domain--do whatever you want with them.

      • After looking at the Malbolge spec, I don't think that you could legally program in it without violating the DMCA.

        With the operation translation tables, it looks like trying to write a program in it is similar to brute-force encryption cracking.

        It is impressive that the one guy managed to write a "hello world" implementation.

        • I seem to recall that originally, the creator of Malbolge attempted to make a Hello World program, and got as far as "Hell" and gave up.

          Why'd they have to take the fun out of it by making one that works? :)
  • by PD ( 9577 ) <slashdotlinux@pdrap.org> on Friday October 12, 2001 @10:49PM (#2423004) Homepage Journal
    A clueless moderator marked it down as flamebait. A language has to be pretty awful for that to happen.

    Anyway, here's Brainfuck [muppetlabs.com] Also here [catseye.mb.ca]

    It's Turing complete, 8 instructions, and programs look something like this [catseye.mb.ca]

    • It's Turing complete, 8 instructions, and programs look something like this [catseye.mb.ca]

      Yes, but what does that lengthy program DO?

      Boy some of these languages look utterly pointless and useless...
      • That program a quine (a brainfuck quine *shudder* quite a feat in any language actually)

        That means the program when executed will print the entire source to the program.

        Quines are pretty time consuming to construct. There are a couple of famous quines floating around in C as well.

        So you can compile a quine run it, and pipe the output of the quine into a source file compile that, run it ad infinitum because the program generates itself :)

        Jeremy
  • What about var'aq? (Score:4, Informative)

    by The Ape With No Name ( 213531 ) on Friday October 12, 2001 @10:52PM (#2423009) Homepage
    That's right a Klingon [geocities.com] programming language. Waaaaaaa! As far from Perl as one can get....
    • Not that far actually... Damian Conway [yetanother.org], author, amongst many other wonders, of Lingua-Romana-Perligata [cpan.org] which lets you program in Latin, uses a module that does computation in Klingon in his OO classes and has written a module that let's you program entirely in Klingon!

      The most interesting point in both Latin and Klingon is that the order of words in a sentence is not significant. Instead declensions are used to determine the role of the various tokens in an instruction: 9 declensions are used to mark whether the variable is a scalar (nextum), an array (nexta), a scalar being assigned to (nexto) etc...

      BTW Damian also wrote Acme::Bleach [cpan.org], which turns your code into a file that apparently contains the single instruction use ACME::Bleach... but that still runs!

  • Reminds me of all those fun hours wasted drawing cool pictures with LOGO [umich.edu].
  • The Beer Page. (Score:5, Informative)

    by Christopher Thomas ( 11717 ) on Friday October 12, 2001 @10:59PM (#2423024)
    No list of esoteric programming languages would be complete without a link to the Beer Page:

    http://core.federated.com/~jim/99/ [federated.com] (mirror)

    This is a collection of programs written in over 200 languages designed to print the canonical "99 bottles of beer on the wall" song.
  • This article is extremely amusing, interesting, and informative, especially if you also follow the link retro computing [tuxedo.org] that exists in the article.

    I had forgotten how many failed experimental languages there were, and was amused to see these odd academic and intellectual experiments still sprouting up.

    One can only hope that one of these odd languages might spark the imagination, and actually provide a paradigm shift. Especially note worthy were "Befunge" and "Orthogonal" which are two-dimensional languages. More experimentation along these lines could only be good. Could a multi-dimensional language more efficiently encode parallel-processing software for instance?

  • by Baldrson ( 78598 ) on Friday October 12, 2001 @11:27PM (#2423052) Homepage Journal
    John Tromp [www.cwi.nl] has managed to out do the lot of them with his "Kolmogorov Complexity in Combinatory Logic [www.cwi.nl]" wherein he concludes [www.cwi.nl]:

    A mere 371 bits suffice to encode a universal combinator equivalent to ...(a) universal Turing machine:

    11100110010100110010110011000010001110010101110010 110
    01100101001100101100101001100101100101011100110010 100
    01101110011001100110001011010110100101011100101011 100
    10110011001010011000010001110011001010010010100101 100
    01110001011100110000100011011100110010100110010110 010
    10011001011001010111001100101000110111001100010110 110
    00110111001100101001100110010100110000100011000110 001

    Dan Brumleve [mailto] has a written a combinator interpreter in Perl that may be capable of evaluating Tromp's strange machine.

  • where's Refine??? (Score:2, Interesting)

    by shibut ( 208631 )
    The oddest language from my point of view was Refine. It was a lisp based object oriented language with relatively few parentheses. Yes, you heard right, lisp and "few parentheses" mentioned in the same breath. We used it to create a prototype and it was interesting. I believe it grew out of Teitelbaum's group at Cornell (creators of the Synthesizer, which 1st year CS majors at Cornell were forced to code on way back when). Anyone else ever use it? I found it to have many of lisp's disadvantages (garbage collection, anyone?) without all the advantages. It did have a good plugin for emacs though (and forced this vi veteran to learn emacs).
  • Users of unlambda should note that the "i" combinator is strictly speaking unnecessary. For further obfuscation, replace "i" with "skk".

    • Users of unlambda should note that the "i" combinator is strictly speaking unnecessary. For further obfuscation, replace "i" with "skk".

      Surely you mean "``skk".

      • Yeah, that's right. Sorry, misunderstood the bracketing rules.

        Incidentally, s and k can be constructed from another combinator (can't remember what it's called right now). Unfortunately it's not a supercombinator, so the graph reduction rules aren't simple to implement.

  • There is also an IOCCC [ioccc.org]-like contest for esoteric languages. It's homepage is here [mines.edu].
    Take a look especially at Sorted! [p-nand-q.com], which is a real cute language... :)

    Another list of esoteric languages [purists.org] is also available.
  • Unlambda (Score:2, Informative)

    by Ben Wolfson ( 216575 )
    The page says that Unlambda's interpreter is written in Scheme, which isn't strictly true. The CUAN contains interpreters written in Java and Scheme, and more than one in C. I think there's a buggy Perl interpreter, as well.

    I've written an Unlambda interpreter/stepper in Python, available here [uchicago.edu]. It's correct, as far as I know, but extremely slow for lengthy programs.

    Incidentally, here's "cat" in Unlambda:

    ```sii ``s``s``s``s``s``s`ks``s`kk`kc``s``s`ks``s`kk``s`k s``s`kk ``s`kk``s`kk`ki``s``s`ks`ks``s`kk``s`kk`kk``s`k@`k i``s``s`k|`kii`kei

    Loads of fun!
  • APL (Score:5, Funny)

    by maxpublic ( 450413 ) on Saturday October 13, 2001 @12:00AM (#2423090) Homepage
    If you want a strange programming language that garnered virtually no support and was a real pain in the ass, look up APL (primarily used at Pomona College in Claremont, CA, because the guy who invented it was a professor there).

    APL was defined by coding which wasn't particularly inventive but which required a complete keyboard overlay - it didn't use ASCII characters (except in text, as I recall), but rather a mixture of greek symbols and shit the author just plain made up. So in effect you had to match 'objects' to keys on the keyboard, a completely non-intuitive way of typing. Talk about watching your hands while you work....

    Unfortunately the college was incredibly gung-ho on APL and thought it would revolutionize coding, so if we wanted to do any serious work we had to do it in APL. This meant that about a dozen of us sat around learning APL so that we could program what might have been (don't really know, but I don't know of any other examples in 1983) the most massively multiplayer Star Trek ship battle game to date (up to 127 players, although the mainframe usually came to a grinding halt when we passed the 70 or 80 player mark). We then passed this program off as a science project, which it was accepted as since no one else could read the damned thing.

    Well, I guess it had a use after all....

    Max
    • Re:APL (Score:4, Interesting)

      by DumbSwede ( 521261 ) <slashdotbin@hotmail.com> on Saturday October 13, 2001 @12:15AM (#2423111) Homepage Journal
      The object of your uhmmmm... affection can be found here at retrocomputing [tuxedo.org] which is listed in the article.

      I find it odd how every syntax I have ever seen in a computer language looks ugly and stupid to me, until I become fluent in it, then I won't abide any change after.

    • Re:APL (Score:5, Interesting)

      by edhall ( 10025 ) <slashdot@weirdnoise.com> on Saturday October 13, 2001 @01:32AM (#2423194) Homepage

      APL was a lot more common than you might think. It was the first language to treat matrices as first-class entities, and so was popular for a time among the mathematics set. It was amazingly fast, in part due to its innovative use of lazy evaluation (e.g. if you only wanted a single column of a large matrix, it wouldn't bother computing the rest of it).

      A bit of APL lore: Back in the late 1970's, Ken Thompson (one of Unix's creators) spent a summer at UC Berkeley (an event that was rather influential in BSD's development). Just for fun, he wrote an entire APL interpreter -- in one weekend. It was a real pain to work with since it used two-letter codes instead of the APL character set, but other than some of the quad functions (various OS primitives and so on) it was complete.

      It's one of the more spectacular feats of programming I've ever heard of.

      -Ed
      • I know of similar. Back in the early 80's when Myrias [myrias.com] was starting up, Dan Wilson -- one of the founders of Myrias -- is said to have written an implementation of SNOBOL for the 68000 in one weekend (the original MYRIAS machines were multi-CPU 68000 boxes).

        Dan was one of the computing gods at the University of Alberta. He did a good deal of work with SNOBOL/SPITBOL (SPeedy ImplemenTation of snoBOL). People who knew the group were impressed, but nobody was really surprised
        . I have to say that spitbol was was an incredible language if you were doing string and list manipulation. Imagine, if you will, PERL on a combination of crack and LSD... It supposedly influenced the regex code in UNIX, but was (In my mind) far superior if you were doing interesting stuff.

        YOu could do stuff like:
        whitechar=any(" \t\n")
        sp = whitechar arbno(whitechar)
        # equivalent to perl regex whitechar+
        salut="hello" | "hi" | "greetings"
        friend="mike"|"john"|"sarah"
        enemy="louis"|"ian"|"jim"
        message salut sp (friend="my friend"|enemy="you slimy creep")

        Even better yet, you could say
        message salut sp ((friend|enemy)$name = f(name))

        In this case f is a user defined function that takes the variable name (which contains whatever matched 'friend|enemy') and returns a string that replaces it. Rather than have f() return a string, it could also return a pattern that continued the match....

        message (salut sp (friend|enemy)$name f(name))$sentence = g(sentence)

        shadows of this ability are existant in the $1 and \1 constructs of perl, but snobol is far more capable than that, because you can match on (and replace with) the return value of functions called with intermediate match results.

        (in all of these cases, we're matching the string in message)

        One weakness of SNOBOL is that it was almost entirely unstructured. The if/then/else structure was implemented as tags on the end of a pattern (like above) that implicitly did a GOTO depending on the success or failure of the match. (does anybody remember the calculated GOTOs of fortran IV?). Pretty much everything was global, and you could (if I remember corectly) jump into (and out of) the middle of what would otherwise be considered a function definition.

        There attempts to do a structured front end to SPITBOL (I think that it was called RATBOL (RATional spitBOL). Although it worked fine, it seemed to, somehow, lose some of it's magic. (perhaps it was just the hacker's yearnin for the obsefecuted(sp)).

    • APL is still very much around.

      For example, take a look at APLus [freshmeat.net], a GPLed language created at Morgan Stanley and derived from APL.

      For more information about J (another offshoot of ALP) and APL, take a look at J\APL - the journal of APL [demon.co.uk].

    • APL was heavily used at the University of Alberta in the late 70's and the early 80s (when I was there).It's integrated matrix functions made it really useful for many statistical and applied math activities. Many things that occured as loops in other languages were done as an operation on an array. I figured out how to do APL one-liners from the command line for MTS (Michigan Terminal System -- a now defunct OS for IBM/370 type processors) and would often use it as a quick calculator (think bc(1) with matrix functions)

      The use of greek letters for all builtin functions meant that the phrase "it's all greek to me", took on a special meaning for second year computer science and statistics students.

      One year, we got in a new chinese professor who's mastery of English was only slightly better than my understanding of Chinese (nil). I suggested to one of his frustrated students that she should try asking him questions in APL. At least then, they'd be on even ground.

    • Dunno your time frame, but when I studied it back in 71, it was at another college. I rather liked it, despite the pain of memorizing all those little symbols. Anyway, the symbols can be replaced by text tags. The important feature of the language is its elegant support for mathematical concepts, as this paper [acm.org] demonstrates. As with many languages, APL does make it too easy to write over-terse code that's hard to read. But that doesn't stop Perl from being popular.

      Incidentally, APL was invented by Kenneth Iverson [gte.net], who never taught at Pomona. Perhaps you're thinking of somebody involved in APL's descendent, J [jsoftware.com]. But neither language was the pet project of one prof.

  • Welcome to SpodNet! (Score:2, Informative)

    by direpath ( 513554 )
    Aha! The first mention of our glorious and unheralded IRC network. Anyone looking to hook up to a newer, reliable network... You may want to try connecting to irc.geeksanon.ca, the round robin DNS name. Of course, you can also use irc.keystreams.com, irc.gravitysucks.org (hosted by www.gravitysucks.org) and irc.duped.net. I am done.
  • My bad (Score:2, Funny)

    by whovian ( 107062 )
    What's all this about erotic programming languages? Oh...nevermind.
  • by Spootnik ( 518145 ) on Saturday October 13, 2001 @12:44AM (#2423137)
    Learn them all !!!

    Of course, you could also approach the task a little more systematically. A possible approach, and this is based purely on learning a language in order to improve one's thinking processes, rather than learning a language based on the marketability improvements possession of such knowledge brings, is to broadly catergorise them along the lines of 'problem solving styles', or 'programming mindsets' that they directly support or encourage.

    Assuming no prior knowledge, you could start by learning procedural programming; a very good starting point is C. It is a small, compact language that will help you learn the basics of procedural programming; it's not a difficult language if you stay away, initially, from its more esoteric features like pointers and bitwise operators. Having learnt C, you will have a very solid grounding for learning languages such as JavaScript, C++, and Java because the 'syntactic core' of these languages is very similar.

    Another procedural language is COBOL. It is quite a big language in terms of the number of reserved words ('verbs' in COBOL-speak) it offers. However, it is really quite a simple language and provides, as core facilities, tremendous file processing capabilities. In addition, it forces the programmer to be systematic, that is, you need to spell out exactly, and in painstaking detail, what it is you wish to do. In a way, its wordiness is its strength, and it is difficult to produce 'sloppy' code the way it is possible to do in, for example, C.

    Next, you could tackle object oriented programming. You could start with either one of the very popular object-oriented languages, C++ and Java. Personally I would start with C++ as it is, I believe, more complex, and thus, more difficult to learn; if you master it, Java will come easy, and the hardest part will be simply to learn its rich set of packages (collections of objects).

    Smalltalk is probably one of the purer object-oriented languages, is widely respected in the programming community, and, I should admit that the main reason I included it here is that its the next language on *my* list to learn. I've looked at a couple of Smalltalk code listings and have found it difficult, at first glance, to understand it; that being the case, I look forward to the challenge of learning it !

    Now, for a couple of oldies, but goodies: LISP and Prolog. Neither of these has, as far as I'm aware, very significant commercial application, but if you are looking to try some truly 'different' programming approaches, in a bid to extend your thinking processes, then these are it !

    LISP, for me, is a truly enjoyable programming experience. I won't pretend to be an expert in it, but by simply spending time with this language I have learnt so much about data structures, programming techniques, and, generally, problem solving techniques. It's a really good tool for 'doodling', that is, quickly whipping up little algorithms and immediately testing them. A definite 'must-learn' language !

    Prolog is one I find fascinating. I'm still struggling with it, and although I've developed nothing more than simple database query applications with it, every time I work with it I find myself approaching a 'simple' problem in non-conventional ways, always forced to rethink how something should be done. I would recommend you look at this language to learn how to program in a truly non-procedural way, that is, to work 'with' the help of the language itself, rather than simply writing down commands for the compiler / interpreter to follow.

    Finally, on top of these you could add interpretive 'scripting' languages, tools which are aimed more at 'gluing' applications together than being fully-fledged development languages in their own right (I know perl purists will probably scream, claiming this is heresy, but basically it is not so much a development language as a 'super-shell', an all-encompassing environment, almost an 'operating system within an operating system').

    Finally, I should stress that, as a programmer, it is not just languages that you should be striving to learn, but to expand your knowledge in general. For example, acquiring general business, management, communication and 'people' skills will make you more aware of the 'real world' in which you must apply your skills.

    While the idea of learning other programming languages is to extend your ability to identify and abstract problems, as well as adding to your 'armory' of programming tools, there is no substitute for a good grasp of your problem environment, that is, understanding the nature and type of 'problems' you will be asked to solve. Not every problem necessarily translates into a computer-based solution, hence the importance of also acquiring non-programming skills.
    • .... While the idea of learning other programming languages is to extend your ability to identify and abstract problems, as well as adding to your 'armory' of programming tools, there is no substitute for a good grasp of your problem environment, .... The language that you think about somnething in will shape the way that you think about it. This is as true for human languages as it is for computer languages. Ask anybody you know who is fluent in multiple languages (fluent, in this case, meaning able to "think" in that language).
    • LISP and Prolog. Neither of these has, as far as I'm aware, very significant commercial application,

      Actually, if I recall correctly, the backend for the Yahoo Stores site was (and still is) written entirely in LISP. This may have been mentioned on /. before, but you'll have to look it up yourself.

      As for learning:
      - Some flavor of asm
      - Modula-2
      - LISP
      - Smalltalk
      - C

      Then, once you've got your foundations down, use Perl or Ruby to get real work done...
  • my brain hurts because you allowed me to follow the Unlambda link. can i sue?
  • Heard it on the radio this morning: After The Sun, NBC, and the NYT, now Microsoft have received a "letter with a suspicious white powder" too. Apparently, some people think that Sircam, Code Red and Nimda are no longer enough to fight against the monopolist, and have decided to take this to the biological arena. As usual, the authorities' advice is "don't open any suspicious mail", except this time they mean snail mail.

    More here on CNN [cnn.com] (Scroll down to "Reno case has Malaysia link"), BBC [bbc.co.uk] (Scroll down to Cheney's photo), and Msnbc [msnbc.com].

    Experts are poring over posters shown at pro-Bin-Laden protests, but so far no hidden [wired.com] tux has been spotted in any of them...

  • Speaking of which, does anyone know what happened to the "99 bottles of beer on the wall" page that shows source code written in umpteen different computer languages to print out the lyrics to that song?
  • BrainF***? (Score:1, Redundant)

    That must be the triple-improved version of some language called BrainF, you know like C++ is to C.

    Or maybe those stars are there to mask some letters? I wonder what they could be?
  • Where have the dd/sh pages gone?

    Is DD/SH now a lost language that only exists as a faint memory in the minds of the few surviving followers of yester-year and the dd/sh monks now awaiting their untimely death? Does anyone have a copy of the sacred parchament?
  • ...was called abuse. I don't know if my friend came up with the idea himself or got it somewhere else and implemented it himself. The interested thing about the language is that anything could be redefined including the keywords of the language. It allowed you to really obfuscate things. I wish I had that interpreter, it was quite fun.
  • The Language List (Score:2, Informative)

    by robbyjo ( 315601 )

    It won't be complete if I don't include The Language List [unige.ch]. Not only this page contains resources for those esoteric ones, but also other "saner" languages too.

    For those of you who want to create programming languages, make sure you read [aw.com] the underlying principles. If you know all these stuffs, your programming language will not be just a toy!

  • It would be interesting to see how these
    languages could be used as pieces to a puzzle.
  • The section on "reMorse" (looks like morse code, used by characters in Cryptonomicon) has an outdated link.

    The new site is: http://members.tripod.com/rkusnery/remorse.html [tripod.com]

  • Another page on weird languages is here [catseye.mb.ca].

  • Esotheric programming forms and programming paradims: http://www.catseye.mb.ca/esoteric
  • Eubonicode (Score:5, Funny)

    by GrEp ( 89884 ) <crb002NO@SPAMgmail.com> on Saturday October 13, 2001 @01:37AM (#2423202) Homepage Journal
    Back when I took compiler construction at Drake University three of us got together and made our own programming language called Eubonicode to help those who like to engage in ghetto algorithmic expression. I threw it up on the website [iastate.edu]. Here is the fibbonacci code:

    sup
    {
    gimme fibo bitch
    a be 1 bitch
    b be 1 bitch
    putou a bitch
    putou b bitch
    fibo be fibo widout 2 bitch
    slongas (fibo bepimpin 0)
    c be a an b bitch
    a be b bitch
    b be c bitch
    putou b bitch
    dissin fibo bitch
    nomo
    }
  • I never thought that I'd see it up on slashdot, but my webring's up on Slashdot! How cool is that!

    In case you're wondering, I'm the bloke who administers ESOLANG.
  • while taking a programming languages & compilers class, the prof, after talking about parse trees, mentioned that we could implement double backwords for loops. A buddy and I looked at each and said, "huh? double backwards for loops?" The prof went on to describe a loop where:

    for (condition) {
    statement1
    statement2
    statement3
    }

    the condition is checked, and statement1-3 get executed. Then statement3, 2, 1 get executed followed by the condition being examined. Essentially flow runs down and then *up* the block.

    I always thought this was a kinda cool, half baked idea. Useful? No, not really, but cool nonetheless.
  • One of the things that Grace Hopper [google.com] was proud of was her part in the creation of COBOL.

    Around 1983 (+-2 years), Hopper visited the University of Alberta which was, at the time, ripe with computer language types. FLACC (Full Level Algol/68 Checkout Compiler) and, (I think) MAPLE were (partly) developed there. C, APL, SNOBOL, FORTRAN, ALGOL/W, PASCAL, PL/1, PL/C, PL/360 and LISP were just some of the languages taught in undergraduate classes there.

    In any case, A friend of mine was talking to Grace, and she commented that "Some of the people here were instrumental in the development of COBOL. I wonder why they don't mention it more?", to which Dan replied:

    "Perhaps they're ashamed of it".

    Another friend quickly pulled him aside and explained the history of Grace an COBOL. Apparently, you could see him blush through his (infamous) grizzly-adams style beard.

  • The best language on the list is Intercal. Unfortunately, it's very hard to learn. It's not that the language is particularly complex. It's just that all the constructs are so absurd, you can't stop laughing long enough to focus on what you're doing!

Your password is pitifully obvious.

Working...