What about the people who lived in the Americas or the Pacific 1800 years ago? These people could not have heard of Jesus as missionaries could not have spread any word to them at this time.

(And while I’m about it, Christianity was a whole different thing back then - the Trinity hadn’t been invented, there were multiple sects with very different ideas, what books would be in the New Testament had not been decided, etc etc. People with beliefs of that time would seem highly unorthodox today, and the Christianity of today would be seen as heretical by those in the 3rd century, so who’s going to heaven again?)

Purgatory was invented for the purpose of not sending good people who had not heard of Jesus to hell. But still, these people were denied their chance to get to heaven which seems mighty unfair.

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!

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.

I’m going to suggest food items that we still take from nature and eat with minimal preparation:

• Honey
• Fish like salmon, trout, grouper
• Shellfish (eg oysters)

We have evidence of shellfish and fish being eaten for a very long time - at least the middle stone age at 140kya - in middens which are 10s of thousands of years old.

Honey is likely to have been a food source - a treat even - even before humans left Africa (so before 100kya) but sadly this would be invisible in the archeological record

Surely that is reserved for QA!

This is exactly the answer.

I’d just expand on one thing: many systems have multiple apps that need to run at the same time. Each app has its own dependencies, sometimes requiring a specific version of a library.

In this situation, it’s very easy for one app to need v1 of MyCleverLibrary (and fails with v2) and another needs v2 (and fails with v1). And then at the next OS update, the distro updates to v2.5 and breaks everything.

In this situation, before containers, you will be stuck, or have some difficult workrounds including different LD_LIBRARY_PATH settings that then break at the next update.

Using containers, each app has its own libraries at the correct and tested versions. These subtle interdependencies are eliminated and packages ‘just work’.

There’s lox to unpick there

Not really. People shed skin and hair constantly, and the small particles float in the air and distribute themselves throughout the volume. And your bacteria are along for the ride. One of the functions of the protective suits, gloves and hairnets is to contain these these particles and thus keep the air as clean as possible. When combined with lamina airflow, positive room pressure and other techniques, it keeps contamination down hugely.

Same with me! I was binary searching cladistically and it spoiler >!it was a jawed animal and did not have hard bones!<. My search among the >!cartilaginous fish!< was all negative. Damn

And to add to that, all the characteristics listed their green flags - characteristics used to judge people.

My god that brought back memories. The first commands when sitting at a new terminal was always, always:

stty sane

stty erase '^H'

It was well into the 2000s before Unix had useable defaults.

Here’s a video with a lot of guidance and examples of use: https://youtu.be/EAQI2ZSmxPU?si=lF5xr8fKyCRHEk7F