I agree, so much legislation is broken, the legislators aren’t doing shit, so we citizens need to fix it!

But we could start with the right to repair.

I had a Sinclair QL which pioneered the keyboard. It wasn’t great - it was far behind the Acorn BBCs and the Commodores) but it was quite usable.

There was significant vertical travel, and there was variation in the push the key gave back - increasing to a point of no return, then a quick downward movement to the thunk of the end of key travel.

I could type moderately fast on it.

The reference if you haven’t seen it.

Dara Ó Briain is a legend!

If you’re pushing everyone’s buttons it’ll end badly.

That was one of the original proposed mechanisms to explain how the (obviously false) autism was caused.

But since then, since thiomersal was removed, other ‘causes’ and moral issues have been invented, including cells from abortions.

The one that makes me laugh the most is that it’s terrible that the poor poor baby is exposed to so many illnesses (measles, mumps, rubella, polio, tetanus, notovirus, rotovirus and more) in such a short space of time, it’s no wonder the poor dear’s immune system is compromised. And then the same mother drops the kid off at daycare and exposes the poor dear to all those viruses and more - and live viruses at that.

There is no bleeding logic, just feels. And they get so angry at the fake harm that medicine is causing, and simultaneously actually causing real harms to real people.

I don’t think that the anti-oop collective is attacking polymorphism or overloading - both are important in functional programming. And let’s add encapsulation and implementation hiding to this list.

The argument is that OOP makes the wrong abstractions. Inheritance (as OOP models it) is quite rare on business entities. The other major example cited is that an algorithm written in the OOP style ends up distributing its code across the different classes, and therefore

1. It is difficult to understand: the developer has to open two, three or more different classes to view the whole algorithm
2. It is inefficient: because the algorithm is distributed over many classes and instances, as the algorithm runs, there are a lot of unnecessary calls (eg one method on one instance has to iterate over many instances of its children, and each child has to iterate over its children) and data has to pass through these function calls.

Instead of this, the functional programmer says, you should write the algorithm as a function (or several functions) in one place, so it’s the function that walks the object structure. The navigation is done using tools like apply or map rather than a loop in a method on the parent instance.

A key insight in this approach is that the way an algorithm walks the data structure is the responsibility of the algorithm rather than a responsibility that is shared across many classes and subclasses.

In general, I think this is a valid point - when you are writing algorithms over the whole dataset. OOP does have some counterpoints encapsulating behaviour on just that object for example validating the object’s private members, or data processing for that object and its immediate children or peers.