High Level Languages & the IBM 360 Series - Computerphile

The Mythical Man Month wasn't just about project management! The Professor continues this tale from the 1960's & asks "Could IBM have used high-level languages to write the Operating System for their new 360 series machines?"
Adoption of C (fourth time lucky!) as the higher-level language for writing the OS kernel of UNIX is told by Ken Thompson, at VCF East 2019: bit.ly/C_Kern_...
Special thanks to Clem Cole and RichardInParis for much extra background information on 360 hardware and software
/ computerphile
/ computer_phile
This video was filmed and edited by Sean Riley.
Computer Science at the University of Nottingham: bit.ly/nottsco...
Computerphile is a sister project to Brady Haran's Numberphile. More at www.bradyharan.com

[@BytebroUK]

My first ever gig as a Programmer, was when I was working as an 'Operator' and someone noticed that I wrote code to sort 'stuff' out. I was given a multi-thousand line FORTRAN IV prog and told basically "That take nearly 24 hrs to run. Make it better." Fundamentally, I found that the innermost loop of three nested loops was four lines of FORTRAN IV. I turned those four lines into a page or two of assembler (obvs for that processor) and the compiler allowed me to embed assembler into the FORTRAN code, and it then ran in less than two hours, with results that matched exactly (my version of regression testing!).

[@chexo3]

That’s one way to optimize software. Give it to some smart kid and hope for the best.

[@jjdawg9918]

This man is a global treasure! My parents used to tell me about how they had to walk 2 miles in the snow to get to school. Somehow that pales in comparison to what early computer/software engineers faced. I remember writing Pascal and JCL on a 360 but even then I had no idea what was involved in making all of that possible.

[@DiJaZu]

I can still remember when being a pupil the efforts of writing the Sieve of Eratosthenes in Fortran and how to submit it as a "short job" using JCL (the harder part...) using an IBM 3270 terminal and finding the output 15 minutes later as a printout of a chain printer in my output bin. The whole procedure and environment was fascinating enough as to spend shortly thereafter my saved money on a TI99/4A...

[@iamTheSnark]

Ah, the chain printer! That was quite an improvement upon our matrix printers. They worked, but even though intuitively the matrix printer would have been faster, the chain printer beat it in speed, and had a much better (if fixed) character set.

[@ahbushnell1]

@@iamTheSnark In 72 I was visitingTexas A&M looking for a school. I went on a tour and saw the big iron. They had a program that would play jingle bells on the line printer.

[@philippezevenberg1332]

sieve of what?

[@DiJaZu]

@@philippezevenberg1332 Finding prime numbers

[@DiJaZu]

@@iamTheSnark The IBM printers hand (of course) endless paper and managed 135'000 lines per hour and had to be vacuum cleaned twice a day from the fine paper residues

[@python-programming]

Always a great morning when a Computerphile video drops as an alarm clock!

[@colmx8441]

A good morning certainly. A great one when it's a Brailsford video :)

[@wahyu9420]

Well, it's 6 PM here

[@python-programming]

@@wahyu9420 haha!

[@geekgee]

I do enjoy Professor Brailsford's reminiscings.

[@greatquux]

We need more! Definitely make that video about hiding / public vs private interfaces. But the history of computing is really where I love hearing him talk.

[@williamdrum9899]

I could listen to him read the phone book not gonna lie

[@markmoore9486]

I wrote some Fortran on punched cards for a 360 in college in the 60s, but I was suspicious of high level languages working on Intel 8080 series designs in the 70s when memory prices forced you to be imaginative. I recall disassembling compiled statements to see how efficiently the compiler converted them to machine code, and then deciding what to compile and what to assemble.

[@Byt3me21]

I am shocked by how simply he describes it and at the same time floods us with information.

[@mikeklaene4359]

In late 1969 I hired on as a programmer trainee - with no degree nor programming experience. I had scored quite well on the IBM Programmer Aptitude Test. The shop had an IBM 360/30 with only 32K of memory so all new programs were written in BAL (basic assembler language). Many of the older programs were written in Autocoder and ran under 1401 emulation. Whilst the assembler was quite "smart" - the real magic took was performed by the linkage editor. It took a while, but by digging in the the link edit maps I could see how the code that I had written got integrated with selected modules from the library of IBM support modules in the relocatable library to see how the final executable program was generated. Eventually I came to grasp what was meant by the "extern" and "entry" keywords. This understanding payed off handsomely when I started mixing "C" and 8086 assembler in MS-DOS systems. This was back in the day when compilers and assemblers were predicated on the programmer knew that which he was doing. Nowadays, the developer tools assume that the programmer is an idiot that needs to be warned and protected from doing most things.

[@bullpup1337]

which is, to be fair, a safer approach

[@davidcarter5038]

IBM's assembler helped with structures - you defined a DSECT containing fields, WIDTH and HEIGHT for example, and then a USING directive to tell the assembler that a register, r10 say, pointed at such a DSECT then ST R4,HEIGHT would store R4 in the HEIGHT field implicitly using R10 as the base address.

About 20 years ago, I spent a while in a zSeries shop, fixing bugs in some ancient series 360 assembly code, and patching the binaries. Meeting people, who still thought EBCDIC is a brilliant encoding scheme, was a fascinating experience.

