The one time security through obscurity would have helped them?

Obscurity is often a valid security tactic, just not all the time and never by itself.

That would be more like: shuffling that document randomly between other documents, or using white font on a white page in Word.

Don't limit your thinking to taking photos - video also works fine. It's how The Mandalorian is produced. Instead of green screens, the actors are in front of floor-to-ceiling LED screens with live rendered CGI.

In old movies, going back to the 1930s and 40s, back-projection is usually seen when characters are driving in a car, and you can usually spot it. These days, not so much.

The alternative is seeing a news report that says "Sabotage by hostile nation and/or terrorists not ruled out!" - obviously the airline will do root-cause analysis and find out who screwed the pooch.

See also https://jyu.dev/blog/why-dev-null-is-an-acid-compliant-datab...

The great achievement of OOP is that it inspires such passion.

In essence OOP is just, "hey, if you have a struct and a bunch of operations that operate on that struct, let's put the name of the struct and a dot in front of the names of those operations and you don't need to pass the struct itself as an argument"

It beats me how either the high priests or its detractors get so worked up about it, even with the add-ons like inheritance, poly-morphism or patterns. (Which of course also exist in a more mathematically clean way in functional languages.)

These patterns have seen real use (not saying optimal) in the wild.

Of course we know today composition is better than inheritance, plain data structs are enough for most cases, and "parse, don't validate". but did people know it in 1990s?

You’re missing the depth of the difference. It’s not just syntax sugar for calling object.method() instead of func(object). The key distinction is what happens when the method mutates the object.

When state is mutable, every method that touches it becomes coupled to every other method that touches it. The object stops being a collection of independent behaviors and turns into a shared ecosystem of side effects. Once you mutate state, all the code that relies on that state is now bound together. The object becomes a single, indivisible unit. You cannot take one method and move it elsewhere without dragging the rest of its world along with it.

Functional programming avoids that trap. Functions are isolated. They take input and return output. They don’t secretly reach into a shared pile of state that everything else depends on. That separation is not aesthetic, it is structural. It’s what makes functions genuinely modular. You can pull them out, test them, recombine them, and nothing else breaks.

   # OOP version
   class Counter:
       def __init__(self):
           self.value = 0

       def increment(self, n):
           self.value += n

       def double(self):
           self.value *= 2

   c = Counter()
   c.increment(5)
   c.double()
   print(c.value)

Here, every method is bound to self.value. Change how one works and you risk breaking the others. They share a hidden dependency on mutable state.

Now compare that to the functional version:

   def increment(value, n):
       return value + n

   def double(value):
       return value * 2

   increment_and_double = lambda x: double(increment(x, 5))
   print(increment_and_double(0))

In this version, increment and double are completely independent. You can test them, reuse them, and combine them however you like. They have no shared state, no implicit dependency, no hidden linkage.

People often think OOP and FP are complementary styles. They are not. They are oppositional at the core. OOP is built on mutation and shared context. FP is built on immutability and isolation. One binds everything together, the other separates everything cleanly.

Mutation is what breaks modularity. Every time you let a method change shared state, you weave a thread that ties the system tighter. Over time those threads form knots, and those knots are what make change painful. OOP is built around getters and setters, around mutating values inside hidden containers. That’s not structure. It’s coupling disguised as design.

Functional programming escapes that. It separates state from behavior and turns change into a controlled flow. It makes logic transparent and free. It’s not just another way to code. It’s the only way to make code truly modular.

You can write these same methods in an OOP language like Java. You dont have to use classes for everything.

But alot of times, yes it makes sense to group a set of related methods and states.

You say this is not a natural way of thinking but I strongly disagree, it lines up perfectly with how I think. You are you, the car dealership is a dealership. You buy a car from the car dealership, the dealership gets money, you lose money, the dealership loses a car and you gain a car. I want these states reflected in the objects they belong and not passed around globally and tracked

Or if I am writing an API library, yes I very much want to 1. group all my calls together in a class, and 2. keep track of some state, like auth tokens, expirations, configuration for the http client, etc. So you can just do api.login, api.likeX, etc

Moreover, most methods youd write in a large project are so limited in scope to the type and purpose, this idea of some great modularity is nonsense. Its not as if you can have a single delete function that works on deleting users, images from your s3, etc. Youd end up writing bunch of functions like deleteUser(user), createUser(user), deleteImage(image), and wow wouldn't it be great if we could just group these functions together and just do user.delete, user.create? we could even define an interface like Crudable and implement it differently based on what we're deleting. wows

Ok simple question. Have a method called increment(n) on an object called tracker. It’s used to increment tracking id values.

I want to reuse the logic of increment(n) inside another object called childHeight to increment height values.

Can I import the method and reuse it inside another object? No. I can’t.

But if increment was a pure function thats like this increment(c, n) then I can move it anywhere.

That is what I mean by modularity. For oop lack of modularity is fundamental to its design. The grouping of methods around mutating state breaks modularity.

You’re talking about a semantic issue. Grouping methods by meaning. I’m talking about a logistical issue where the grouping by semantics cannot be broken even though the logic is the same. Incrementing height and incrementing ids are identical in logic even though the semantics are divergent.

That is the problem with OOP.

There are multiple ways to handle that.

Class Number {

   static Int inc(Int n) {
      return n+1
   }

}

import static Number.inc

