What's weirdest language did you ever use?

[olkipukki]

  is "simple approach" looks like required a special keyboard?



P.S.
found it in some magazine ad back dated to 90s

[tggzzz]

Ah youngsters

All it requires is a different golfball on the IBM Selectric typewriter, plus an overlay for the keys. In other words, exactly the same mechanism used for Greek and maths characters.

[ataradov]

Yeah, people in the 60s were always baked and invented a ton of garbage like this. Unfortunately some of that took off. Fortunately majority of that died the death it deserved.

I'm all for trying new things, but this is a clear fail. If it is not obvious to someone, then flipping burgers may be a better occupation.

Also, I wonder which of Greek characters means 100 here.

[KaneTW]

I'm in programming language research and APL is a weird one. It's undoubtedly effective but the entry barrier is absurd.

I talked with a person actively working with APL at ICFP last year; their main argument was that in most cases excess symbols are just noise (I agree) and APL was the logical conclusion of that. I think it goes too far; while I use APL-style quite a bit in Mathematica, idiomatic APL code is just too dense IMO.

Then again, I never really learned APL, so maybe that feeling will change if I actually learn it.

[T3sl4co1l]

"Write-only programming" comes to mind.  It's almost impossible to reason about, or understand, code as-written, and it's easier to start from a more comfortable base and reason your way down to the output symbols.

I sometimes feel that way about things I've written, though I'm trying to remember when I last felt that way.  It might've been writing SPICE, of all things; which seems fair enough, as analog hardware is very different from code, and a netlist is very different from a description language.  I'm perhaps more fluent in schematic than netlist.

Not to humblebrag, but I do like to think I comment well, so I've had fairly few times where I looked at something from the past and had to shake my head.  Thinking about my history, that's probably in part to do with growing up in QBASIC, where most of the head-shaking is working against the limitations of the language itself; to write truly awful formatting, is just as big a challenge.  If I had grown up in C, where truly awful formatting is not only allowed but encouraged, perhaps I'd have a very different perspective...  And, having matured into C, rather than being thrust into it, I try to format as neatly as possible.  So, while C is the most popular abuse-able language, I don't personally happen to have much codebase, nor much cringe in it.

Which, I guess, arrives at the point I guess I would like to make if I had the personal experience to justify it, C is a very common example that can very much be written in a write-only manner.

On a related note, there's "write-only" code of industrial importance, and you're using it right now -- a huge amount of JavaScript is obfuscated, partly to save space (minify) but partly also to make it difficult to hack or abuse (trackers, ads and blockers), sometimes even to make it difficult or impossible to debug (there's still a cat-and-mouse game driving good old fashioned popup windows, and these tricks are part of it).

Although I guess that still isn't really saying much, as "write-only" code is supposed to be machine code, which is literally everything you're using.  How many licenses prohibit decompilation, patching, memory manipulation and so on?  But it's literally just reading bytes (from an executable file, or an address space, etc.), which is trivial to do...

Oh, so, heh, as for the actual question; probably 8086 assembly.  I don't know a ton of languages, and I'm merely aware of the esoteric ones.

Or, I guess \$\LaTeX\$ is pretty weird, but it's not so opaque for ordinary use, and you rarely have to go out of your way to write new code yourself (basically I've written a few environments, nothing that counts as computationally interesting code).  I respect (or pity?) those that write packages for it though.

Tim

[hamster_nz]

Advanced Perl begins to look like random gibberish, especially if people go 'regex to the max'.

Postscript is pretty weird too, but in a nice way.

[WattsThat]

While I don’t think it would be considered esoteric, Datapoint 2200 assembly language was pretty frustrating due to its use of capitalized three letter mnemonics. Got pretty good at it after porting several large programs first to 8080 asm cp/m and then several years later to 8086 asm ms-dos.

