Object-Oriented Programming seems to be receiving a lot of hate recently, usually from inexperienced developers who have just “learned” Functional Programming and then want to hate on anything that doesn’t support functional purity. Unfortunately, this crowd always seems to fit the same mold. They are usually web developers, fairly young, seemingly intelligent but extremely impatient and easily swayed by new technology (e.g. JavaScript developers fit this mold precisely) but the most important trait that sets them apart from developers who embrace OOP, is not persevering long enough to actually learn how to use it.
Interesting! I believe that the statement about using Mathematics as ‘general programming language’ might have been the inspiration for the language Fortress which contains/contained some very cool ideas:
You write your code in semi-pseudocode (the exact syntax of Fortress was based on a lot of research by Guy R. Steele about how pseudocode has been written in many papers over the years), which can use Unicode mathemathical symbols (or a LaTeX-y ASCII equivalent of them).
This code can compile to machine code, but also to a beautifully rendered PDF for human consumption.
Iterating over collections happens, by default at least, in no particular order and on as many CPU cores as your computer has.
Unfortunately, development on it ceased after a couple of years. Nevertheless, I believe that Fortress in turn was one of the inspirations for Rust (although I do not remember the source of that claim).
I like how Mark Seemann’s posts often revolve around pushing the impure code to the edges of the system and how he uses Haskell for creating functional reference implementations to inform the design of production code.
However I would expect that lots people would be uncomfortable with how
OO had a head start because it worked within the given limitations of the computer hardware at the time - limitations that held other approaches back. However since then:
It’s largely advances in hardware that have made it possible to create increasingly complex systems - more complex than the complexity that needed to be tamed back in the 1990s.
FP may not be the saviour but class-based OO needs a lot more (continued) scrutiny and not be automatically grandfathered as the best way to move forward.