My memory has Java not being a thing yet when Pascal was waning. For me, the progress was Java -> C -> C++ -> Pascal. It's going to be different for everyone, though. I hope someone knows how to answer this objectively, because it's an interesting question.

Similar history here - Pascal was the most common teaching language through the early 90's but by the mid 90's wasn't present in any of the (PC) development shops I encountered, particularly given the popularity of C++ for the Windows ecosystem and the focus given to OOP. Java was still in its infancy in the late 90's and since teaching languages tended to lag behind I'd agree that Pascal -> C/C++ -> Java is about right.

Worth noting that the Advanced Placement computer programming test moved from Pascal to Java.

This question seems to want an impossible generalization. One language waxed, another language waned.

I started out as a Pascal programmer, and moved on to Modula-2, then to a proprietary called Euphoria, then to compiled BASICs (principally QuickBASIC and compatibles), then to what are now called 'scripting' languages like Python and PowerShell. I haven't touched Java and it is unlikely I ever will.

@DrSheldon, No surprise if the rigid and ritualized world of academic testing moves more slowly than the cutting edge of commercial software engineering.

Funny, I used Lisp in my first real job, Pascal in the next, then C, Objective C, C++, Java, (the list goes on from there before returning to C and C++); but I never self identified as a Lisp programmer or a Pascal programmer or whatever. I always was just a programmer, and if I needed to learn some new language for a new project, I'd pick up the manual and I'd learn it. No biggie.

I moved from Pascal to python :-) (after some experimenting with other languages and a short detour in C). At the time, I even taught introductory programming and I covered Fortran and Pascal, then I added python to the mix.

@SolomonSlow - indeed; I use the tools that the job requires. Do we class mechanics by what branch of spanner they prefer?

When Java came out it was fairly limited and slow (no JITs, just to name one thing!) Plus the GUIs were ugly. (Still are, IMO, but NVM.) And it didn't take long for Sun to jump on the browser bandwagon as a means of getting usage/support (applets!) and IMO that just meant that everyone else realized that it was (at the time) completely unsuitable for any real app. That, plus deployment issues (you had to have the JVM + the JARs, and the packaging wasn't that good back then either) + remember at that time there were no language-specific "package managers/repositories" ...

... (except Perl and TeX) ... and - it just didn't have anything to recommend it to production uses, unless you were really all in on "no Microsoft allowed". In teaching of course things were different as they have different goals and made different judgements.

Jeez this question attracted multiple answers fast. Good work, @Schezuk!

P.S. Pascal was really limited in crucial ways. Biggest limitation of all: fixed length strings. (And on popular implementations: short maximum length fixed length strings!) Java certainly fixed that. Better than C did. (C++ wasn't much of an issue then at all.) But: The C solution, cruddy though it was, was at least well known, well described in textbooks and such, had ubiquitous support in C libraries, and ... I don't think turned out to be such a big problem for mass adoption. (Until we learned about buffer overflow attacks on the internet, of course, but that was later.)

@DrSheldon: When I took the AP Computer Science exam in 2000, it was in C++.

@davidbak: Programs that are going to use non-static-const strings that are more than a few hundred bytes should generally keep them in dynamically allocated storage, but making dynamically allocated objects behave like values requires that a language have a means of locating all such objects that exist any any moment in time. Programs in Turbo Pascal on the PC, or popular dialects of Pascal on the Macintosh, could handle text inputs larger than 255 bytes. They just had to use something other than the language's 'string' types to do it.

@davidbak: The maximum length of strings in popular Pascal dialects wasn't merely limited by the use of a single-byte prefix for length, but also by the fact that processing a construct like doSomething(stringFunc1()+stringFunc2()) would require allocating space for at least one, if not two, maximum-sized strings on the stack before calling either function. If a maximum-sized string is 256 bytes, that's practical. If a maximum-sized string is 64Kbytes, it isn't.

@supercat - well the larger point is Pascal strings were fine for school exercises but not so much in the real world.

@davidbak: Actually, they were fine for pretty much the same real-world purposes as non-dynamically-allocated strings in C. Standard Pascal's failing lies not with its string types (which are very useful for many purposes), but the lack of a standard means of handling variable-sized dynamic allocations of any sort.

@davidbak: If Pascal had recognized "Pointer to array of unspecified outer bounds" as a valid data type whose New statement required specifying the bounds, and whose bounds could be queried via some operator, along with functions to store the characters of a string into an Array of Char starting at some offset and to interpret a range of up to 255 characters as a string, Pascal's string type would be superior to anything that exists in the C language or standard library.

I was the last year of students to take the AP test in Pascal. The next year it was C. A few years later I took a course in college about a bunch of obscure languages, and little baby Java was just one of those languages. We wrote some applets, and it was still seen as a language for web widgets.

When I was in college in the mid 90s Pascal wasn't offered but C++ was in the process of replacing Fortran. We still had COBOL but I would imagine that was replaced too. Courses in Java and Visual Basic were optional at the time.

@davidbak: "Pascal strings were fine for school exercises but not so much in the real world." They were used in the Mac OS APIs (classic).

@supercat, Pascal strings just needed flex modes, and upb, lwb operators....

I was in school during that time. We first learned Pascal, then Java. When I then got to university, they were in the process of switching from Fortran to Java.

@WayneConrad: "For me, the progress was Java -> C -> C++ -> Pascal". I really don't understand what those arrows mean, or what "progress" mean to you.

@davidbak: Not related to the question. But still: formdev.com/flatlaf is an awesome project which makes Swing apps finally not ugly.

My memory (as just an amateur programming enthusiast from Singapore) was encountering Pascal being taught in schools-classes I didn't take because I was doing other subjects-but people who were interested in programming as a hobby (including myself) picking up C on their own. Computer clubs tended to teach C, too. The impression was that Pascal was being sidelined by C, and C was the "in thing" (even though C was pretty "old" too). I don't even remember Java being a thing back then - hardly surprising given that it was 1991, and Java wasn't actually in existence, at least as a public release.

Microsoft embraced C and not Pascal so the programmers targetting Windows were nudged in that direction. Borland who essentially was Pascal on Windows was considered a competitor and not an ecosystem as I remember it.

Also, the reason at all to use Java in the early was to get interactive web pages in the Netscape browser (and those emulating it). That's it. It was not until the Microsoft JVM and Hotspot in Java 1.2 that it became just bearably fast to use.

I think there could be a decent follow up question if you asked this same question for C#.

Regarding the Pascal influence, two things I remember James Gosling mentioning in an interview many years ago are: 1) Preferring keywords as in Pascal over symbols as in C++ (Gosling mentioned extends instead of : as an example). 2) (Technically not Java The Language but Java The Platform) The JVM was influenced by Smalltalk VMs, the Burroughs B5000, and the UCSD Pascal p-Code system.