[@dave7f611]

I did that this morning.

[@lawrencedoliveiro9104]

IBM’s excuse for EBCDIC was that ASCII was almost, but not quite ready for prime-time in 1964.

[@TheEulerID]

I have the greatest trouble believing any programmer thought EBCDIC was a brilliant encoding system. I worked very extensively with it writing assembly code, and it's quirks with all those awkward discontinuities in the character encoding were always a nuisance. Of course it was just derived from Hollerith punched cards that were designed to be handled and sorted automatically by electro-mechanical machines, so it was a carry-over from the late 19th century (interestingly, much of the calculations for the Manhatten Project were carried out using punched card machines and that same electro-mechanical equipment used in things like compiling the census). IBM were also not the only computer company which used EBCDIC encoding back in those days. However, to this day I can still align by eye IBM 370 machine code instructions, identify the instruction types and disassemble by eye about 90% of the instructions, such was it burned into my brain. We used to apply machine code patches to the operating system whilst it was live (this was for 24 x 365 OLTP systems). I haven't done that for 30+ years, but it's still stuck there.

[@TheEulerID]

@@lawrencedoliveiro9104 the primary reason for preserving EBCDIC was, as always, with IBM, down to backwards compatibility tied in with commercial interests. Prior to electronic computers, punched card tabulating machines were extremely widely used (and had been since the early part of the 20th century) and data records were often kept on punched cards. Many companies still had machines of this sort in the early 1960s and kept data that way and wanted to maintain a degree of inter-operation and the ability to migrate. That, and there was a lot of equipment around to punch and handle cards, print from EBCDIC and so on.

[@pebbleschan6085]

8-bit EBCDIC is a doddle. 7-bit ASCII is also a doddle. GB18030 -OMG! Too big for a human brain!! For EBCDIC, decimal digits are prefixed with F; alphabetical chars have bit 7 set, bit 6 is used for upper/lower case, and the chars are stored in alphabetical order between decimal indices 1-9 for each nybble row with an offset of one for chars S-Z. For ASCII, decimal digits are prefixed with 3, alphabetical chars have 41(hex) added, bit 5 used for upper/lower case. For both, other chars are essentially scattered so just use a LUT.

[@dzaring]

I went to Norther Illinois University. They had written "structured macros". These macros had if, then, else, do while. We were supposed to use then and never, never use a branch or go to. They made assembly language so nice to use. It was my favorite.

[@essamal-mansouri2689]

I've never heard of anyone speak fondly about assembly but that actually sounds super fun. Do you have any examples of something you wrote that you can put online?

[@strehlow]

My assemblers class in college had a very interesting exercise. We were given specs of a CPU with a unique assembly language with about 20 opcodes. We had to write an integer division program in that language. We implemented each opcode for it as a macro in PDP11 assembler. Then assembled it and ran our division program on hardware foreign to the assembler we wrote it in.

[@wmrieker]

I went to work somewhere writing PDP-11 assembly code. There was a guy who made these horrendous macros none of us could understand! Easy to abuse and of course you had to know what instructions the macros created while you were writing the calls or you were in for some hurt debugging the stuff.

[@vectoralphaSec]

I learned IBM zOS 360 Assembler in university 3 years ago for my Assebler class. It was interesting.

[@name7692]

up until i tried assembly, i was quite fond of high level programming languages, but now i love the challenge of assembly

[@davesorgen5474]

Worked with 360/44, 50 and 4300 (pcm) series. Started with ForTran IV (1967) and moved on to PL/1, BAL, SAS and REXX. The real pain with all OS/360 boxes was having to pre-allocate all disk storage. JCL was #2 on the "fun" list.

[@iamTheSnark]

I programmed in Fortran for years on a Data General Nova 3, then Nova 4, finally on an Eclipse. Then we reprogrammed everything in Pascal.

[@lawrencedoliveiro9104]

Those IBM mainframes seemed to have amazingly primitive filesystems. Even our little DEC PDP-11s had files that you could grow just by writing to them.

[@LMacNeill]

I think I was born at just the right time. When I started as a Freshman at Georgia Tech in 1988, they were still teaching assembly and C -- not C++, because it hadn't been standardized yet, and universities weren't really teaching it at that time except maybe in some high-level classes or possibly for grad students. So I had to learn how to do all that stuff that's hidden from today's programmers. But object-oriented programming came along pretty quickly in the '90s, so I had to learn that too, in order to maintain my career as a programmer. There are programmers today who aren't much younger than I am who have literally never had to deal with the stuff that high-level languages keep hidden from you today.

[@allanrichardson9081]

COBOL was the first published language (initially called Flow-Matic) to use structures, because they were already in use for punched cards and accounting machines. PL/I and other languages copied COBOL in defining structures.

[@vincei4252]

We had an IBM4381 running CMS in college. None of us used it preferring to use the Vaxen with VMS and Unix on Apollo workstations. Not really surprised the 360 was odd and frustrating to use.

[@Masp89]

I've never worked on the System/360, but I'm very familiar with writing assembler and cobol for the IBM z/15, and trying to link-edit the modules together, it can be a mess sometimes! It's a pretty fun job, and I really enjoy working on this platform. As I'm quite young, the first model mainframe I worked on was the z/13 and later the z/14 and z/15, but a lot of my older colleagues are telling me stories about how life was like when they worked on the System/360 or the System/370. I really like listening to those stories.

