skysight-inc/HackerNews huggingface dataset:
A lot of OOP languages have added method references, and lambdas in this day and age.
Or just make your root file system read-only. Running off an initrd greatly limits your filesystem size.
You're describing the Anemic Domain Model which is quite useful.
You can't be suggesting that the first time someone attempts to do something like this on a large scale, that Mullvad's team would be surprised.

You surely can't be suggesting that this didn't come up in meetings, and that the opportunity cost wasn't determined and taken into account when offering this trial service.

The painlessness of the service, along with the encouragement to generate as many new account numbers as needed while testing, along with allowing full feature access without throttling, meant that I generated two weeks' worth of trials before finally deciding Mullvad was right for me.

But now I know they are right for me, and as I said in an earlier post I am now a customer for life. As long as nothing changes, that will remain so, and I will, as I am now, frequently proselytize their service and encourage others to try them out for free. I'd say they calculated the opportunity cost correctly.
Make sure you're not using an operating system that would be unpopular among the IP block you're VPN-ing through. Also, better have the same browser, screen resolution, fonts installed, ...
I would agree with the substance of your comment if the form wasn't as childish as the old meme of replacing S with $ in various tech companies ...

I've had a lot of issues with IKEA bed slats. It's a shame because the beds themselves are great.
No true Scotsman.

>Because it's easy

There are lots of cases when forcing yourself to stick to OOP styles or programming is much less easy. You could look at various comparisons of code line counts of equivalent programs between C# and F# code as some basic examples.

I don't mind having classes that can inherit available in a language, but languages like Java and C# that force you to use only those things leads to a lot of unecessary boilerplate. You can work around this with static classes full of static functions that you can treat as 'modules' full of free functions. Which, is what I do a lot :D

But I wish I didn't have to bother with that workaround.
The one (stupid) feature
your neighbor's roommate could have searched for and viewed your linkedin profile if he knew your name, prompting a suggestion on your end.
>You'll start wondering if Weapon should inherit from the player base class.

Probably not. If you want to do that, they should both implement an interface (and perhaps share some code through composition) but code inheritance is likely not the right approach here.
> If you have different players who use different hit strategies how do you handle that with just a pure function? Lots of if statements in the function? Passing in lambdas in every case you call the function?

I'll list a few strategies I've seen in different contexts:

1) Clojure has "protocols", which is a strategy of doing polymorphism where the verb is charge instead of the noun.

2) Rust has trait objects, where you have to implement the polymorphic behavior you want for a separate player type but the data is separate from the behavior and not interlinked or owned by the class. You can implement the behavior in the scope of the module where it is used.

3) You already mentioned this, but lambdas in Javascript or functors in C++ satisfy a lot of specialization requirements.

All 3 of these approaches are different ways of approaching the problem of different behavior on the same data. The key thing with them is that it allows domain specific behavior to be decoupled from an owning object. There may be reasons that OO is more suited to a problem (as you mention), but I tend to agree with the author's post around the dogma of using OO everywhere.

In the article, the author also mentions a quote around encapsulation

> Encapsulation is an object-oriented programming concept that binds together the data and functions that manipulate the data, and that keeps both safe from outside interference and misuse.

In my opinion, this view of binding the data and behavior together stems from an idea that data is scary and can be changed at any time. In an immutable, pass-by-value, functional world, those getters and setters and indirection is just another thing in my way from composing the data together with collections tools I am very familiar with. I think it was Neal Ford who said that "OO encapsulates moving parts, whereas functional programming removes moving parts." I think that's very appropriate in this context. In a data-first view, you model what properties and data shapes you care about in your records, and then you create little functions that connect those things together; in OO, you create the links first through methods (even if those have interfaces), and you're stuck with those connections anywhere you want to pass the object.
Their app also periodicacally asks you to upload your phone contact list for them. I'm glad Apple have a clear warning message they obviously can't circumvent because the LinkedIn UI makes it really easy to accidentally trigger it in a few places.
Negligible? What evidence do you have for that?

We build quantum computers where? On a planet? That has? Gravity. We have a star that also creates? You mean to tell me that gravity will bend light with 0 mass, but it won’t interfere with an electron? Or atom?

I’m open for debate, show me some papers or blog posts on how gravity doesn’t interfere with a quantum gate? Look at the moons gravity and our oceans.
Read up on how blue light + retinal can knock out photoreceptor cells. Especially in your 50s and 60s. When your immune system goes downhill. You can reduce the amount of blue light on your smartphones and monitors.
Refactor, with the right IDE this should take minutes. OOP witbout something like intellij or VS.NET is not fun.
That sounds like something out of the Dune universe.
Patterns for microservices architecture
I can't speak for smalltalk but the actor model in erlang (but especially in elixir) is a joy.
It's maybe confusing because you are presupposing OOP as the default. Humans tend to observe some situation and sythesize stories to explain it, even when it comes to observing their own actions.

