Prime example: Lisp. The language has the smallest possible syntax, but its semantics are mostly in special forms. If you don't know the exact meaning of all special forms, you don't know the language.
Looks interesting. I wonder how hard/easy to port this to Linux/Mac, for example.
https://github.com/AntKrotov/oberon-07-compiler
Linux seems to be supported.
The compiler is written in C and should compile on many POSIX compatible systems. Works like a charm on the Pinebook Pro for example.
0.6 seconds on a free tier AWS instance:
Although Wirth seems to only have been involved with Oberon-2 and Component Pascal.
https://hardcoresoftware.learningbyshipping.com/
One of the things he talks about it the approach the Microsoft Tools team took to implementing MFC in C++. He talks about a lesson he learned from Martin Carroll, one of the early C++ gurus, that essentially just because a feature exists, that confers no obligation to use it. “You’re writing code for your product, not a compiler test suite,”. He took that and turned it into the MFC team's approach of using C++ as a better C, not OOP for the sake of OOP.
I remember those days well, even then I was mostly working on Unix systems with a bit of Windows here and there, but I was well aware of what MS was doing at the time. He gives a really engaging account of those times and it's interesting how many of the lessons he learned and talks about are still relevant today.
(Maybe I'm missing something, but) I'm not sure why this should sound at all like a contradiction – how could increasing a language's size/features reduce its complexity?! Maybe you meant "the complexity of programs in a language"?
That is the contradiction: does the addition of features makes the language more complex? Or do the features help simplify the code? Different answers for different languages?
It will be interesting to see the trajectory of new languages like Nim, Julia and Rust. These are medium-sized languages and Rust in particular is already considered complex by some programmers. Only time will show how much they grow in language features and complexity.
You do need to think carefully about how to add features, though.
By "the language", I mean every part of it, (I thought that's what everyone means!) and you two seem to mean, only the parts of a language used in the programs you write.
"The language Oberon emerged from the urge to reduce the complexity of programming languages, of Modula in particular. This effort resulted in a remarkably concise language. The extent of Oberon, the number of its features and constructs, is smaller even than that of Pascal. Yet it is considerably more powerful."
The FreePascal of today has grown considerably over time. The same can be said of many popular languages today: PHP, Ruby, Python, C#, Javascript, etc. Some languages start big from the beginning (e.g. Ada).
With large languages there is also the feeling you've only learned a subset of the language, blissfully unaware of many other features the language offers. At least with smaller languages you have a greater chance to master the language whole.
Of course, it doesn't automatically follow that a smaller language will be simpler or easier to grasp. (There is plenty of argument surrounding Go's supposed simplicity.)