In this talk I make a critique of Inheritance as it is present in mainstream OOP. We look from multiple points of views on the Inheritance relationship, and we show that, at a closer inspection, it doesn’t reach up to the promises it makes. The talk touches the simple problem of the Rectangle and Square, it discusses the parallel with the is-a relationship, and it shows how the Liskov Substitution Principle runs against inheritance.
Based on Language Unlimited: The Science Behind Our Most Creative Power book by David Adger, in this Overload article I tried to explore how programming languages should be built, taking a linguistic perspective. The main idea is that we might hope that programming languages are structured in such a way that, reading the code can be done without any effort, leaving the main cognitive powers to focus on the semantics of the code.
In my last Overload article, I was arguing that the senders/receivers models may be a bit too complex. Soon after writing it, I realized that this is just perceived complexity. One can change the perspective at looking at the same proposal, and with that change of perspective, the concepts may be simpler to understand and work with. Moreover, the model seems to be strong enough to use it as a base for all our concurrent applications.
Executors are one of the most expected features for the upcoming C++ standards. This article tries to cast a critical perspective of some of the main proposals discussed for adoption. Besides briefly explaining the content of the executors proposal and providing a few examples, the article tries to pick on some decisions made in those proposals. It tries to argue about the strong and the weak points by adding simplistic labels of “good” and “bad”.
C++, like most imperative languages, have a bad tradition in writing multi-threaded applications. Concurrency safety ranks first in terms of C++ development frustration (far ahead from the second place). This talk shows how concurrent C++ applications can be designed by shifting the focus from low-level synchronisation to a set of concurrency patterns that deal with higher-level constructs.