[@YallDotBiz]

GE/Honeywell Multics OS was written in PL1. Best large mainframe I ever worked on. Multics would make a great video.

[@RaymondHng]

I learned Honeywell GCOS GMAP assembler.

[@YallDotBiz]

@@RaymondHng me too. Very rich instruction set.

[@RaymondHng]

@@YallDotBiz I remember MME GSNAP would produce a core dump.

[@YallDotBiz]

I learned in the 70's while in the Navy. You?

[@RaymondHng]

@@YallDotBiz My community college had a Honeywell 6023 in the late '70s. But when I went into the working world, it was minicomputers running the Pick operating system.

[@banrach1]

In the early 70's I worked on an IBM 370 using Fortran. I was using it to solve calculations regarding control theory. The problems can be very complex and contains many matrices ('S' transforms ) and lots of other complex structures. I did find FORTRAN an awful failure. The solution (for me) was IBM's APL2 implementation in the eary 80's. The IBM APL (and it's set of Auxiliary Processors) was brilliant, it's complex mathematical functions, easy I/O and graphic presentation functions made the task easy. Personally I think it is a much underated computer language.

[@btaylo24]

Should look at the AS/400 and its single level storage.

[@lawrencedoliveiro9104]

Single-level storage was pioneered in the ATLAS project, about two decades earlier. Also a feature of MULTICS.

[@black_platypus]

Really nice. I don't think I've ever heard somebody specifically highlight the "hiding" aspect of abstraction as a key virtue, but it feels good to have it said out loud :)

[@smurfyday]

That's sad. Teaching AP CS Principles course in high school and that's one of the main concepts.

[@vk3fbab]

It's pretty fundamental to how humans operate. Building knowledge and more complicated things as time passes. In electronics it started with transistors leading to ICs leading to CPU leading to microcontrollers leading to system on a chips. More and more integration and implementation hiding. Software is the same. Assemblers leading to compilers leading to operating systems with general purpose higher level languages and then problem specific higher level frameworks.

[@samuraijack5919]

Just started my job programming COBOL and MVS Assembler for an IBM 3090 mainframe. Assembler is makes you appreciate higher level languages

[@RameshKumar-mv3jd]

This man is the best. Please wring as many stories as you can from him

[@chriswatson2407]

Thanks for your bang up-to-date review of the System/360

[@BobFrTube]

As noted below, Multics was written in PL1, and the Unix group was spun out of the Multics group. While writing in assembler wasn't too hard when one was disciplined. In CP/CMS (VM) I could write services and tools in PL/1 and other high-level languages.

[@davidgillies620]

There's an operator macro in C called offsetof which gives you the byte offset in a struct of one of the fields. It's usually a sign you're doing something evil, but it does make for _marginally_ more portable code. You can in principle use it on (some) C++ classes, but that's hairy. You're more likely to need it in low-level systems stuff like kernel programming.

[@it5190]

He’s back! Keep them coming.

[@blankblank4949]

that is an awesome sweater

[@v8pilot]

The HP 3000 operating system MPE was mostly written in high level language SPL in the early 1970's.

[@kevincozens6837]

In Junior High school I wrote programs by filling in bubbles on some cards. They were sent out to be run overnight on the Board Of Educations IBM 360. In high school I learned WATFIVS (Waterloo Fortran IV). A few years later I also dabbled in PL/C and some IBM 360 assembler. I still have the reference books for PL/I and IBM 360 assembler.

[@andrewharrison8436]

Always found IBM machines to be programmer hostile but ask them to sort some huge data set and they just did it. I suppose both are corollaries of using assembler: raw power for the sort but untamed.

[@lawrencedoliveiro9104]

OS/360 (the troubles with which started off _The Mythical Man Month_ ) was written in assembler, but that didn’t stop it being complicated, buggy and slow.

[@BlankBrain]

I wrote a programmable RPN calculator for Prime computers. The main program was written in PLP, a stripped-down PL1 derivative with no floating point or I/O. The "registers" were manipulated in PLP as text strings. Most of the arithmetic functions were written in FORTRAN (IV). I think I had to write a few things in assembler, but I don't remember what.

[@leosigman7239]

I remember in the 1970s, programming in Business BASIC on IBM 360s and 370s leased through IBM’s subsidiary Service Bureau Corp. for time-sharing.

[@bulldawg4498]

I began my software development career programming in an IBM 360/MFT shop ... Our mainframe had less than one meg of physical memory ... I became an expert not only in BAL, Basic Assembler Language, but also the Macro Language, too ... Of course, everyone had to content with JCL, Job Control Language ... Because of MFT restrictions, our "load module" executables had to be less than 88K in size ... and programmer dynamic memory management was prohibited by fiat ...

[@jayb9687]

I don't understand any of it but I find it fascinating. You could say I'm a bit envious of people who can.

[@germansnowman]

Love these oral history videos! One big request though: Please get a tripod!!! The shaking is distracting and does the content a disservice.

[@RameshKumar-mv3jd]

I didn't notice it until I read your comment, now it's making me motion sick. He could even stabilise it in post if he couldn't use a tripod for whatever reason

