For me, the evolution of Mac programming languages and use depended on the purpose, but it generally tracked the use and growth in language development over time as the personal computer took over. Initially, Pascal was very common and shipped with the early Macs -- MacPascal was the evolution from LisaPascal in the very early '80s. I may still have a copy of MacPascal somewhere. Then, it was followed by LightSpeed/THINK, TurboPascal, MPW, etc. Pascal was also available for the Apple II (very early, pre-'80s). But, the genius of the Apple II was Apple Basic and being able to drop into a command prompt at any time. There was also MacBASIC that appeared in the '80s (but I never really used it).
My first non-Apple Pascal compiler was Borland TurboPascal.
68K assembly was a requirement to do anything at the hardware level or to do hardware engineering (used it all the time, and then some). Initially, 68K was relatively easy and became more advanced with the appearance of the '020, '030 and '040 processors (managing interrupts, patching bus error vectors, etc.). I really loved 68K assembly.
Coming from Apple II, many early Mac developers understood 6502 assembly and also probably had crossover x86, Z80 experience and were familiar with MS-DOS and CP/M. There was a CP/M card for the Apple II in the early days.
At the hardware level, you had to be somewhat micro assembly agnostic -- but micros are all very conceptually similar and Motorola was a common platform, HC05, HC11, 6805, etc. For example, a peripheral device might be in HC11 and if you were working on low-level code in the Power Manager of the PowerBook Duo, you might be writing in 6805 assembly. The early high-level language compilers for embedded were somewhat primitive. It was mostly assembly for embedded work.
Generally speaking, C eventually became the mainstay across all levels, growing into C++ at the high level by around 1995-6-ish. However, there were other hardware development tools including Forth -- such as Mach2 and MacForth -- for probing hardware addresses, board bring-up, etc. that stretched back into the '80s and were critical for Mac developers (and researchers). Plus, Forth is cool - a stack-based language that lives in between high-level and assembly. I had to use it during board bring-up.
Also, I seem to recall direct PCI programming and low-level interrogation on later Macs via FCode. And, as you would expect -- there were many other languages that paralleled academia - Lisp (especially - very cool), Smalltalk, Fortran, etc.
There were specialty languages and MANY communications protocols to master -- the language of Data I/O. Notably, with the rise of Adobe, WYSIWYG and high-resolution imaging, came Postscript -- another early win for Apple -- but not used for general programming. However, it allowed for high-resolution definition and synchronization between the Mac (PageMaker) and Apple's early LaserWriter (mid-80s), giving rise to Desktop Publishing.
From my perspective, one of the best things Apple did to help all new programmers was to create HyperCard and HyperTalk. HyperTalk was very Pascal-like and called back to the early days of MacPascal but with greater ease-of-use and immediacy (interpreted) -- no need for a compiler or IDE (but eventually, there was a compiler/run-time). On the heavy metal side, MPW was the core IDE and had many extensions, capabilities and significant build complexity (my favorite). Other IDEs appeared over time -- the LightSpeed tools evolving into THINK tools and also the appearance of Metrowerks CodeWarrior (another personal cross-platform favorite), that was acquired by Motorola for their processor ecosystem. MPW was great and my standard IDE for a long time, but it was pricey and eventually lost out to CodeWarrior (and time-sharing with VisualStudio on the PC).
Finally, for the Mac, in order to be an effective developer, you had to understand Mac resources, resource files, resource programming and ResEdit. There was a dedicated book for ResEdit. I really loved ResEdit. Before I could program, I was a RedEdit hacker and prankster.
For debugging and disassembly, the primary tools were MacsBug and TMON -- again -- various dedicated books for Macsbug from Apple and a number of 3rd-party resources. Both tools were highly extensible with add-ons, data structure templates, symbols, etc. I used to love Macsbug on 68K processors. And, TMON was great. For disassembly, there was a program called MacNosy by Steve Jasik -- another very useful tool.
To summarize, coming from parallel exposure to early Macs and Apple II/IIc/IIgs then on to hardcore Mac-only, my dev language path was as follows:
High-Level
(BASIC) --> PASCAL ---> C ---------> C++
(HyperTalk for certain user docs because it was fun and useful)
---------------------------------------------------------------------
Mid-Level (glue for high-level integration)
------------------- 68K ASSEMBLY ------------> (always present/required) - HAL
Low-Level (glue for low-level integration)
---------------------------------------------------------------------
Device-Level (Metal and Minimalism)
--MICRO ASSEMBLY + C --------------->
But...mostly C and assembly.
For development today, It's still C/C++ and assembly, unless you're doing web, then it could be anything, with the specific addition of C# and Java as possible embedded cross-overs. C# is increasing in relevance with the rise of IoT, but it's still mostly C and assembly.
I hope the above provides a good overview of what it was like to grow through the evolution of various development tools on the Mac (and otherwise).
Mod: This reply seems off-topic vs. OP, so maybe move to a new thread, as needed.
I think I might have an Apple II Guide from APDA somewhere.
)
