This is such a broad generalization as to be useless. I use several pieces of software that are around $10/month which there’s no way in hell I would pay $50 for.

I'm not writing from the POV of a consumer of software. I'm writing from the POV of a seller of software.

If you are selling software, don't be the person charging $10/month. It's hard to make that business work.

Be the person charging $50/month. It's still hard - any business is - but it's much easier to make a software business financially viable if you charge decent money.

Advent is a liturgical season, not a set of 4 Sundays. Neither 4 nor 25 are "in the name."

I’m a rubyist, but how is message passing fundamentally different from method calling? I get that method_missing adds a twist, but your comment doesn’t explain what the fundamental difference is.

Especially in the context of Fixnum#times. How does message passing vs method calling matter there? #times is just a method on Fixnum.

Because it leaves it up to the object being called what to actually do with the message. The object you're talking to might be forwarding its messages to another object in another ruby instance on another machine (if the current machine is getting fully loaded, etc), and the caller would be none the wiser. And crucially, the caller wouldn't have to be modified to enable this. The logic for this would be entirely within the object being called.

So the difference isn't just with method_missing.

With "method calling" as you put it, the program blows up if that object doesn't have that method, WHEN YOU CALL IT.

Basically, this smalltalk oo paradigm is about shifting where you put more of your logic. At & around the "call" site, or within the object whom you're calling & entrusting to do something useful with it.

All hearkening back to Alan Kay's original ideas about biology influencing how we organise code, and having a program be 1000's of "little black boxes" where work gets done by all these boxes talking to each other.

Which is why smalltalk (& ruby implements the Smalltalk object model to its entirety) actually has an awful lot in common with Erlang & other BEAM runtimes, even though those are functional languages. Because once you get beyond the techy buzzwords, the main ethos behind them is actually quite similar.

I guess what I’m getting at, is that I don’t understand how the difference actually informs anything concretely, as in the example of Fixnum#times, where this discussion started. Why is it super important to understand this fundamental difference?

Fixnum#times isn’t a great example, I only used it since the parent used it to illustrate their confusion and quite frankly a concrete useful example is to complex for this format.

ActiveRecord has changed a lot over the years, but as an example in the original ActiveRecord you used dynamic finders. None of the finder methods existed initially, but if you passed a message to an active record object for a non existent method rather than fail it would determine if that should be a method and then it would build and persist a method to the process for future calls.

It allows for some really interesting and powerful applications in horizontally scaling as well.

> I’m a rubyist, but how is message passing fundamentally different from method calling?

The difference is fairly subtle most of the time in practice, which is why dynamic OO languages like Ruby that use message passing can mostly look like OO languages that use method calling, though it is significant behind the scenes and opens up a lot of possibilities; one of the more obvious practical differences is that it is why Ruby can capture and handle unknown "method calls" via "method_missing", which works the way it does because the version of __send__ defined in BasicObject looks for an existing method matching its first argument in the object's inheritance chain, and if it finds that calls it, and if it doesn't find one does the same thing with the "method_missing" method.

There's a lot that can be built on top of this, either leveraging method_missing or more directly.

Though I think the more relevant issue upthread isn't message passing vs method calling but narrow vs broad conception of nouns/agents.

I guess if the target audience is people who already know what it is?

That's an absurd comparison.

At the time there were dozens of search engines and new ones every day. Everybody knew what search engines were, and what they offered. Google did not invent the form field -> SRP pattern; people were already used to that. Google was able to rise above the field because 1. yes the homepage was nice, but more importantly 2. the results were so much better than competitors.

I don't understand the comparison to SQLite online because what are the well-known competitors, and what is it even trying to do?

Not even going to touch the ChatGPT comparison.

This is accurate. Back then nobody went to google and was confused when it was just an input box. They went there already knowing it was a search engine and that search engines needed input. They came back because the results were so good (relative to competitors).

The clean interface just stood out as the other competitors at the time we're bogged down by ads. So a quick loading page in a time of slow internet connections, was a very nice user-centric feature.

I think that would be the power of Elixir and the BEAM.

They make some pretty beefy battery cases.

This is a tablet. Are people predicating their bitchiness on what kind of screen it has?

Is there a web browser and social networking on this 'tablet'?

You're using a very literal definition of tablet that seems more argumentative than constructive. Care to try rephrasing?

Yes, that is correct.

I don't see how any of that implies that an incumbent did it.

If you were a criminal trolling the Internet for vulnerable servers and found stripe keys... would your first instinct be to refund customers rather than do some other sort of crime? Like what's the motivation you envision here?

"Because I can" or "Because it's funny" are more than enough reason for most people. The fact that the hacker refunded all the customers, then emailed them to warn them that they were using a terrible app actually sounds like a pretty tame troll to me. If the hacker was truly hired by the competition to act maliciously, they could have done far, far worse.

Your friend should take this as a lesson instead of trying to deflect blame to their competitors.

> Because it's funny

I think you mean “for the lulz”

There are black hat hackers that take great joy in just causing as much chaos as possible, particularly with such vibe-coded apps. Even with stripe keys, it's not like they could direct money elsewhere.

Maybe a blackhat hacker decided that the software was so shoddily built that the company didn't deserve to continue existing, and decided to try to make that happen as a sort of vigilante justice against crappy vibe-coded apps.

Definitely not a good idea but it's not an unreasonable motivation.

Some people just want to watch the world burn :shrugs:

Fun and internet points!

I use Zed too, and as a longtime magit devotee, I've really been enjoying using gitu [0] in Zed. gitu doesn't have everything magit does, but there's not much I find myself missing.

I have it nicely integrated with Zed by defining the following task, which you can then add a keybinding for if you want:

    {
        "label": "gitu",
        "command": "gitu",
        "reveal_target": "center",
        "hide": "always",
        "env": {
          "VISUAL": "zed",
          "GIT_EDITOR": "vim"
        }
    }

[0] https://github.com/altsem/gitu