[@parrotraiser6541]

Anybody who had to do anything on an ICL 1900 series machine has my deepest sympathy. I worked for English Electric, whose System 4 was essentially an IBM 360. When the Government forced the firms to merge, I looked at the documentation for 1900 and thought "How does anyone do any work on something so primitive? I'm not going to try." ICL were also notorious for using human names on variables and even operating systems (George III). Judging by the examples, the good Professor didn't escape the contamination.

[@TheEulerID]

I learned to write assembler code on an System 4, which was a licensed copy of an RCA Spectre, what was that company's attempt to write an IBM 360 semi-compatible (compatible at non-privileged level, but with significant differences with privileged instructions, the way the interrupt mechanism worked and in the channel architecture). I worked as a programmer on an OLTP operating system written (originally) by a combination of the Post Office Telecommunications, CDC and ICL to allow fast, automated custom clearance for the air cargo handling back in the early 1970s. It was a true 24x7 hour system and, when I joined in around 1979, it was running a thousand user system on an ICL S4 with just 768 Kb of ferrite core store (there was also a dual-mode version of the OS that ran on two machines which could write into each other's memory space by channel-to-channel adapters; basically a primitive cluster system with a shared "file system"; in quotes as it was not the sort of file system that people are used to these days). Later on it ran on ICL's DME machines which provided the S4 environment, but we also converted the OS to run on IBM (and Amdahl) mainframes under VM whilst keeping source (but not object code) compatibility for the OS. Application code was automatically portable of course). The OS itself was called MONITOR and was used on several Post Office Telecoms projects and also for RAF stores handling, which was running into the second decade of the 21st century as far as I know. In any event, having written assembler code for a few architectures, the IBM 360 version delightfully regular and logical. Things like C structures had their analogues in DSECTs, and it was easy to deal with arrays of items with mixed data types. I did take a brief look at the ICL 2900 series and its OS and I wasn't a great fan. By then I had read so many machine dumps that I could decode most object code by looking at hex dumps. It was burnt into my brain.

[@ny4i]

The more I hear about the IBM 360 Series, the more I thank my lucky stars I stumbled into a Burroughs shop and learned how to program in Burroughs Extended ALGOL :)

[@DougieLawson]

IBM did move on to writing in a PL/1 like language, variously called PL/S, PL/AS, PL/X and that's used today for z/OS (which is S/360 with a new marketing label). Db2 (the IBM mainframe SQL database) is exclusively written in PL/X. IMS the Data Language/1 hierarchical database is written in 50% assembler and the rest in PL/X.

[@greghunt4843]

Indeed, and PL/S is roughly the same age as C and a much more stright-forward language for the purpose (ignoring hilarous features like "return to"). The suggestion that Algol 68 might be used for system programming is mildly amusing, my recollection is that the first complete implementation of all language features didn't arrive until the early 80s (if you google it you get references to the late 70s, in either case the wrong decade to be contender for writing either OS/360 or Unix).

[@chexo3]

Ooh, this is cool to see, I’ve been interested in IBM Power ISA recently in the context of blob-free desktop/workstation systems. This isn’t about ppc but hopefully I learn something about the history of IBM here.

[@fernandogirard9702]

Almost all of my career was as tehcnical support for 370, which also operated (That is, OS, DB, comms and so on), but in the middle I was also programmer in Cobol, RPGII, CICS, Mantis (did you knew it?) and some assembler. Sadly, I falied with fortran. Those dinosaurs were great, And hats to the 1401 (yes, Autocoder!).I had the pleasure of modyfing code in real time with the 8 switches of th op code in the console. So funny.

[@marklonergan3898]

Good old dimentional array to linear memory block conversion - only relevant in an academic understanding these days but still the best example in my opinion of why programming languages use a 0-indexing (first element = 0) instead of 1-indexing (first element = 1).

[@SiMeGamer]

And why is that? How is being one dimensional relevant to starting from 0? I never studied computer science. I just dabble in programming and math on my free time, and I haven't gotten to this type of low level logic.

[@marklonergan3898]

@@SiMeGamer the formula for 0-indexing is just the sum of each of (index * size ^ dimension). It's not the best way of phrasing it so lets say you have a 3D array of length 100, using variables [i][j][k] to index them. So using the above formula, the 3 dimensions would be: (i * 100 ^ 2) (j * 100 ^ 1) (k * 100 ^ 0) Which is the same as: i * 10,000 j * 100 k * 1 (which is simply just k) So the formula would be: (i * 10,000) + (j * 100) + k So taking the index [51][27][3] for example, the linear index is: (51 * 10,000) + (27 * 100) + 3 = 510,000 + 2,700 + 3 = 512,703 I'm not sure a formula can even be made for 1-indexing. Some people would say the 1-indexing formula could just be 10,000 * (i-1) + 100 * (j-1) + k, but essentially, all you are doing is converting to a 0-index in your application - so in that case the language might as well just use 0-index all along.

[@TexDrinkwater]

The 360 is before my time. The only big iron i've got any experience with is a 370 running vm/cms. APL, COBOL, and FORTRAN, but mostly PL/I.

[@wmrieker]

wrote gobs of mixed fortran/pdp11 assembler for computer graphics in late 70s