I wish I had kept that thing, it had two 8” floppies in addition to the cassette decks. Unfortunately, it had a habit of blowing up power supplies on a regular basis, the ps heat sink was as wide and high as the enclosure and had hundreds of pins rather than fins to increase the area. But, that’s what you need when you build a processor out of discreet 7400’s logic. While it was considered fast for its day (2 MHz), you started a compile and went to lunch...

[AG6QR]

PL/C was a fairly straightforward derivative of PL/1, which in turn was not all that radically different from Pascal or Algol.  But it was designed for teaching in the age of punched cards.  The designers observed that turnaround for punched cards could be very time-consuming, and little syntax errors could prevent a program from executing, frustrating the student.  So they created a "patching compiler" for PL/C, which would fix up erroneous statements into something that made sense syntactically, if not always semantically.  If you were missing semicolons or had mismatched parentheses or quotation marks, it would insert symbols in the place that it thought made the most sense.  It was pretty good at fixing up very minor typos like missing commas and semicolons, but it was sometimes too enthusiastic at patching up things that didn't make sense.

The compiler would always produce an executable program, no matter what source code you gave it.  We used to make a game of picking up random punched cards from the trash bin, which would typically include lines from FORTRAN programs, data cards with numbers and/or text on them, and perhaps an occasional PL/C statement.  Most of the cards that ended up in the trash were there because they had typing errors.  We'd shuffle them and try to see whose random program would produce the longest output.  We almost always got at least a few lines of output. Occasionally someone would hit the jackpot and produce an infinite loop containing a print statement, which would hit the (rather short) limit on lines of output.

[mcovington]

I'm in programming language research and APL is a weird one. It's undoubtedly effective but the entry barrier is absurd.

I talked with a person actively working with APL at ICFP last year; their main argument was that in most cases excess symbols are just noise (I agree) and APL was the logical conclusion of that. I think it goes too far; while I use APL-style quite a bit in Mathematica, idiomatic APL code is just too dense IMO.

Then again, I never really learned APL, so maybe that feeling will change if I actually learn it.

APL defies one of the most basic principles of HUMAN language, which is that words are made of a discrete set of shorter units (speech sounds, represented by letters).  APL tries to make each character be a word.  Awkward, and of course it can't be carried out thoroughly.

[Stray Electron]

Ah youngsters

All it requires is a different golfball on the IBM Selectric typewriter, plus an overlay for the keys.

   No overlay needed if you had an IBM 5100.  :-)  Just flip the big red switch above the keyboard and you could use BASIC or APL.

    I originally learned APL on an IBM 1130 but never used APL professionally until 25+ years later and then only for one project.  IBM made APL keyboards for the 1130 and an optional APL keyboard for the original IBM PC.  The IBM PC APL package came with APL on a 360K or possibly a single sided 180k disk, I don't recall which.  The disk was self booting and had it's own OS and didn't run under DOS. IIRC the package also included an overlay for the original 84(?) key keyboard and IBM also sold a set of replacement APL marked key tops for the standard keyboard.  IBM PC APL also required that you use a Color Graphics Adapter card in the PC and a CGA monitor. The original text-only graphics card and Monochrome monitor wouldn't work with APL.  APL needed the 64k of video memory in order to load the APL character set for the character generator into RAM.  The Monochrome Display Adapter card only had 16k of memory (all in ROM) and the character set was fixed and did not include all of the characters that APL used.  But IIRC IBM or somebody also later made an optional ROM chip that contained the APL character set.  The IBM PC APL made calls to some of the IBM Copywrite messages in the BIOS ROM so it wouldn't work on any of the early MS_DOS compatible computers but it didn't take long before the clone makers found ways to write their own Copyright notices that allowed APL and other SW to run on the IBM PC clone computers, generally called "IBM PC compatible" instead of merely "MS_DOS compatible".

   I still have my APL books and an original package of IBM APL for the PC and somewhere I may still have a big set of the various "golf" balls (can't recall the right name at the moment) for the IBM Selectric typewriter and there is an APL character set on one of them.  BTW you also needed a Selectric with the optional RS-232 interface.  And AFIK the Selectric was only used as a print device and wasn't used for input, at least not with APL.  The Selectric might be capable of input but AFIK no one made an APL keyboard for it or an APL overlay. 

   The symbols used in APL are actually more logically thought out and intuitive than they appear at first glance. APL (literally "A Programming Language") was initially developed as a mathematics teaching language (at Harvard IIRC) by Kenneth Iverson but somebody at IBM saw it and IBM was so impressed with it that they hired Iverson to implement it as a programming language and in the late 1960s and most of the 1970s, APL and BASIC were neck and neck in popularity.

   The wikipedia article on Iverson is very worth reading.

   The HPL language that Hewlett Packard used in the HP 9825 calculator and a few of their other systems was their version of APL.

[tszaboo]

French.

[T3sl4co1l]

French.

https://youtu.be/lWUlRZ4KeNQ?t=15 (0:15 to 0:22)

Also, the relevant Futurama reference...

Tim

[westfw]

Well: "TECO" -  Both DEC and MIT versions.  It'd be pretty tough to post an example, given the use of all those non-printing characters.

My university taught APL to non-engineering majors, and the business school where I worked used it a lot; I could sort-of do stuff with it, but mostly didn't.   APL was used like Forth or LISP would be a bit later - you'd load up an interpretive environment with a bunch of functions pre-defined by someone else, and not so much PROGRAM as do analysis with a very advanced calculator (you know, back before symbolic math packages, or spreadsheets, or PCs.)

The ITS shell was pretty weird too.  And Macsyma.  A bit of EDT (an extensible editor) on the Univac 90/70.

"Raw Seething Postscript...", which wasn't that weird, but still pretty uncommon.

I got through part of a Cray-1 assembly language class before work-related issues drew me away.  Mostly just another assembly language, bit with a liking for one-character opcodes.  Ugly.

[jfiresto]

Well: "TECO" -  Both DEC and MIT versions.  It'd be pretty tough to post an example, given the use of all those non-printing characters....

Huh? Unless you were masochistic, you wrote your TECO code and then you packed it – you did not do both at the same time! How could anyone read the code, including its author(s)?

[tggzzz]

Surely the point of an interpreted or compiled language is to allow the use of readable code, what then is the point of wankery like that?

I hate languages like that, it's a similar thing to the 'examples' you find on forums which are just dick waving by people desperate to prove just how much smarter they are than everyone else.

I hate C too Or perhaps you like this flight simulator program from the 1998 IOCCC?

Code: [Select]

#include                                     <math.h>
#include                                   <sys/time.h>
#include                                   <X11/Xlib.h>
#include                                  <X11/keysym.h>
                                          double L ,o ,P
                                         ,_=dt,T,Z,D=1,d,
                                         s[999],E,h= 8,I,
                                         J,K,w[999],M,m,O
                                        ,n[999],j=33e-3,i=
                                        1E3,r,t, u,v ,W,S=
                                        74.5,l=221,X=7.26,
                                        a,B,A=32.2,c, F,H;
                                        int N,q, C, y,p,U;
                                       Window z; char f[52]
                                    ; GC k; main(){ Display*e=
 XOpenDisplay( 0); z=RootWindow(e,0); for (XSetForeground(e,k=XCreateGC (e,z,0,0),BlackPixel(e,0))
; scanf("%lf%lf%lf",y +n,w+y, y+s)+1; y ++); XSelectInput(e,z= XCreateSimpleWindow(e,z,0,0,400,400,
0,0,WhitePixel(e,0) ),KeyPressMask); for(XMapWindow(e,z); ; T=sin(O)){ struct timeval G={ 0,dt*1e6}
; K= cos(j); N=1e4; M+= H*_; Z=D*K; F+=_*P; r=E*K; W=cos( O); m=K*W; H=K*T; O+=D*_*F/ K+d/K*E*_; B=
sin(j); a=B*T*D-E*W; XClearWindow(e,z); t=T*E+ D*B*W; j+=d*_*D-_*F*E; P=W*E*B-T*D; for (o+=(I=D*W+E
*T*B,E*d/K *B+v+B/K*F*D)*_; p<y; ){ T=p[s]+i; E=c-p[w]; D=n[p]-L; K=D*m-B*T-H*E; if(p [n]+w[ p]+p[s
]== 0|K <fabs(W=T*r-I*E +D*P) |fabs(D=t *D+Z *T-a *E)> K)N=1e4; else{ q=W/K *4E2+2e2; C= 2E2+4e2/ K
 *D; N-1E4&& XDrawLine(e ,z,k,N ,U,q,C); N=q; U=C; } ++p; } L+=_* (X*t +P*M+m*l); T=X*X+ l*l+M *M;
  XDrawString(e,z,k ,20,380,f,17); D=v/l*15; i+=(B *l-M*r -X*Z)*_; for(; XPending(e); u *=CS!=N){
                                   XEvent z; XNextEvent(e ,&z);
                                       ++*((N=XLookupKeysym
                                         (&z.xkey,0))-IT?
                                         N-LT? UP-N?& E:&
                                         J:& u: &h); --*(
                                         DN -N? N-DT ?N==
                                         RT?&u: & W:&h:&J
                                          ); } m=15*F/l;
                                          c+=(I=M/ l,l*H
                                          +I*M+a*X)*_; H
                                          =A*r+v*X-F*l+(
                                          E=.1+X*4.9/l,t
                                          =T*m/32-I*T/24
                                           )/S; K=F*M+(
                                           h* 1e4/l-(T+
                                           E*5*T*E)/3e2
                                           )/S-X*d-B*A;
                                           a=2.63 /l*d;
                                           X+=( d*l-T/S
                                            *(.19*E +a
                                            *.64+J/1e3
                                            )-M* v +A*
                                            Z)*_; l +=
                                            K *_; W=d;
                                            sprintf(f,
                                            "%5d  %3d"
                                            "%7d",p =l
                                           /1.7,(C=9E3+
                              O*57.3)%0550,(int)i); d+=T*(.45-14/l*
                             X-a*130-J* .14)*_/125e2+F*_*v; P=(T*(47
                             *I-m* 52+E*94 *D-t*.38+u*.21*E) /1e2+W*
                             179*v)/2312; select(p=0,0,0,0,&G); v-=(
                              W*F-T*(.63*m-I*.086+m*E*19-D*25-.11*u
                               )/107e2)*_; D=cos(o); E=sin(o); } }
Download and run it from https://www.ioccc.org/years-spoiler.html You need a few other files for the scenery.

[GeorgeOfTheJungle]

Postscript is pretty weird too, but in a nice way.

A friend of mine runs his 3d printer with postscript instead of gcode.

I hate C too Or perhaps you like this flight simulator program from the 1998 IOCCC?

Code: [Select]

#include                                     <math.h>
#include                                   <sys/time.h>
#include                                   <X11/Xlib.h>
#include                                  <X11/keysym.h>
                                          double L ,o ,P
                                         ,_=dt,T,Z,D=1,d,
                                         s[999],E,h= 8,I,
                                         J,K,w[999],M,m,O
                                        ,n[999],j=33e-3,i=
                                        1E3,r,t, u,v ,W,S=
                                        74.5,l=221,X=7.26,
                                        a,B,A=32.2,c, F,H;
                                        int N,q, C, y,p,U;
                                       Window z; char f[52]
                                    ; GC k; main(){ Display*e=
 XOpenDisplay( 0); z=RootWindow(e,0); for (XSetForeground(e,k=XCreateGC (e,z,0,0),BlackPixel(e,0))
; scanf("%lf%lf%lf",y +n,w+y, y+s)+1; y ++); XSelectInput(e,z= XCreateSimpleWindow(e,z,0,0,400,400,
0,0,WhitePixel(e,0) ),KeyPressMask); for(XMapWindow(e,z); ; T=sin(O)){ struct timeval G={ 0,dt*1e6}
; K= cos(j); N=1e4; M+= H*_; Z=D*K; F+=_*P; r=E*K; W=cos( O); m=K*W; H=K*T; O+=D*_*F/ K+d/K*E*_; B=
sin(j); a=B*T*D-E*W; XClearWindow(e,z); t=T*E+ D*B*W; j+=d*_*D-_*F*E; P=W*E*B-T*D; for (o+=(I=D*W+E
*T*B,E*d/K *B+v+B/K*F*D)*_; p<y; ){ T=p[s]+i; E=c-p[w]; D=n[p]-L; K=D*m-B*T-H*E; if(p [n]+w[ p]+p[s
]== 0|K <fabs(W=T*r-I*E +D*P) |fabs(D=t *D+Z *T-a *E)> K)N=1e4; else{ q=W/K *4E2+2e2; C= 2E2+4e2/ K
 *D; N-1E4&& XDrawLine(e ,z,k,N ,U,q,C); N=q; U=C; } ++p; } L+=_* (X*t +P*M+m*l); T=X*X+ l*l+M *M;
  XDrawString(e,z,k ,20,380,f,17); D=v/l*15; i+=(B *l-M*r -X*Z)*_; for(; XPending(e); u *=CS!=N){
                                   XEvent z; XNextEvent(e ,&z);
                                       ++*((N=XLookupKeysym
                                         (&z.xkey,0))-IT?
                                         N-LT? UP-N?& E:&
                                         J:& u: &h); --*(
                                         DN -N? N-DT ?N==
                                         RT?&u: & W:&h:&J
                                          ); } m=15*F/l;
                                          c+=(I=M/ l,l*H
                                          +I*M+a*X)*_; H
                                          =A*r+v*X-F*l+(
                                          E=.1+X*4.9/l,t
                                          =T*m/32-I*T/24
                                           )/S; K=F*M+(
                                           h* 1e4/l-(T+
                                           E*5*T*E)/3e2
                                           )/S-X*d-B*A;
                                           a=2.63 /l*d;
                                           X+=( d*l-T/S
                                            *(.19*E +a
                                            *.64+J/1e3
                                            )-M* v +A*
                                            Z)*_; l +=
                                            K *_; W=d;
                                            sprintf(f,
                                            "%5d  %3d"
                                            "%7d",p =l
                                           /1.7,(C=9E3+
                              O*57.3)%0550,(int)i); d+=T*(.45-14/l*
                             X-a*130-J* .14)*_/125e2+F*_*v; P=(T*(47
                             *I-m* 52+E*94 *D-t*.38+u*.21*E) /1e2+W*
                             179*v)/2312; select(p=0,0,0,0,&G); v-=(
                              W*F-T*(.63*m-I*.086+m*E*19-D*25-.11*u
                               )/107e2)*_; D=cos(o); E=sin(o); } }

See? You can't do cool things like that in python 8¬)

[jfiresto]

Sure you can, but if you are not careful (or lucky), you excite unpleasant expedients and limitations within Python.

[GeorgeOfTheJungle]

You can write Forth programs almost as ugly and incomprehensible as Perl. Cheers, techman.

[techman-001]

You can write Forth programs almost as ugly and incomprehensible as Perl. Cheers, techman.

I knew it was only a matter of time

Besides, I have won the "Ugliest Forth Code" awards the last 6 years running !

[MarkL]

I have to put in another vote for APL, and I totally agree on the "write once, read never" aspect.

It was the first programming language I ever learned in the mid-70's.  My second language was BASIC a couple of years later, and it just seemed inconceivable that I had to explicitly iterate what I wanted to do over each element in an array.  What a step backwards.

I still have an RS232 Selectric with an APL ball.  Neither it or APL on my laptop get any use now-a-days.  Dealing with the character set is just too much of a barrier.  Octave is close enough for my needs, but I do miss thinking about what trickery (read: operators) could be used to solve a particular problem in APL.

G-code, with its incomprehensible function codes by number, and the varied interpretation of the codes depending on the current effective mode, is in second place.  What were they thinking.

[SiliconWizard]

Surely the point of an interpreted or compiled language is to allow the use of readable code, what then is the point of wankery like that?

Oh I agree.

Something to consider with old programming language is that resources were scarce, and the more readable/natural a prog language would be, usually the more resources it would take up to edit/save/load/compile/...

With newer languages, it's just unexcusable IMO, but some people still find that smart to make things look like gibberish.

[SiliconWizard]

Anyway, depends on what you'd call "weird".
I never had to use APL, but it would certainly deserve another vote. Although pretty interesting and in a completely different league, I would also mention Smalltalk.

Otherwise, for those I used: perl. May I just say "eek".

[tggzzz]

Although pretty interesting and in a completely different league, I would also mention Smalltalk.

The core concepts are now mainstream: Java is effectively "typed Smalltalk", and Ojbective-C is "Smalltalk with a C syntax".

Smalltalk is still easily available; the environment is called Squeak https://squeak.org/

I first used Smalltalk on a Mac Plus in 1986. It was, and is, glacial - but sufficient to convince me OOP was a very important part of the future.

ADDED:

I've just had a quick look at the current Squeak/Smalltalk system; it continues to be under active development and is continuing to disprove some of the claims made about C's supposed uniqueness for low-level memory-based applictions...

In particular, the Smalltalk Virtual Machine (VM) i.e. interpreter, JITter, garbage collector, memory is implemented and debugged in Smalltalk. It can then be "compiled" (for want of a better word) into the native code for a processor and operating system. C still gets a look-in, but merely as an intermediate language one level up from assembly (that technique is 35 years old, first being seen in Kyoto Common Lisp in the mid 80s ).

The power of that technique is obvious when considering debugging the GC, but it has many other benefits on the development process, e.g. just-in-time JIT development

When the JIT was frst being developed and was at a state
where bytecoded methods could actually be translated to
machine code, development fell into a very productive and
enjoyable rhythm.

As a bytecode was encountered for which
the template had yet to be written execution would stop in
the debugger, which would create a skeleton implementation
for the template method from the MessageNotUnderstood ex-
ception. The programmer would implement the body of the
method and execution would continue. Were the new tem-
plate definition to be incorrect and cause a bug during JIT
generation, rather than when the generated machine code
was run, then the debugger could be used to wind execution
back to the beginning of the JITting of the current method
and resume execution, repeating the cycle until disassembly
looked good (somewhat like lemming debugging below). As a
new method was encountered and JITted yet more templates
would be encountered. Similarly as the abstract machine
instruction to concrete machine instruction mappings were
added these could be implemented in the debugger, an expe-
rience repeated when new back ends were added. Much of
the JIT was written in this interactive live style. This style
encourages tool creation because one can create, extend and
polish tools in the middle of debugging sessions, enhancing
them to make sense of ones current predicament. Immediate
feedback makes tool investment cheap and cheerful.

from https://www.researchgate.net/publication/328509577_Two_Decades_of_Smalltalk_VM_Development_Live_VM_Development_through_Simulation_Tools

[SiliconWizard]

Although pretty interesting and in a completely different league, I would also mention Smalltalk.

The core concepts are now mainstream: Java is effectively "typed Smalltalk", and Ojbective-C is "Smalltalk with a C syntax".
(...)

Oh certainly (which is why I said interesting AND in a different league than other weird languages that have been cited). (And agree with the clear descendence in Obj-C, a bit less so in Java, but that's another topic entirely...) Smalltalk was pioneer, and influenced many later languages.

It was still the "weirdest" language I had learned. Whatever "weird" means to each of us.

[olkipukki]

https://en.wikipedia.org/wiki/Chinese_BASIC

that's cool 

At least you can save on 'key pressed' and learn Chinese at the same time!