Class Tracker {

    Integer height = 0;

    incHeight() {
        this.height = inc(this.height)
    }

}

class Tracker extends Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or

interface Number {

   default Int inc(Int n) {
      return n+1
   }

}

class Tracker implements Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or my pick

class Number { //or extend the Integer class and add your methods

    int num = 0;

    inc() { 
     this.num +=1
  
     }

}

class Tracker { Number trackingId; }

class Building { Number height; }

t = Tracker()

t.height.inc()

b = Building()

b.height.inc()

All OOP does is really give you a way to group state and methods, how you use it is up to you. There is a reason almost all big software is written this way and not in Lisp.

Do you see the problem? What you wrote is the problem with oop. Gotta tear your whole program apart and rewrite it. You had to create new things and rewrite your methods.

With functional you don’t rewrite. You recompose what you already have.

It means oop is not modular. You didn’t create modules that can be reused. Nothing could be reused so you had to reconfigure everything.

Take a look at the Interable interfae in Java if you want some good examples of reusable functions.

It enables map, filter, stream, reduce, groupby, etc on lists, sets, etc

or collections class which gives sort, min, max, replaceAll, etc

Sounds like a job for a block chain!

The problem highlighted here is that AI summaries misrepresent the original stories. This just opens a flood gate of slop that is 45% worse than the source, which wasn't stellar to begin with as you point out.

A whole lot of news is regurgiated wire service reports, so how reporters do matters greatly - if they're doing badly, then it's entirely possible that an AI summary of the wire service releases would be an improvement (probably not, but without a baseline we don't know)

It's also not clear if humans do better when consuming either, and whether the effect of an AI summary, even with substantial issues, is to make the human reading them better or worse informed.

E.g. if it helps a person digest more material by getting more focused reports, it's entirely possible that flawed summaries would still in aggregate lead to a better understanding of a subject.

On its own, this article is just pure sensationalism.

Yo, Taylor, I'm really happy for you. Imma let you finish, but Beyoncé had one of the best videos of all time.

I do not think that GP's comment was meant that way. GP simply wanted to clear up a misunderstanding that was apparently created by the renaming of this thread to "Greg Newby, CEO of Project Gutenberg, has died", which has been undone since. I am sure GP did not mean to detract from Greg Newby's contributions to the project.

I'm generally pretty good at figuring out even the most abstruse jokes, but not getting this one. Care to explain?

It wasn't that abstruse 15 years ago.

https://knowyourmeme.com/memes/kanye-interrupts-imma-let-you...

The difference, in my view, is that Taylor Swift wasn't being incorrectly given credit for Beyoncé's video.

ok yeah I knew the reference I just wasn't getting how they thought it applied here.

At one point this morning, this thread was about 50% posts by someone repeatedly pointing out that it wasn't the founder of Project Gutenberg who had passed away and being maybe a little precious about writing their dates with a leading zero.

Imo, it was a valid criticism.

On the award of her Grammy, Kanye West grabbed the microphone and said this to Taylor Swift. I think Newby is Swift in this analogy.

Edit: MTV Video Music Award, not Grammy.

Wow I can’t believe this happened!

I can't tell if sarcasm, but he was very drunk, and it became one of his first big scandals. He's had so many more after that it pales in comparison.

Just wait until you find out who won the US presidential election.

Firing a company's boss and appointing a trustee is uncommon, but it happens.

E.g. at IT service provider Centric, where the majority owner and CEO had a mental breakdown. Employees suffered from his delusions, but it also threatened to affect customers. The trustees aren't government agents, they just run the business as a going concern, minus the mismanagement (in this case, minus the mental illness).

US law also provides for a CEO to be ousted and a trustee to be appointed in cases of mismanagement or fraud. I wouldn't call that taking control, in much the same way as bankruptcy proceedings appointing a trustee don't amount to government taking control.

Now, the article refers to a filing made by former management. That filing is conflating the order and the firing of the CEO. The ministerial order didn't fire the CEO, that was a separate action filed by the company's works council and happened before the order was issued. The reason for the firing lies mostly in mismanagement and conflicts of interest.

The ministerial order is much more limited in scope, allowing the government to roll back decisions detrimental to the company - especially transfers of assets.

It's a shame that CNBC is just parroting the former management's objections, rather than you know, doing any reporting.

In both the order and the legal case, it's clear the ownership/management wanted to shut down the company and take the assets. The company was also not doing OK financially, and this kind of thing reeks of bankruptcy fraud (i.e. fraudulent conveyance).

The kind of tech nexperia makes isn't rocket science but I could imagine they produce some chips that are used in essential supply chains. So rather than wait for the bankruptcy and the fraud to happen, the company was restricted from transferring assets.

So the wording "takes control" is misleading. "subjected to additional oversight" is perhaps too wordy but more accurate. "put on a leash" might be a good way of putting it.

Thanks for doing the work I should have done :D

That's very helpful.

EDIT: is this behaviour common with Chinese companies in Europe? Do they buy to lead companies to shutdown?

There are some databases with spending habits, so you can compare your spending to folks with similar households, and some prudent guidelines. But it's not rocket science and a bit silly. You don't really need to remind sneakerheads they spend more than average on shoes, or pennypinchers that they spend (too?) little.

For most people just keeping tabs of spending helps them reign it in. Setting up auto savings and pension contributions also helps. The next step is using cash to pay for discretionary spending - not more automation.