> Turbo Pascal was in the running with assembly language for my favorite language to program the IBM PC in the 1980s.

Teaching myself programming as a kid in the late 80s I encountered the limits of BASIC and then Turbo BASIC pretty soon. Everyone I knew was dabbling in Turbo Pascal but for some reason I can't really recall I rented K&R at the local library and went for Turbo C. I got an incredible amount of mileage out of that decision.

Learning x86 assembly was par for the course back then. Everything was so slow and that was the way to get everything out of the machine. I even remember me going to some length dabbling with the timer for the CPU hogging DRAM refresh cycle to squeeze out the last few percent of CPU power that poor 8086 had. Basically moving away from the conservative settings towards a point where the DRAM was just not becoming "forgetful".

I saw Pascal on the VAX (sucked) in school before I really got into Turbo.

I saw C before I started using Turbo because I had a C compiler for the 6809 using this Unix-clone OS

https://en.wikipedia.org/wiki/OS-9

on a TRS-80 Color Computer and I was checking out the K&R C book and also the AT&T UNIX manual from the public library a lot: I had a project of implementing many of the "software tools" such as wc for OS-9 as well as developing tools compatible with ones people were using on CP/M bulletin boards like

https://en.wikipedia.org/wiki/LBR_(file_format)

and

https://en.wikipedia.org/wiki/SQ_(program)

(Now I tried that last one in Microsoft BASIC and boy the bit handling was painful)

OS-9 was a gateway for a lot of good developers. Constrained (8/16-Bit) enough to make you think but having a lot of the tools and ideas from mainframe/Unix world.

It was part of the strange CoCo experience. The CoCo had a superior CPU in that the 6809 was a great target for conventional compilers (as opposed to the 6502 which would drive you to virtual machine techniques like UCSD or Wozniak’s SWEET16)

Yet the 32 column text size was worse than the already bad 40 cols common on micros. It did not have the great audio of the C64 but the shack sold numerous upgrades like the Orchestra 90, you could even pack in four upgrade cards with the multi-pack. It was insane how many upgrade you could buy (like a digitized tablet, many kinds of dot matrix and letter quality printers, speech synthesis oak). Disc drives cost more than the Coco but they were way faster than the affordable 1541 that C64 users had)

I had a DEC printing terminal (with an acoustic coupler modem on the side!) and a TRA-80 Model 100 attached and could log in with three user sessions. I had a UART for one serial connection, the bit banger was fast enough for a printing terminal!

My Coco 1 starting burning up power supplies so I got a Coco3 which had 80 col text and a real windows + mouse experience for OS-9 but the third party software situation was terrible so I got a 286 machine in 1987, a time where I see Byte magazine is overrun with ads for PC clime builders. I got the money from a consulting project I did, I was told years later how much value my project made and should have asked for enough money to buy a 386.

The last version of TP I used was I think 7? and it added in inline assembler. It was super nice for 14 year old me to learn assembly just enough to do the things TP couldn't do (like control a mouse on DOS). It was my gateway to a life of software development.

I used that a bit (absolutely great) but that was near the end of my TP career, for the most part I wrote library subroutines in assembly.

For instance, the 8086 had a REP MOVS instruction that copies a block of bytes, the TP standard library used that for the copy data function. 80186 added REP MOVSW which would move 2 bytes at a time and be about two times faster on my 80286 machine. I had several replacements for library subroutines which took advantage of 80286 instructions to get much better performance.

Inline Assembly was already on Turbo Pascal 4.

Wikipedia claims that TP 6 added inline assembly, I looked at the TP 4 manual and found you can write

  procedure FillWord(var Dest,Count,Data: word);
  begin
  inline(
     $C4/$BE/Dest/       { LES DI,Dest[BP] }
     $8B/$8E/Count/      { MOV CX,Count[BP] }
     $8B/$86/Data/       { MOV AX,Data[BP] }
     $FC/                { CLD }
     $F3/$AB);           { REP STOSW }
  end;

Note that {} is a comment so this is raw machine code expressed in bytes where you can substitute in addresses or other values. Not as cool as what came later.

It is about having the feature available in some form.

Well, prior to 7 I had the yellow one. 6? and no books or manuals, just some snippets from a Peter Norton book I got from the library enough times that the librarian asked me to not check it out for two weeks once. I got 7 for christmas and it came with the manual and maybe I mis-remember the difference between "added" and "I learned about it then"

Ah yes, and then was it Borland Pascal? I seem to recall a nice IDE through my old rose tinted glasses. But 8086? PC assembly I didnt get along with, having been spoiled with DevPac and 68000 Amiga world. But I had a lot of fun with the box drawing characters in the IBM PC 'font' putting together a small Pascal windowing utility blitting chunks of memory to swap overlapping window focus.