I don't mean to unfairly paraphrase but to transpose what you wrote so it shows these stories you are telling yourself

- usually people criticising OOP are "bad programmers"

- OOP is easy, alternatives are hard

- Even if OOP model is a bad fit, it's still a model and the extra devs needed to solve its bad fit can easily be chained to the oars

- If OOP makes trouble, it was because it was "done badly"

- Most easy things work well enough even if "done badly" (that is just not true)

- If OOP can be cobbled together to work at all, it is justified since that justifies anything

If you consider a simpler proposition like, "this can be done in a few hundred or thousand lines of C99 instead of latest C++ and boost", I think there is just no valid reason to bring OOP into it.
> it has to be there

No it doesn't. For example, for single bit of precision, saturated addition is bitwise or, saturated subtraction is bitwise andnot. Obviously, the electronic doing these bitwise operations do not use any extra bits. Similarly, for higher count of bits, the electronic doing the math may or may not have that extra precision.
I disagree. SICP says "“In programming, we deal with two kinds of elements: procedures and data.” If we reduce that further it is really just data.
I've been programming for 15 years (so I was around for the rise of OOP). There's nothing fundamentally wrong with OOP. I still write a lot of classes. But what I haven't written in a almost a decade: code with inheritance, encapsulation or polymorphism. Nothing has exploded.

Also, objects are best when used to represent actual objects (i.e. collections of data rather than collections of functions).

This is OK

User user = new User("John");

But this:

StringTokenizer st = new StringTokenizer(str, ",");
while (st.hasMoreElements()) {
System.out.println(st.nextElement());
}

Might not be as clean as:

stdout(tokenize(str, ",")); // functions are hypothetical
What does OOP has anything to do with your IDE. I think you are referring to typings
Psychedelics helped me a lot but I'm in a good place today where I only vape a little weed. No drinking or smoking. Cutting down on porn a LOT! Still hard to completely avoid to be honest until I have a steady again.

I am starting to just lay out everything in front of me as a CHOICE. I can feed the side of me that is a world-class designer and a sincere servant to society OR feed the hedonistic self-destructive megalomaniac that will probably die unfulfilled.

Pretty easy choice when I lay it out like that...
If someone abuses people to get ahead, the answer isn't to allow others abuse people in the same way, in the name of fairness.
Not really. Almost no one would call erlang or elixir an Oop language, but one basically does everything using Kay's style.

No true Scotsman doesn't apply when the original definition legitimately shifts
On the reproducibility of Perturbative Neural Networks, in response to Reddit
No I haven't but I appreciate the headsup. It's been a few years since I even looked at anything on Azure in all honesty.
>Computation itself is the most important aspect of computing. Code and data are just complexity to manage.

Of course you're gonna write some computation, else there would be no program. That's not the point here.

First, author doesn't mean "data" as in what comes in, it means the data structures of a program.

Second, for the purposes of designing a program (and its computation part) data structures are a better guiding principle than objects. That's the argument being made.
Hehe OK, I'd imagine that would be very confusing when it didn't work.
I'm pretty confused by how you perceive this. I don't see "crap boilerplate supporter classes" – I see objects that encapsulate events and actors for all the usual OOP reasons.

I wonder if some of this disagreement is down to the way that different people abstract this problem in their heads.
>- Because OOP requires scattering everything across many, many tiny encapsulated objects, the number of references to these objects explodes as well. OOP requires passing long lists of arguments everywhere or holding references to related objects directly to shortcut it.

This drove me nuts too - it's the exact opposite of what OO design suggests to do. See: https://en.wikipedia.org/wiki/Law_of_Demeter
The users of a cryptocurrency are able to ignore the 'legal ownership' rules, though - they implicitly opt-in by using the system.

This is the key distinction between actually using _Bitcoin_ (i.e. running a full node and creating transactions), and using custodial Bitcoin (outsourcing it all to a third party using legal constructs).

If you're saying that the users of the cryptocurrency can't opt-out of the legal system - sure, no-one can opt out against men with guns (in practice what ends up happening is everyone hiding under pseudonyms and introducing a whole bunch of friction in an attempt to do it anyway).

I suppose my comment is intended to illustrate that this is all a sort of shell game played by non-participants.

Essentially, lawyers trying to glue themselves onto and extract consulting fees or whatever from a system which does not require them.