[@HumbleHuman-k7g]

Really nice story of the “bit”.

[@Trev0r98]

Here's the key: IBM was focused on low- to mid-range not supercomputer stuff. They had the talent long before, but -- the bottom line prevailed.

[@jeffreyplum5259]

I am aware of the libraries used with Digital Equipment Fortran under their RT-11 operating system. They allowed one to do just about everything C could do, system-wise. Their were text processors which added higher level operation to Fortan. The best known of these was called Ratfor for " Rational Fortran" The real problem with doing Operating System in high level languages was the tiny size of memory on many systems . They were squeezing as much out of very limited memory and mass storage. By the time they got high level language s working well, there were all these ugly standards built into the systems.. 360 was also a real memory system. The linkers and loaders had to work overtime pouring programs into the limited memory allowed them. Virtual memory can use every scrap of memory in a system. It hides details of the underlying memory map with a simpler and cleaner model. It removes a large amount of the memory allocation tuning which was required by 360 era systems. Thanks guys

[@mentatphilosopher]

As I remember it the IBM Fortran, Cobol, and PL/1 compilers did not generate binary code directly. The generated not very human readable assembly code which if you wanted you could just punch out at that point. That intermediate file was then fed into the common assembler which generated the binary that the linker just linked into the completed executable. The linker had no knowledge of the higher level languages. I have written programs that were chimeras. Cobol for report writing, fortran for mathematical parts, and assembler bits. All you really needed to do is know how the higher level languages passed variables in function or subroutine calls, either by value or address or in the unique way that PL/1 passed structures and arrays.

[@steveb1972]

Rod, Jane and Fred(dy)? So this programme was written by a “Rainbow” fan! 😊

[@vernearase3044]

Later versions of the OSes for System/360/370/390 were written in PL/S (Programming Language for Systems). For low level OS operations, you really don't want language runtimes and diagnostic routines to be interfering with correct operation of the OS, so the traditional high level languages were not employed in writing low level code. From an operating system perspective, you really don't have much use for multi-dimensional arrays - when you're dealing with data aggregates you're mostly talking structures and linked lists.

[@mjbirdClavdivs]

I hope you'll do a follow-up to this since Brooks has now passed away at 91.

[@dikleatherdale8947]

The joy of the 360 was surely that its instruction set was closely matched to COBOL and Fortran. You couldn't say that about the ICT 1900 and COBOL on the CDC 6600 was a nightmare! But in certain other respects, I can only agree that the 360 was fairly unhelpful to programmers. But if I may disagree with David, his assertion that to access elements of two-dimensional arrays you needed to multiply, while being true of Fortran (because Fortran allowed out-of-range subscripting) could be avoided in other languages (Atlas Autocode comes immediately to mind but I suspect the same was true of Algol 60) by using Iliffe vectors (vectors of pointers to vectors of data (2D) or vectors of vectors of vectors (3D) etc.).

[@lawrencedoliveiro9104]

The CDC 6600 was a supercomputer. It could do computations about 50 times faster than anything else around. CDC was actually set up to sell business machines. But they made the mistake of hiring Seymour Cray as their hardware guru, and he just wanted to build the world’s fastest computers. And the company had no real idea how to sell them.

[@quintrankid8045]

"COBOL on the CDC 6600 was a nightmare" Why?

[@JessicaSunlight]

Was quite high level talk on a very low level things in world of computing 🙂

[@garanceadrosehn9691]

I started programming on an IBM 360/67 mainframe computer. I'm not going to take the time to provide all kinds of history, but one thing I'd say is that this video is talking about *hardware* (IBM 360), when the problems he's talking about are at the software (operating system) level. The first OS I used was OS/MVT batch system, which was pretty awful (IMO). We then switched to a non-IBM operating system which ran on the IBM mainframe. And we had all kinds of higher-level languages available, even though most of the operating system itself was written assembler. When you have a multi-user timesharing system, the OS really needs to care about low-level optimizations. Once much more powerful hardware showed up, then being written in assembler was a huge problem, but it was the right language for the earlier mainframes.

[@echandler]

MTS?

[@garanceadrosehn9691]

@@echandler - Yes. the Michigan Terminal System, run on 370 architecture mainframes by UofM @AnnArbor, RPI (@Troy NY), and maybe ten other colleges around the world. Canada, England, Brazil.

[@chaoslab]

Don't forget today is "international learn COBOL day". So get out there and make us proud!

[@Alestibana]

شكرا" لمجهوداتكم

[@Yupppi]

I have to say this every time. My favourite professor. So that's why the bible starts with the man naming every animal and thing. Innate need to name things to be able to abstractly deal with them.

[@WilliamDye-willdye]

