What’s the oldest, weirdest, nastiest, or most unusual language you’ve ever coded in?

CommanderJameson

Ars Tribunus Angusticlavius
7,993
Subscriptor
Not including esoteric languages like brainfuck etc.

I’ll start with RTL/2, a realtime language with an emphasis on (a) re-entrancy and (b) ugliness. The only example code I can find is this, from the Wikipedia page. Still, it was enough to bring back traumatic memories.

Code:
TITLE Hello World;

LET NL=10;

EXT PROC(REF ARRAY BYTE) TWRT;

ENT PROC RRJOB() INT;
TWRT("Hello World#NL#");
RETURN(1);
ENDPROC;

The EXT PROC declaration is to pull in the TWRT function from the standard library so we can output something. RRJOB() is the equivalent of main().

RTL/2 (or, at least the version that was inflicted on me) came with an unpleasant runtime environment that ran on a DOS PC, and you had to use a fearsomely unfriendly editor to write it. Needless to say, it gained little traction outside of the UK chemical industry and is totally dead now. I was taught it as part of a realtime module at university, some 30-odd years ago.
 

fitten

Ars Legatus Legionis
52,251
Subscriptor++
Way back in the day, I was interested in computer languages so I would download them and play around for a little while and them move on. I've written some stuff in ABC (the predecessor of Python) on my Atari ST for fun. Some assembly languages can be kind of rough. I wrote some SHARC assembly. Other than that, I wouldn't say I've written enough in a bunch of other languages to count (all stuff like on-offs). We did have two professors in college who were big ADA fans so we had to use that for several classes. Wrote some Lisp and Prolog. Saw a little Cobol but never had to actually write it. I did have to write a library that imported Cobol flat file data, though.
 

invertedpanda

Ars Tribunus Militum
1,844
Subscriptor
Not sure either qualifies, but my first language was BASIC, and hardest was x86 ASM.

Worst language, however, was a proprietary one by a media company. MTL: Morris Templating Language. It literally did not exist outside of Morris newspaper websites. It tried to simplify common stuff to allow for faster development of things like calendars, lists, graphs, etc, but in reality it was hardly ever used by most properties because the rare times something was needed it was outside the working hours of folks like me so they said fuck it and made a graphic :p
 
  • Haha
Reactions: hanser

koala

Ars Tribunus Angusticlavius
7,579
C.

I've also done some x86 assembly. I also have a mathematician brother, so I've helped him do Fortran.