Repeated again for the sake of clarity - if men with guns ultimately decide transactions on the blockchain, the entire system is pointless. We can just delete it. We don't need the horrendously expensive resolution mechanism of PoW in that case, because there's already a resolution mechanism, that of men with guns.
AdaFruit's "Powerboost 1000 charger" is not cheap but it's very good and also has USB power pass-through pin, in order to detect power failures. However you will need a 5V-3.3V level converter to feed it to the RPi's GPIO pins.
It’s a very serious area of research. Are there any good solutions in the literature to collusion-resistant voting and reputation?

Something like hotornot is voting resistant because it shows RANDOM photos so it would take a lot of effort and time for people to collude to upvote a particular photo.

But that is a site about one topic: hotness. How do you get people in smaller forums rate eg the strength of an argument without causing people opining on stuff they have no idea about (eg career politicians or chess fans rating claims about molecular biology).

I am seriously interested in building a site where each claim is debated exactly ONCE - you come and either upvote a pro/con argument (which itself rests on other claims) or submit a new one, and it would use Randall Munroe’s ranking system for display.

The idea is to make people discuss the truth or falsity of each claim once and for all. Politics, religion, news etc.

I can see how evidence ca accrue, eg if a video of an attack in Yemen is uploaded, it would join a growing list of other videos claiming to be accurate representations of this event. Each video should be kept. But which woukd be upvoted? What if some are doctored and heavily upvoted in a coordinated attempt by “sleeper” accounts that behaved well until that point? How would HN detect it?

Believable fake videos are not (yet) able to be produced. But fake photos already are. And other claims can be pure garbage. Fake news of all kinds has permeated the Web. I have often said that our systems have been designed to rely on the INEFFICIENCY of an attacker, and that needs to be changed in the next systems we design.

Voting is one of those. I understand how to make voting secure private and verifiable with Merkle Trees. I don’t know how to prevent collusion.

And any site which purports to bring everyone together to determine “truth” becomes a honeypot for disproportionate efforts to game it.

How does Wikipedia stay relatively good? At least as good as Britannica? I would love to more collaborative (open source) instead of competitive (capitalist) systems for software, news, drugs as it is for science etc.

How does science do it? They don’t, sometimes.

When it comes to centralized beliefs about truth, whether it’s who owns a token (preventing double-spending) or whether Gandhi “really” said that quote or whether Tienemen square really did happen, what is some literature about consensus about REAL WORLD (not electronically verifiable) claims that actually can’t be gamed so easily?
Real People Eat Quiche
A funny example of this in practice happened a few years ago during the United Airlines and Continental Airlines merger.

When they switched computer systems, somehow they switched the method they used to calculate the distances between cities for their frequent flyer program. Before the merger, both companies used the ellipsoid method. During the computer systems cutover, the method suddenly changed to a spherical approximation. They also used an incorrect

The difference resulted in shorting flyers of a few (I think the most I saw was 40) frequent flyer miles per leg. They got caught within a couple days and 'fixed' the 'accidental' change. One of those things they seemed to hope no individual would catch but that over many many flyers would add up to a significant cost savings.
Why is color of a car an issue with OOP? Without knowing your the use cases, neither of us will model it correctly for the job at hand.

A car obviously has multiple colors. It has at least two: exterior and interior. Quite often there are two-tone colors. But as a manufacturer, I'm going to guess that each interior and exterior color scheme has an ID. If you are a car manufacturer, the interior and exterior color scheme ID would be all you need.
How Just Opening a Site in Safari Could Have Hacked Your Apple MacOS
Tim Cook Calls for Strong Privacy Protections
I will concede that gravity may not be a physical wave but a ripple in dark matter, that ripple would essiently by the interference pattern. Like lanes in a highway of dark matter.

Gravity can be caused by combined vibration of an element. Think about quantum fluid. We see a big correlation between the micro and macro universe.

So if the earth has a frequency that means it vibrates, that plus mass can equal the effect of gravity. Though that is still a rough idea.

Gravity is still a mystery until we can detect it.
How to Shop Online Like a Security Pro
>I'm talking about simple, procedural hit(monster, weapon, damage).

The moment your game needs to know anything else about that hit event, you're going to start creating side effects from that procedure and that QUICKLY snowballs into spaghetti code. Not to mention, just from the signature, that's going to be an absolutely huge procedure.

>Because it's not worth the effort. You won't notice any difference in speed. Be pragmatic.

That's the exact same case I'm making. A hit object every so often will have no impact on performance (certainly not a huge impact) like you originally said and you gain developer productivity.
Searching and sorting text with diacritical marks in JavaScript
In Canada, most mortgages have to have their rate renegotiated every few years. For example, mine was amortized over 30 years, but on a five year rate. When five years are up, I have to renegotiate an interest rate. "Renewing" the mortgage.

This has interesting properties economically. It's a bit like a floating rate in that it will change, but like a fixed rate in that you don't have to worry about next month having an unexpected high bill. The banks give better rates because they only have to estimate the near-future and not the next 30 years.

Big question: what happens when all the people who could barely afford their mortgage five years ago come to renew with rates higher?
I didn’t try to forget OOP per se, but I slowly adopted the authors guidelines regarding a data first approach. Now most of my objects are just wrappers around data, rather than analogies to real world objects.

However I mostly am working on web apps so maybe this approach is more suitable to such apps.

When working on desktop apps, during my initial days as a programmer, I found OOP based ui systems easy to grasp, but then this could be due to lack of experience.
At least 3 satellites failed because of the radiations, https://en.wikipedia.org/wiki/High-altitude_nuclear_explosio...

I can relate with the scientists that worked on this satelites, send them in space to collect data and 2 weeks later the americans destroy them because they want to try nuclear bombs in every possible place.

https://www.youtube.com/watch?v=zmCe0GeCwA0
"One must never change the order here!"

This is presented as a basic truth and then not really backed up, as far as I can tell. Why must I apply the order as the author believes?
Did you take psychedelics in a clinical setting?
Show HN: Icon Transition Generator
>I don't see how this is a problem unless you think programming objects correspond with physical objects.

This is a problem because we don't just want "any old design that sorta kinda works" but a guiding principle to our design, and to find the optimal place for each action/data.
You seem to be translating a modeling failure into an indictment of the whole object modeling paradigm. Your car model doesn’t account for multi-color liveries? Revise and refactor the model. Adapting to change isn’t the same as falling apart.
A language has 2 main purposes:

1. communication

2. representation of concepts

1 is pretty obvious, and for a programming language this means communication between a person to a computer

2 might not be as clear, but if you know that people cannot count in languages that have no numbers, it becomes obvious. There is a tribe that only has 0, 1 and many, and guess what, they can't tell the difference between 7 and 8.

Now back to programming languages and their communication between computer and programmer: the old programming languages were very close to the computer. As languages evolved, they started to be become 'human', where it is easier for us to read and write them.

OOP in that sense leans very close to concepts of normal humans. Objects, things objects can do, objects have separate responsibilities, etc. It's easy for a human to have such a model inside his head, because we already do this every day.

Now as a programmer, most of the things that I need to do is make a representation of the real world into a program. Since the real world is made up of things that do stuff, it's easy to model it in such a concept.

Most arguments against OOP always come from either a theoretical or academic background.

But in the real world, with real companies, real problems to solve and real programmers, OOP is used. Because it lends itself really well for representing the real world in a computer model.

EDIT: not saying that anyone that doesn't use OOP isn't a real programmer. But those people are more into the algorithmic or mathematical problem space, not a problem space where a real-world concept needs to be modeled. Most software is like the latter, and therefore most programs are OO. Is it the best solution for everything? Definitely not.
Indeed: here's a recipe and discussion of protein levels from 11 years ago that talks about White Lily and how to substitute a mix of cake flour and bread flour (and what amounts of baking powder and soda to add to become "self-rising")

http://pinchmysalt.com/how-to-make-the-best-buttermilk-biscu...
> Imagine there are hundreds of ways Hit can be implemented and used in different situations.

This is the typical argument you get to hear from OOP apologetists. And the codebase is rotting, just for concerns about hypothetical problems...

I remember one time when I was criticized for putting in too much global data and not enough classes "because what if we have two GUI instances?". The guy of course had no idea why he would want that, and how it should work.
Not at all. It also has excellent visibility, extensibility, and debugabillity.
Learn How to Use Vuex by Building an Online Shopping Website
> Complains about logical fallacies

> Immediately comments with logical fallacy.
Teeth Tell the Story of the Early-Human Diet and Our Own
If the classes are shallow that's fine. The problem is using classes to model the whole behavior, not using them to hold some values together.
This idea was extensively discussed here in 2016: https://news.ycombinator.com/item?id=11354021
(monster, weapon, damage) is "the object". And yes, the procedure probably has "side effects". Because that's the point.

> Not to mention, just from the signature, that's going to be an absolutely huge procedure.

How do you intend to write less code with OOP?
It's not. It's serious and sad. I remember a news article from a few months ago that exactly mentioned (and made fun) of this paper.
>Can you provide references for proper OOP?

Joshua Bloch's "Effective Java" is well worth a read. He outlines specific principles like "Favor composition over inheritance" (https://medium.com/@rufuszh90/effective-java-item-16-favour-...) in just a couple of pages each.

I also want to strongly recommend Martin Fowler's "Refactoring" since it covers a lot of "good" OOP design and gives practical advice on how to take bad code and make it better.

The original "gang of four" "Design Patterns" book is also pretty good, although definitely less practical than the other two.