When I started college the computer was a 360, and then I worked as a computer operator in a 360/370 shop. There was plenty to dislike about it, but it was probably better than it seemed because it took many attempts and a long time to finally replace it with something better. I still think that the only fatal flaw was cost. We look back and ridicule IBM for not adapting quickly enough to the low-cost PC/*nix revolution, but switching in those early days would've meant replacing their own still-lucrative business model with a still-unprofitable new model. Had they been willing to take the plunge, we might still be using the 360 instruction set today.

[@recklessroges]

Same reason that the movements in TaiChi have silly names; it makes it easier to remember them.

[@neilfurby555]

IBM 360, assembler language, punched card input, early 1970s...wonderful. And I was paid a salary as well !

[@peterstark9381]

Nice to see that I'm not the only one with a bend collar. ;-)

[@clarkac1]

I'm confused about when the Prof is talking about - must be middle late 60s as S/360 came out in 1964. And PL/1 (and also Cobol) could do all he was talking about with structures in the early 70s, so he must mean before then. ex-IBMer here!

[@petermsiegel573]

Agreed. I started in the early 70s on 360s, working in the daytime on time sharing terminals and various high level languages. At night I used paper tape on a PDP11. I much preferred the more powerful and interactive IBM systems.

[@RupertReynolds1962]

Odd. I started on Z80 micros, then learned MVS and VM (including VM running several MVS guests) with PL/I and assembly, then later moved to x86--I was horrified at how crude, ramshackle and just plain nasty x86 was, although it improved with 64-bit CPUs. I went back to MVS 3.8j (dated about 1980?) recently with TK4- (under Hercules) recently, and the only thing missing for me was the combination of the ISPF editor with Rexx edit macros, that turned it all into a kind of IDE when set up carefully. I've never found an instruction set and assembler as nice to use as Assembler H (or HLASM) on S/390

[@lawrencedoliveiro9104]

Ever did any VAX programming?

[@RupertReynolds1962]

@@lawrencedoliveiro9104 No, not VAX.

[@lawrencedoliveiro9104]

@@RupertReynolds1962 It had a machine instruction that took a table of coefficients and would compute a polynomial for a given argument.

[@RupertReynolds1962]

@@lawrencedoliveiro9104 I've never done that sort of work, but I can see it might be useful. Vaguely reminds me of S/370 "compare and form codeword" and "update tree" used in sorting. There was a prize at my shop for anyone who could explain in detail how UPT could be used :-)

[@lawrencedoliveiro9104]

@@RupertReynolds1962 There were quite a few complex instructions similar to that. They really went to town in terms of making assembly language look higher-level than FORTRAN in many ways. Much of it turned out to be pointless when it was discovered that these complex instructions were slower than doing the individual steps using a longer sequence of simpler instructions.

[@juliuszkocinski7478]

I now feel bad for trying to skip assembly during university

[@frankgerlach4467]

Using C for operating systems is by no means a given. The ICL mainframes used Algol in the kernel. In many ways, this was more safe and secure than the Unix/C approach. Unix and C won out, because it was given away for free. We now have the Cyber War Domain because of C and Unix. The idea of "linear progress in technology" is fully wrong. C was a regression compared to Algol !

[@Richardincancale]

Hi David. I think if there was beauty in the 360 it was in the idea of having a range of machines with a 1:50 power range (initially, and more later) that were compatible. The corollary if this was that the same software had to be able to operate on an 8k word machine as well as a big(!) 256k word supercomputer. High level languages, even Fortran were still too inefficient at producing optimised code. So every byte was sacred…

[@iamTheSnark]

True that. We programmed in Fortran for years, and by changing the most common modules to assembler, the speed of the overall program increased by a factor two.

[@lawrencedoliveiro9104]

The idea of an instruction set implementable across such a wide range of hardware capability was groundbreaking. The software side, not so much. IBM never really got used to the idea of timesharing (not until it adopted Unix in the form of AIX, anyway). Much nimbler competitors like DEC, DG _et al_ ran rings around it in this area, during the 1960s and 1970s.

[@Richardincancale]

@@lawrencedoliveiro9104 I agree that their official time-sharing products were clunky - TSS and TSO. But to be fair the VM/CMS system was not bad - it gave rise to the CP/M and DOS type interfaces 15 years later. The VM concept though - that each user had a complete virtual 360 was outstanding though - and today virtualisation is part of every IT system. The fact that the 360 ISA was virtualisable was luck rather than design. OTOH the x86 architecture was developed by Intel at a time when they should have realised that having a non-virtualisable ISA was a mistake…

[@lawrencedoliveiro9104]

@@Richardincancale CP/M was originally cross-developed from a DEC PDP-10 machine running TOPS-10. That’s where its inspiration came from, not IBM mainframes.

[@Richardincancale]

@@lawrencedoliveiro9104 Ah interesting - I hadn’t realised that that Monitor, the predecessor of TOPS-10 was released as early as 1967 - the same year as CMS. They were probably both influenced by CTSS…

[@mheermance]

One of my senior projects was a batch operating system for a 3081D which is a 360 descendent. The ability to load and execute it in a virtual machine via VM/CMS was a real win. But wow was the instruction set primitive, even compared to the 6502. There was no hardware stack, so you needed to do call linkage yourself via BALR and a heap.

[@lawrencedoliveiro9104]

Lack of a hardware-imposed stack is not necessarily a disadvantage. Even POWER/PowerPC does not dedicate any register as a stack pointer; that is purely an ABI convention. And that’s about as modern an architecture as they come.

[@mheermance]

@@lawrencedoliveiro9104 Yes, I've worked with some RISC architectures that used register linkage for subroutine calls. It's been decades, but I seem to recall this was more crude than those due to a lack of addressing modes that eased using a register as a user stack pointer. Instead you used the heap for everything, including saving your registers upon entry and exit to a subroutine. It was a strange experience.

[@lawrencedoliveiro9104]

@@mheermance On PowerPC Apple Macs, R1 was dedicated as the stack pointer. I think this might have been IBM’s usage as well.

[@mheermance]

@@lawrencedoliveiro9104 Yes it's common on RISC architectures to choose one register as a stack pointer by convention. In addition such machines support a register indirect addressing mode with offsets, and often auto increment and decrement. If you ever programed the RCA 1802 it used exactly this approach.

[@lawrencedoliveiro9104]

@@mheermance There’s even a note in the PowerPC documentation that load-with-update (i.e. stack pop) might be slower than doing separate load and add-to-stack-pointer-register instructions.

[@monkeybarmonkeyman]

Yes, if you want the bee knees and it was wonderful, go look at the System 38 which moved into the AS/4000 then eventually what, the A series... Designed specifically for business, they were amazing. The System 38 established an object-oriented operating system for users that do this day, I wish was behind all PC OS's... IBM "tried" apparently with Warp... but Gates beat them with money he earned from them in the first place...

[@btaylo24]

It changed name to iSeries and now IBM i

[@bfs5113]

I was a Computing Science student, majoring in OS back in the 360 days using punch cards.

[@spearhead30]

This is amazing!

[@ahbushnell1]

Fortran has complex numbers also, which is nice.

[@michaelsommers2356]

-That's a relatively new addition to the language.-

[@ahbushnell1]

@@michaelsommers2356 I remember using it in optical calculations when I was an undergraduate. That would have been in the 70's.

[@michaelsommers2356]

@@ahbushnell1 Turns out the complex type goes back to FORTRAN II. I could have sworn it appeared in FORTRAN 77; I don't remember it at all in FORTRAN IV. My mistake.

[@ahbushnell1]

@@michaelsommers2356 I recently found out Python can handle complex numbers which is great.

[@michaelsommers2356]

@@ahbushnell1 I think most languages today can, and any object-oriented language can be made to. Of course, any language that has semantically-significant whitespace, regardless of any other wonderful features, is an abomination unto the Lord.

[@quintrankid8045]

I wonder if we can get a video on indexing for band matrices.

[@phasm42]

When I was a teenager, assembly was life 😅

[@TheEulerID]

I find this video thoroughly confusing. What is meant by could IBM have used a higher level language when it goes on about the user environments. This seems to confuse the operating system (or operating systems - there have been several), that the operating system was written in, and what languages were available to programmers. Also, just what sort of user environment is he talking about? The batch environment under, say, MVS? Or the time sharing environment under MVS (TSO). Or maybe CMS under VM (which emerged later). Or, perhaps, the transaction processing environment under, say, CICS. I worked on IBM 360 architecture (or, rather, IBM 370 and later) architecture machines for quite a long time, although I came to it via an ICL S4, a licensed copy of an RCA Spectra, itself a (mostly) IBM 360 compatible machine at the user programming level (although different when you got into privileged instructions and the channel architecture commands). I did program in assembly language, but then I was working on a dedicated transactional processing operating system called MONITOR which ran UK air cargo handling and automated customs clearance systems for almost three decades (also RAF stores control and a few other things). It was ported over to (real) IBM machines rather than ICL S4/370 and ICL 2900 (S4) DME machines in the early 1980s. In any event, back to the 360. Those early operating systems were all written in assembler, largely because of limited resources and the need for efficiency. The IBM 360 was introduced in 1964, and that was an age of ferrite core storage which could be measured in tens or a few hundred KB. Even in 1980, we were running 1,000 terminal OLTP systems in 768KB of core storage on an ICL S4, so efficiency was everything (although it was, by then, a machine that had been obsolete for a decade, but government politics dictated that it was not migrated to an IBM machine). However, by the 1980s on IBM operating machines, a considerable range of high level languages were available, including Fortran, CICS, APL, Pascal among many others. From a computer instruction architecture point of view, the IBM 360 and later variants were delights to program in assembly code, with a highly regular instruction set, consistent addressing modes and instructions which were comprehensive enough to be easy to program in without being overly complex (save a few oddities). I should add that I don't think of C as a full high level language, as it lacks lots of things I'd expect (like boundary limit checks, exception condition checks, string expressions, memory management and so on). C is more of a portable assembly language than a true high level language as the programmer has to be fully aware of the underlying low level data structures or else chaos will ensue - and often did when I saw computer science graduates fresh from university trying to code business applications using C. Also, what was linked together was not "assembler modules", but object code. Also, there is a direct analogue of a structure in IBM assembly code, and that's the DSECT. It lays out a memory structure template which can be addressed by means of a base register. Indeed, if you are so inclined, you can preserve the space for another type of DSECT, or and array of them, within you new DSECT if you so wish. It all has to be done very explicitly of course, but there's absolutely no reason to remember the displacement of anything. Come to think of it, I could do that in Z80 assembly code too.

[@Bhakti-rider]

Finally someone else who finds what he's saying rather confusing (or confused). I had a career as an application programmer/analyst in the MVT/MVS/zOS universe, using COBOL, PL/1, JCL.of course, CICS/SQL, Natural, and many other pieces of software, such as WYLBUR, TSO, SPF/ISPF, REXX, Clists, and others I might not remember. Not much of what he says rings any bells for me.

[@squishmastah4682]

I agree with Professor Brailsford 100%. The lack of naming schemes is maddening to me, and their inclusion is critical to many of the programs I create.

[@aboodtube2577]

Great Content!

[@prima6170]

Before my time. Came in at the System 36.

[@VAXHeadroom]

RISC: Relegate Important Stuff to Compiler :)

[@aleksandersabak]

It may have not been around yet, I'm not sure about the timeline, but wouldn't Forth be a good low level high level language? It can compile to machine code that runs somewhat efficiently and can be expanded to higher and higher levels.

[@aleksandersabak]

It's also easy to write a compiler for its basic syntax and write the true compiler in Forth itself.

[@lawrencedoliveiro9104]

The trouble with FORTH is it’s such a crummy language model. Even PostScript is better than that.

[@aleksandersabak]

@@lawrencedoliveiro9104 now what did you just say about my favourite language family?

[@lawrencedoliveiro9104]

@@aleksandersabak You like PostScript? Both its graphics model and the language are antiquated, but both can be improved.

[@aleksandersabak]

@@lawrencedoliveiro9104 I don't have much experience with PostScript, so my opinion on it is based solely on the information that it's a concatenative language. From the snippets I saw it seems it leans too much into the imperative syntax for my taste. I prefer languages that embrace the concatenative paradigm (like Factor or Quackery), but I know there are none in widespread use.

[@adamd0ggg2]

On hiding implementation: Abstraction > no abstraction > bad abstraction or Abstraction is better than no abstraction, however a bad abstraction is worse than no abstraction or Abstraction😁 ❌Abstraction😐 👎Abstraction😢

[@silkwesir1444]

Hard to tell who is older, the professor or that light switch behind him... :P

[@tocsa120ls]

If you search programmer's jobs, companies are STILL looking for FORTRAN programmers.

[@bazoo513]

Ah, how do we know this distinguished gentleman is a Brit? We hear about the best language no modern kids ever heard of: Algol 68 (and, a bit less so, BCPL). Now, _those_ were the days...!

[@bertcampbell8687]

The ONLY language is Assembler.

[@guilherme5094]

👍

[@rty1955]

Haha a 360 had 32k of memory! You had to write in assembly. Ivm does not use "struct" it uses control blocks. You can call ANYTHING by name of you use a DSECT or dummy section which is like a struct as a DSECT define offsets into a memory area. A DSECT uses NO memory. Typically you would create some memory, put your variables in it that was mapped by a DSECT, put the address od this memory into Reg-1, call a subroutine using register-15 as the memory addr to go to and a register save area pointed to by reg-13 that was standard linkage on a 360

[@akashpawar9058]

akash

[@gaptastic]

..."even genius programmers like me make mistakes"...

[@ITGuyinaction]

🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖🤖 You have incredible knowledge about computers! I'm also admiring that you were able to crete such a big channel. I'm trying to do sth similar but these are just few steps. All the best!

[@zxuiji]

paused at 6:57, calculating the positions of structure members doesn't sound all to difficult: ((index * sizeof_struct) + member_offset) seems about right to me

[@andrewharrison8436]

zero based or one based - damn off by 1 again.

[@michaelsommers2356]

The hard bits are the size of the struct and the offset of the member.

[@NotMarkKnopfler]

The hard bit is the multiplication on hardware that doesn't have a multiply instruction. If the width of your array is a power of two it's a simple shift operation, but if your array width is 11 (for example) then now you need a sequence of assembler instructions to perform the multiply. Those instructions consume memory and clock cycles!

[@zxuiji]

@@michaelsommers2356 Can easily note that in docs, be it on paper or digital

[@zxuiji]

@@NotMarkKnopfler Then simply have a sticky note on the monitor for the instructions (because garunteed they'd be common enough to warrent it) or dedicate a function to it (which is what I would do)

[@aoehler1]

Do fresh outs realize how easy they have it these days??

[@juliuszkocinski7478]

I know some to which C seems like archaic Lang that nobody wants and are displeased that they even need to be bothered with it (basically because of pointers. And lack of ready to use standard structures - Yeah, I know)... Not on my faculty though.

[@quintrankid8045]

@@juliuszkocinski7478 C? Archaic? You mean that language used to write the Linux kernel and to implement Python?

[@juliuszkocinski7478]

@@quintrankid8045 it's not my opinion

[@quintrankid8045]

@@juliuszkocinski7478 Yes. Sorry. I didn't mean to imply that it was your opinion.

[@THEMATT222]

Noice 👍

[@flyguille]

Trekkies DETECTED! gg.!

[@jurjenbos228]

"Algol68 if you are a weirdo committee person that loved high level languages". That is so true!

[@bernaridho]

Low level of what? Language? Not really. Low level of ABSTRACTION. High level of ABSTRACTION. Low level programming languages have low level of abstraction. High level programming languages have high level of abstraction. It's that simple.

[@Bhakti-rider]

Well and truly stated.

[@yasinnabi]

I found this channel very interesting and worth Subbing. I liked all the contents. subbed and liked! a fellow creator,,,