(None of the three I'd touch again if I could. I always say that many CS students say they love C when they are studying. And they keep a fond memory of it... until they have to write C for money.)

Those would be the oldest/nastiest, I think. (Well, nastiest may also include .bat files.)

I also did some 6502 assembly, 68k assembly, C64 Basic, and Blitz Basic (loved that one, that's what I consider turned me into a programmer).

As for unusual, I helped an acquaintance writing "C+-", their university's bizarre custom C/C++ mashup. Why? WHY? Those were for some terrible algorithm courses. Why would they spend time writing a bizarre obscure language when their syllabus SUCKED SO HARD? What a waste.
 

MilleniX

Ars Tribunus Angusticlavius
6,767
Subscriptor++
Oldest? Fortran 77, probably on code that's still in use. Lots of weather/atmospheric forecasting and research, and aerodynamics stuff still using it.
Weirdest? Prolog, lots of fun
Most unusual? An OS port in assembly for the ARC 'reconfigurable' architecture. It is/was an ISA specification and reference microarchitecture implementations that explicitly leaves room for chip-specific extension instructions, registers, architectural state, and so forth. Basically, optimized for designing ASIC functionality that's tightly integrated at the instruction pipeline level with a fairly generic CPU core.

Oh, I also explicitly wrote some PostScript for my undergrad course in programming language theory/design/principles.
 

devjames

Wise, Aged Ars Veteran
107
Oldest? Z80 Assembly under CP/M on old Addressograph/Multigraph / Varityper computer typesetters.

Weirdest? Magna8 under GCOS8. A COBOL-generating "fast development" language on an old Bull mainframe my employer had. Magna8 was "functional programming" before that was a thing. You were supposed to (basically) enter commands in any old order and it would make sense of the whole thing and generate a COBOL program to do it. In reality the language authors knew it couldn't do a lot without help, so you also typed in line numbers in specific ranges (ranges for each "module", IIRC) and then had to take the COBOL output, figure out what was wrong, and then write more line numbers. bleh.

Nastiest? 80286 Assembly. double bleh.

Most unusual? Forth. Deep Blue C was a runner up, but Forth wins.
 

Ardax

Ars Legatus Legionis
19,076
Subscriptor
I've never used anything particularly weird, but wandered through some awfully proprietary languages in my time. Apogee was one of them -- it was like dBase, only different. I seem to recall it took some finagling to get them to give us Windows DLLs to access our data.

Last employer had multiple in-house developed configuration DSLs for their flagship product.
 
FOCUS and JCL to get data from an IBM mainframe when I worked at an insurance company

I also wrote some VBA macros in Excel to input data into IBM PCOMM using the pixel grid and using sendkeys to automate tasks like navigating through menus and updating rating files. Saved literally thousands of man-hours of manual data entry, but boy was I terrified of something going wrong since it was the engine for the entire pricing system, and it was literally using Excel to do things "put a Y in the 24th row and 36th column on the screen, sendkeys the Enter button" and running for a full day just cycling through thousands of screens
 

von Chaps

Ars Centurion
1,910
Subscriptor
Oh, I forgot FOCUS. I was an Oracle consultant (yea, I know) taken on at one place and ended up doing FOCUS. Felt very odd.

Also, the very original C++, before there was a compiler, when it was converted to intermediate C. Which, of course meant debugging was fun (but at least it didn't spew pages of template errors).

Which also makes me think of C++'s template meta-programming 😱 - and not in a good way!
 

jacs

Ars Centurion
219
Subscriptor
Tinkered with a number of languages over the years though it never resulted in anything useful

  • Basic on a TRS-80 (early 1980s in high school)
  • Basic, Forth, some version of C all on an 8 bit Atari
  • Pascal, C, Modula-2 on an Atari ST
  • HyperTalk
  • VAX Pascal & Turbo Pascal

Lots of books on assorted languages like Prolog sitting around (I like reading books about different languages, even if I’ll never use them)

Java (it was obscure at the time, to me anyway - had a work project to take a Mac +touchscreen+Java and do something with it. Fortunately it was canceled before a single line of code was written.)
VAX Basic - first real job I had as a programmer involved this.

C# and .NET based coding activities now consume my working life, but those aren’t obscure.
 

fitten

Ars Legatus Legionis
52,251
Subscriptor++
I guess I could list MS Basic on MC-10. That's where it all started for me :) I had the 16KB RAM expansion pack (for a total of 20KB!). I, like many others from that era, wrote a D&D helper program in BASIC. I eventually got it so big that entering another line exceeded the memory capacity of my computer. Took forever to load from tape, too.
 

MilleniX

Ars Tribunus Angusticlavius
6,767
Subscriptor++
There was also a home-grown functional language that my undergrad used for CS II courses. Its syntax was somewhat modeled on Prolog, since they were used back to back in the course. Its most distinctive feature was a very simple syntax for lazy evaluation of specific expressions. I think it was just sticking $ in front of them to indicate a thunk. This made it very easy to teach concepts like generators that produced infinite lists, but only as they were consumed.
 
D

Deleted member 261340

Guest
Oldest? Z80 Assembly under CP/M on old Addressograph/Multigraph / Varityper computer typesetters.

Weirdest? Magna8 under GCOS8. A COBOL-generating "fast development" language on an old Bull mainframe my employer had. Magna8 was "functional programming" before that was a thing. You were supposed to (basically) enter commands in any old order and it would make sense of the whole thing and generate a COBOL program to do it. In reality the language authors knew it couldn't do a lot without help, so you also typed in line numbers in specific ranges (ranges for each "module", IIRC) and then had to take the COBOL output, figure out what was wrong, and then write more line numbers. bleh.

Nastiest? 80286 Assembly. double bleh.

Most unusual? Forth. Deep Blue C was a runner up, but Forth wins.

GCOS8 JCL is also pretty grim - and DPS8/DPS9000 assembly keeps me awake at night. (Nice OS, though.)
 

JimboPalmer

Ars Tribunus Angusticlavius
9,402
Subscriptor
In the order I learned them:
Boy scouts PL/1
Home BASiC
College ForTran
Pascal
Modula-2
Smalltalk 85
PDP 8 ASM
Work RPGII
COBOL
PL/SQL
C
Business Objects

Smalltalk was the oddest, RPGII was write-only code. I made a good living being able to modify RPG from 1983 to 1998 I enjoyed making PL/SQL faster

In RPG, numeric variables are 2 letters long, booleans are 2 digit numbers, greater than, less than and equal to were positions on the 80 column card. Comments go from column 81 to 96.
 

Aleamapper

Ars Scholae Palatinae
1,284
Subscriptor
Had to learn Prolog at university, what a weird, but cool, language that was. If I was older and had more experience in more declarative languages I probably would have gotten comfortable with it, but at the time it never really clicked with me at all. I got my assignments mostly done, but it never felt at all intuitive.

Looking back, the original AMOS Basic was quite a weird and nasty language. The syntax was all over the place, some bits are sort of natural-language-y, some bits are more c-like, everything is done via keywords rather than APIs so there's literally hundreds of them, with no consistency about anything at all, and so many of them are truly WTF material. And then there's the embedded animation language, AMAL :eek:
 

fitten

Ars Legatus Legionis
52,251
Subscriptor++
Not on actual hardware, we had a software emulator that ran on 8088 based PCs (even way back then). We had a class that was an "Into to..." something, I can't remember what, now, where we had to program in PDP-11 assembly the whole semester.

Also did a little bit of work on a Univac 1100 series mainframe (that was the main machine of the university at the time). 36-bit word and worked using Ones' Complement so it had a positive and a negative zero ;)

We had a Programming Languages course that we had like 8 assignments or so and every assignment had to be written in a different language... so Smalltalk, Prolog, Lisp, C, ADA, OOPascal (Borland), and some others.
 
Interesting topic....

Academic use - x86 assembly or Ada. Not sure why, but I loved working in assembly, although I never had to do anything more complicated than a few undergrad assignments. Ada was taught at my university because we had some defense companies that recruited heavily from our school and specifically looked for this skill. I never did really wrap my head around it.

Professional use - old C++. I've done about 95% Java development for 20 years now, but currently oversee a large C++ codebase from the 90s. There is a massive amount of complexity arising from 1) wringing acceptable performance out of 90s era hardware and 2) implementing functionality from scratch that is now standard in most languages.
 
The oldest, weirdest, and nastiest language I've ever coded in was the one I wrote my first paid program in—FORTRAN II II as extended (from IBM's open-source-for-customers implementation) for the IBM 7090 by C-E-I-R Inc. with help from the Smithsonian Astrophysical Observatory. My major achievement in that language was the Phase 3 program described in this post. My implementation of depth-first search (more-or-less independently re-invented) was greatly complicated because FORTRAN II didn't have recursive subroutine calls, so I had to implement from scratch a search stack using an array.

The coding error I mentioned in the last pre-P.S. paragraph of that post was a result of the horrible control structure limitation shown in "Simple FORTRAN II program" in the Wikipedia article. IIRC I had a three-way branch that went to the wrong statement number under certain circumstances. It took me 14-hour days from a Tuesday to an early-Sunday-morning shower to recognize that error, after ruling out a compiler error (I'd previously found one introduced by a C-E-I-R extension).

C-E-I-R's major extension to FORTRAN II was the implementation of logical three-way branching if a branching statement had a 'B' (for Boolean) in column one of the source card. The condition inside the statement's parentheses would then implement '*' as an AND operator and '-' as an exclusive-OR operator in the expression, and the middle statement number of the three following the close-parenthesis would be branched to if the expression evaluated to FALSE (I think). This extension made it possible to write programs that compared 6-character (the length of a 7090 word) strings of text, which made it possible to write programs that COBOL-61 made dead simple. Nevertheless my boss should have left the Phase 1 program described in that same last paragraph in COBOL-61, so it could have been expanded to correct keypunched-into-the-wrong-column errors in the RCA-PERT-format input. He didn't; I had to manually fix such errors that Phase 1 detected.
 
Last edited: