skysight-inc/HackerNews huggingface dataset:
OOP is here to stay because it is the default model of how we see the world. You actually do not have to teach people to use this, just how to map it to the OOP Software Systems like Java/ C#.

It was great while Moors law still lasted, and to write efficient software was becoming some strange quest for some formula one fields of software like games or other massive workload fields like OS-Wizzardry.

Today, the massive workload is still growing, due to sloppy architectural habits and user demands, but the saviors of parallelization and new chip technologies have not come to rescue the sloppy-devs from the laws of leaky abstraction.

Your code runs on a hardware system.

And currently your code is running out of hardware.

And with that OOP is running out of excuses.

So you would write this.
Then it would three months before the shipping be handed to some adult- and this adult will delete it.
All of it.

Its full of references, full of class-bloat which will push one another out of the cache.
Even though the compiler will try to yank the worst out this mental crutch out of the code. Some references can not be dismissed deterministically, so they will be kept.
Which makes it incredible slow.

What replaces it will be a efficient structure, keeping all the chunks necessary for collision detection, in one very array like field.

Over this a Algo traverses, acting with a function, which does not reference non-local stuff, detecting collisions and damage. Allowing not only for a few players- but a workload of players.

It will look very ugly, like C, with inline assembler- ugly, and it will be ready to ship.
U.S. Supreme Court to hear Apple App Store antitrust dispute
> I would be unlikely to submit a pull request until I was reasonably sure that it was welcome and and that the person receiving it would be a good person to collaborate with.

The person you collaborate with do not owe you anything, and it goes both ways. If a PR is rejected, then its author is free to fork the project. But you can't have it both ways, you can't complain about people potentially abusing issues then think there is a special technique to limit the problem, while keeping an issue tracker opened, because there isn't.

Closing the issue tracker will ensure only people capable of fixing issues will collaborate to a project.
Why wouldn’t you?

C# is so unproductive compared to python. Everything is so low level and verbose, nuget packages are mostly undocumented and unsupported, entity framework is terrible, no graphql tools.

I mean, we still do a lot of c# at our place, but every chance we get, we use either python or JavaScript with an end goal of completely leaving c# behind.
I guess I should preface this by saying that I'm not being particularly trained in this; I've skimmed Tufte, but that's it.

To me, the interesting thing about it is that it captures both the utilization of two dimensions of the paper/screen and the representation of a one-dimensional quantity. Humans are notoriously bad at intuitively translating among quantities of different dimensions, e.g. translating the area of a circle to a population.
I’ve been working on breathing through my nose more over the last few weeks. One area where I’m noticing improvement is better sleep. When I used to breathe through my mouth I would dry out my mouth severely multiple times during the night. This possibly reduced sleep quality because I would roll over to drink a glass of water whenever the dryness got uncomfortable. Maybe it was increasing dehydration, too.

I resisted breathing through my nose because my left nostril seems slightly deviated. Forcing myself to breathe through my nose while I jog or do yoga seems to help. My hunch is that the nostril is just closed up a bit from lack of use.
Okay, so how would you model that in a different paradigm? And why could OOP not model that the same way?

Your example also doesn't specify a business context. What kind of software am I building such that I need to model a car and it's color? That simple question will entirely change how the OOP model is designed.

OOP is easy to teach because it's easy to use, to understand. But again, if you use simple poorly thought out OOP, it may work- just badly. And of course there's the problem of "those who can't do, teach" and often those teaching programming are poor programmers.
It isn’t uncommon, nor is it bad design to define value classes that represent simple actions. This enables the action/command/event value to be reified, serialized, transmitted over the wire, deserialized, and potentially processed remotely, asynchronously, or by multiple arbitrary consumers.
In the real world?

If I’m programming in a monolith, I change the Color property to a List and I get a big red dot with the number of errors the change caused in the bottom of my IDE and it tells me all of the places I need to change the code.

If my car class is part of a Nuget package. I change the version number to represent a breaking a change following the standard semver semantics. When the consumer upgrades to the latest package, they either get warnings about Color being obsolete and use Colors instead or I just completely remove the Color property and they get a red dot and change their code or decide they don’t have time and keep the old package around for awhile.

If I’m writing an API, and since I did properly separate my domain model from my view model, I both map the first item in the Colors list to the Color property in my view model and I create another Colors property.

These are solved problems.
My brother is a retired Inspector who did many child pornography and abuse cases. His IT guy did many searches and indexes of computers full of child porn. I’m happy to know both of these people.
It's not connected to anything, so probably not. However back when we used purpose-built electromechanical switching systems for telephones, people exploited them[0].

[0]https://en.m.wikipedia.org/wiki/Phreaking
> You could look at various comparisons of code line counts of equivalent programs between C# and F# code as some basic examples.

People have done this methodically, and the results may surprise you:

http://www.cs.bsu.edu/homepages/dmz/cs697/langtbl.htm

That's the one from 1996, there was a newer one that pretty much confirmed the results.
iterative code

That was a typo of "imperative", sorry.

But I notice OO is unique in that "you don't understand it" is always the main defense

It's really, really not. This kind of argument comes up in a number of places, and I think there's a commonality – it tends to appear where systems are flexible, open-ended, and easy to start using, such that people tend to pick them up without thinking about how and why they will be using the tool. You see the same thing with "agile" for example.

OO isn't complicated. At the most basic level, it's just taking a data structure that you might use in any other programming approach, and attaching functions to it as methods. Go is object-oriented in this sense, for example.

Problems arise when bad implementations of OO concepts appear – but pointing at say excessively-enterprise Java and saying "this is evidence that OO is bad" doesn't really hold any water.
I’ve been a bit wary of Revolut after it turned out they were making potential job applicants engage in an MLM to secure an interview: https://twitter.com/mellino/status/1054473108936122368?s=12
Interesting article. Though, the article should provide alternatives and speak to how use other types of programming paradigms might solve the issues that the person in the article is stating.
I agree. Even in Domain Driven Design, sometimes you just have transaction scripts. Call a spade a spade and write your code accordingly.
> You end up with:

> Player.hits(Monster).with(Weapon)

I think games are a particularly pathological case for OOP, and as such probably not a good example for the article's case. But FWIW, the problem with what you describe (and with OOP for games generally) is that game logic tends to be way too polymorphic for code like that. That is, players don't just Hit() monsters, they also hit items, traps, breakable terrain, etc., and they get hit by monsters, by projectiles, maybe explosions, fall damage, etc.

And the dilemma of doing all that in OOP is, you find yourself with 20 different things that can receive a Hit(), that have little in common otherwise. Some have hit points but others don't, some don't have an armor value, some need to receive knockback but others don't even have a physics body, etc. As a result, do you make Hit() accept 20 different types, with special cases for each? Or do you rejigger your class hierarchy so that those 20 classes all inherit from Hittable, etc? Either could work in this or that case, but neither's much fun.

This is all why ECS (or other aspect-based approaches) are so popular for games - they let you define very general "Hit(src, tgt)" chunks of logic, that don't care what type each object is, but can easily query whether or not they have hit points or a physics body.

But again, I think games are a pathological case here and none of this should necessarily be considered an argument against OOP generally.
Why do you want WPF or windows forms for your application? Especially if you’re doing a web based backend any way.

I know it’s a tad silly to use web uis for everything, but the truth is, that it’s where almost all of the ui innovations lie right now.

It’s not just for design either, it’s also automation. Like if you use Django, a lot of the basic forms for inputs will actually write themselves based on you’d datamodel.
OOP in that sense leans very close to concepts of normal humans.
Objects, things objects can do, objects have separate responsibilities, etc.

This is not entirely accurate. Human languages are closer to functional languages: they have verbs that operate on nouns. Verbs are not attached to nouns, but rather, the operation of the verb is dependent on the noun.
I wish the US could have the level of European HSR.

We’ve spent 50 years explaining why it won’t work here and widening highways. Now to even acquire the land is incredibly expensive.

Now our dream is to go 700 mph so we can take the long way over cheaper land instead of directly at slower speeds.
As a non-OOP-thinker, this seems completely natural to me. The verb hit doesn't belong completely to one noun, so it shouldn't be forced to live within the struct/class with the data (which really is about only that noun).

What problem is solved by forcing the function to belong to one of the actors, as in joe.hit(tiger).with(sword) or something? People say things about encapsulation, but it seems here that hit may change the state of Player, Monster and Weapon, so their states can't be fully private. In this code you can also have hit(p::Player, w::Door), if this were not allowed then perhaps you'd have to have separate hit_player_monster and hit_player_door functions... is that the problem?
First flight of ion-drive aircraft
OO bugs that I see are actually in the “invisible” parts of objects, as these require more experience to know what is really going on. For example, failing to implement necessary operators (or worse, implementing them in ways that are subtly incorrect). Knowing how to implement object “glue” properly is something that just doesn’t come up if you’re using simpler programming styles, and in cases like these it’s better to pick the simplest and most maintainable approach that will suit the task to avoid pitfalls.
On top of that you can order multiple physical cards for free on the same account so if one gets stolen you take the next one out and keep going. Needless to say you can disable the stolen one without having to call anyone.
> Biometric IDs seem to be about as close to a perfect identification system as you can get.

This seems a massive assertion that’s not qualified at all in the article. It was my understanding that biometrics in consumer hardware have always been easily circumvented and are largely about convenience.
What do you mean?
The link takes you to the README file which contains usage example and instructions. And you can find the source code in "s3upload" file.
I use 4, and it's not difficult to remember, for anyone worth chatting to.

You just naturally remember, like you would remember where your friends live. I guess if you are constantly dealing with "contacts" rather then friends it would get confusing.
i wonder if you can just chop up 50 fingerprints an feed them to https://github.com/mxgmn/WaveFunctionCollapse
https://www.gnu.org/philosophy/words-to-avoid.html#Intellect...

https://www.gnu.org/philosophy/words-to-avoid.html#Piracy
I was about to reply in C# that would usually be done with LINQ, but then I realized I kind of just proved your point since LINQ is functional programming not OOP....
Oh yeah, I forgot to mention that. They also have single-use disposable virtual cards which is pretty handy!
How an eerie abandoned US base near North Korea turned into an art haven
It's a good example of why multidisciplinary research is essential though
IDK about "any public blowback"...income tax was and is very unpopular.

It took an entire constitutional amendment before it was adopted in the U.S.
Would be nice to see some MS projects become open source if they are serious. Edge?
Where are these mantras from?
> At its core, every software is about manipulating data to achieve a certain goal

> This part is very important, so I will repeat. goal -> data architecture -> code.

Wait, what? No. That isn't what you just said. You said my goal was my goal and manipulating the data was the way to achieve that goal.

Take Shopify. They had a goal: Make a ton of money by running ecommerce stores.

They used OOP. They IPO'd and they're doing great.

You can argue all you want about how they would have done better if they'd done some other programming style, but the reality is that almost every startup that I see win in fields like Shopify's (where there are a ton of different concerns with their own, disparate implementation specificities[0]) do so with OOP codebases.[1]

In large corps like Google non-OOP with typed languages like Go might work great. Streams of data and all that. But for startups it's too slow. OOP is agile because you get some data and you can ask it "what can you do?" and you can trick functional or logical programming languages into kinda doing that too, but they do it poorly.

[0] Even wording this in a non-OO way was a stupid waste of time. I could have just said "different models and methods" and 99% of the people here would have nodded and the 1% would have quibbled.

[1] Some startups like WhatsApp are a bit of an exception, but even YouTube used Python.
Posted 19 days ago: https://news.ycombinator.com/item?id=18383553
> You want to know why OOP is useful and common? Because it's easy.

Try rewriting that without adjectives. Engineers are very convincible, but they need evidence. Personally, I don't find OOP to be particularly useful or easy.

Check this out... "I became a much better programmer when I started writing functional code. Now I tend to write OOP code in a functional way, but learning how to do that was and not easy, and I am not sure most would find it useful." By saying that, I'm basically taking a position that's the opposite of yours, and while it's true to me, it provides no evidence for you to help you evaluate my side of the conversation.
No. Not dynamic. The best way is to use Common Lisp.

I don't know if there's consensus for other, lesser solutions. Stroustrup seems to think C++ just isn't good enough[1], but good ol' function overloading is good enough for the cases we're discussing.

[1]: http://www.stroustrup.com/multimethods.pdf
In a "more normal" society, in times of famine, people rebel and kill their leaders. That's kind of the "healthy"/correct thing to do: even if you die trying to kill your leaders (no biggie since you likely would've starved anyway), in the end someone succeeds, they get replace by somewhat better leaders, worse case by foreign invaders that can only be better than current leaders anyway, some of your relatives carrying genes and ideas in common with you have better changes of surviving/multiplying. In a more evolved society, applying the rules results in relatively small number of death and explosive cultural and scientific progress afterwards - think about the French revolution (mostly triggered by famine btw). Also, even in the worst case scenario, when a country dissolve in a swarm of anarchic hordes, those hordes still are better off: they can go an pillage the neighboring countries.

If a society actually manages to turn its population into fully obedient sheeple, which is probably what the Chinese emperors managed to do, and then the communist party carried on doing... then you get catastrophic outcomes like these.

And they are truly catastrophic, worse than worse, because in a war at least you have some "survival of the best warrior" selection that improves the overall human gene pool...

The big lesson to be learned here is that training people to be obedient and non-violent makes it impossible for them to fix or destroy a sick social order, and this leads sooner or later to massive numbers of deaths. Our natural propensities for disobedience, individualism, and violence against authority are what keeps societies healthy when kept at a low-enough-but-not-zero level.

One can only wonder what catastrophes the "social credit score" thing will surely sooner or later lead too...
See also https://youtu.be/NAsM30MAHLg

A analog device for performing Fourier analysis.
>(monster, weapon, damage) is "the object".

Now an environment flag causes fire damage to deal +10% more. You're either going to have to extend the hit method again (further complicating it), or just pull that flag from the environment class in the procedure body itself (undeclared dependency). When something else outside monster/weapon/damage/environment has to change the hit calculations, you'll have to extend it again and again.

>And yes, the procedure probably has "side effects". Because that's the point.

Side effects are terrible for maintenance and debugging, you shouldn't be using that to defend your argument here -- unless you don't know what side effects are which is why it's in scare quotes?

>How do you intend to write less code with OOP?

The point is for it to be more human readable because it's unlikely there's performance impact in this case. You don't want to count code quality by lines/characters of code.
imagine sci-hub is intimidated out of business some date in the future... we would come to regret not making backups, but the size is too large at least 60+TB last I checked. Let's say 60GB were feasible for an average individual. So now we need a decentralized way to ensure we have division of responsibility. How do we divide the labor?

Suppose everyone downloads all the articles for which the hash converted to decimal modulo (3 * 365) equals the user's ((birthyear % 3) * 365+birthday)

Then if a few ten thousand participate, we'd have a backup

Something crazy I didn't know, in the article:

>In France, on January 13, 1535, a law was enacted (at the request of the Catholic Church) which forced the closure of all bookshops and stipulated death penalty by hanging for anybody using a printing press.
Do hou have a link for a beginner ?
I've been testing this one from Balena (formerly Resin)

https://www.balena.io/fin/

It's a carrier for the Raspberry Pi compute module. Solves many of the problems it has in an industrial environment. It takes 6-24vdc, has real eMMC storage, an RTC, a hardware coprocessor that can be used as a watchdog and an mPCIE. I think there's a DIN case for it as well.

All that for a bit over a hundred dollars plus the $40 for the compute module. That seems pretty decent at that price. The next step up seems to be a "cheap" x86 IPC at a few hundred dollars.
> it is common because academia loves OOP.

Absolutely not! I doubt that anybody was ever taught OOP in an academic PL course, unless it was really an "introduction to programming" course, or their professor was working on this topic at the moment. The meaning of a program in an object oriented language with imperative features and inheritance is not pretty.

There are aspects of object oriented programming that are useful for structuring programs (hidden state) and others which are a recipe for disaster (recursive types). This complexity is always swept under the carpet when teaching OOP. Classes/inheritance/objects are always taught via imperfect analogies, which should tell you everything you need to know about how "easy" OOP really is.

No, the reason it is taught so widely is purely practical. It's a popular paradigm and a lot of practical programming projects might need an OOP background.

---

Edit:
Just to be clear, I'm not trying to say that OOP is bad per se.

The information hiding and namespacing aspects of objects are really useful, both in theory and in practice. It's just that I think that implementation inheritance is an imperfect way of facilitating code reuse and not something you should teach to new students...
Zeynep Tufekci: Not a drill
There was. The most well known was CleanFlicks. They were all sued into oblivion.

https://en.m.wikipedia.org/wiki/CleanFlicks

There's a documentary about it: https://m.imdb.com/title/tt1007026/
25% off startup branding and PR book (and services) with code “sundaymonday”
When I'm coding, I often find myself in a situation where, in order to reach my goal, I need to use a "bad" language tool (e.g. eval), violate some principle of good coding (e.g. avoiding side effects), or just have to write ugly code. I've come to the conclusion that a lot of writing good code comes down to recognizing those situations and stepping back to find a way you can change your design or strategy to avoid needing the ugly code.

I've never quite liked OOP, but I struggle to say exactly why. I wonder if some of it is that the class structure and hierarchies makes it difficult to step back and change the design in order to avoid having to write ugly code.
(For context: not a dataviz expert by any means, but I've done a bunch of work in that space for the last several years.)

For sharing information professionally? Not much - but you have to remember the context. Du Bois and his team were preparing these visualizations to be shown at the World Fair in Paris, not for a business meeting. As important as the data they portray is their underlying goal: to show that African-Americans are the equals of their European / Caucasian counterparts in cultural and intellectual endeavors. Presenting the ongoing socioeconomic plight of African-Americans as Modernist data art - at a time when Modernism itself was only just starting to spill over into the visual arts - definitely supports that goal.

Now, on to the visualization merits of the spiral. We have four data points spanning two orders of magnitude. To show those on a bar chart, you'd have to either: a) use a logarithmic scale, b) use a linear scale and accept that three of the bars are tiny, or c) use "scale breaks". Instead, Du Bois presents the data in a way that draws attention to the most prominent data point, while still preserving linear scale.

There are some highly effective techniques in the other visualizations as well. The property valuation chart uses annotations to provide narrative context. The freemen / slaves proportion chart uses filled-in space to lend it a stark visual weight that, again, speaks to the narrative impact. Data visualization is storytelling with data, and these charts are clearly designed to get their narrative point across - quite effectively, I'd say.

Finally: Tufte was printed in the 80s, nearly a full century after these visualizations. That, more than anything, makes these striking. With the exception of Playfair's charts, Oliver Byrne's treatment of Euclid's Elements, certain railroad timetables, and few others, the world hadn't seen much in the way of truly effective visualization. They were literally inventing effective visualization techniques. That we don't hear more about Du Bois' charts is unfortunate.