skysight-inc/HackerNews huggingface dataset:
>- 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.

again IMO, demonstrate that the author never really understood OOP.

That's a "No true Scotchman/OOP" fallacy. The OOP that the author "never understood" is what we see ALL the time in enterprise and startup code.

There could be a better OOP (e.g. Alan Kay's definition of it), but that's not what people are taught or practice.
Not necessarily, the NN may just concentrate on them in the porn it's trained on, because it's a common factor that's in porn, but not in beach pics for example. (whereas in both you have almost naked people).
The Ouroboros Card Shuffle
This does read nicely in most cases.

There are minor issues when you venture off and decide that it would be cool if a monsters could damage your weapon. Something like Monster.hits(Weapon).with(Weapon). You'll start wondering if Weapon should inherit from the player base class. If not, you'll spend time wondering how to share the code to keep things dry. Obviously there are many solutions even within OOP, but one might consider looking to ECS to remove code duplication and decouple things.

Lots of good examples in the game programming patterns book: http://gameprogrammingpatterns.com/component.html
Ok, I didn’t mean it’s impossible for someone to ask you to do something during your free in a demanding tone. For example Arnt, get over here and make me a coffee...

But we have this word called No. Maybe it’s down to my personality but I have no problem telling people NO or when I’m in a mood to fuck off or when I’m feeling more professional to just reply with “Where shall I send the estimate?” Basically “Fuck you, Pay me...”.

But the ability to ignore the idiots comes probably down to volunteering me free time as a teenager coding and managing player ran games, the players took the game incredibly seriously, to the point I got harassed because I took action on a player for breaking the rules (issued a temporary suspension from the game), on irc, on the forums getting called a bad staff who should be ejected by the other staff got to me a little, until I told the other staff it was they just felt “I was handling it”. Once they knew they reassured me that they had no intention of doing so (kicking me off the team) and if they continued to feel free to delete their account off the game. I learned that they are not worth the stress and so not to give them the time of day, don’t rise to them because at the end of the day, they are not worth it.

So tbese days I just get on with something else or tell them “sure... but you gotta pay.”.

What I mean is, once someone if demanding of your time then you have to get something of worth in exchange.

In a relationship it’s the joy of having someone in your life to share things with and who can help you improve who you are. At work in exchange for being a code monkey you receive monetary compensation.

In open source its kinda a mix of both, it’s joy of helping others, either today for later down the road.

If someone is taking that joy away, they are taking away your incentive to work on that project so in exchange you have the right to change what you are getting out of the deal. Take your estimated time to do what they are asking, multiply by a figure per hour your happy with, multiply that by 3 (as these things always run over and there will always be support requests down the road) add on what the tax man will take off you and quote them that.

If they are happy to pay, awesome, take a deposit, and tell them you will start on their changes next week. If not tell them they will have to wait like everyone else.

If they continue to be an arsehole then handle it just like you would any other child throwing a tantrum, stay calm and ignore the behaviour.

Edit: I’m not saying it’s not stressful or my way of handling it is the best way for everyone just it’s the method I use to deal with such “children”. I understand the mental strain it can cause. I’m just saying that the person doesn’t have the right to demand your time or attention (including the time your thinking about them offline).
Of the languages i know, C++ and C# come to mind. Granted, in C++ the differences are fairly minor and inconsequential at runtime.
"struct" here is meant in the same sense that the author of the post refers to "PoD objects". Just data in public fields.

Whereas a "class" is usually thought of as private data exposed only through methods.

There is no language that enforces this distinction; it's purely by convention. C++ makes it a little simpler by having a different default access level.

In any case, you are being needlessly pedantic and missing the point.
You can network boot them too, which is way more convinient. RPi3 can do it natively, the former ones need an SD card, but since it's only for the bootloader, it'll survive much longer.
Someone at UC Berkeley is already adding hardware-assisted GC to a RISC-V core: https://people.eecs.berkeley.edu/~maas/papers/maas-asbd16-hw...
Dev team manger here and a cofounder of 100% remote team. What I am looking for in candidates. Tech aspects: some experience in the area we hire for. But most important soft skills: Honesty, being humble handle criticism and lear, be able to clearly communicate which includes neat emails, be open to new ideas (don’t be stubborn), and most important- great communication (let me know you receive my email, confirm you are working on it, say thank you for interview, send me email that the problem is hard you need more time, keep me updated before I ask you for an update, keep Slack on your phone and check it time to time). Our startup is 2 years old and the only reasons why we had to stop working with any developer were problems with communication.
I've always wished "long form" articles would put an abstract at the beginning.
I get that the analysis of the Iliad doesn't prove anything and it could just be a stylistic thing, but that doesn't mean the general story he lays out if totally wrong.

The theory is valuable because it's a good explanation for a lot of things and it doesn't disagree with the evidence. That's the purpose of all scientific theories, in Popper's philosophy of science, which is still the most relevant.

I haven't heard anything even half as compelling for a plausible evolution of social cohesion or the origin of consciousness, by which Jayne's means inner life.
> when class Player hits() a class Monster, where exactly do we modify data? Monster's hp has to decrease by Player's attackPower, Player's xps increase by Monster's level if Monster got killed. Does it happen in Player.hits(Monster m) or Monster.isHitBy(Player p). What if there's a class Weapon involved? Do we pass it as an argument to isHitBy or does Player has a currentWeapon() getter?

I don't see how this is a problem unless you think programming objects correspond with physical objects.

My first thought is make a separate Swing class representing the player swinging their weapon. There's probably an even better way to do it but this gets around the issues mentioned above.

class Player {
fun takeSwing {
swing = new Swing(
this.currentWeapon,
this.location.offset(this.direction)
)
if swing.killedMonster {
this.xp += swing.monster.level
}
}
}

class Swing {
fun new(weapon, location) {
this.weapon = weapon
this.monster = findMonster(location)
if this.monster != null { this.monster.takeHit(this) }
this.killedMonster = this.monster != null && this.monster.dead
}

fun damage {
return this.weapon.baseDamage
+ this.weapon.bonusDamage
}
}

class Monster {
fun takeHit(swing) {
this.hp -= swing.damage - this.defence
if this.hp <= 1 { this.die }
}
}
I think damage to the weapon could still be handled in the Hit class, because Hit has a reference to Player and Monster and Weapon. You could even create different types of Hit classes that could execute different kinds of Hit behavior like this.

In that case it may be better to rename it to HitStrategy?
OOP is not a silver bullet but for some classes of problems it's the best tool available.

That's the reason why all good rich GUI frameworks are OOP-based, including HTML DOM we use on the web. GPU APIs, OS kernel APIs are OOP-based as well.
We started with Quake III, Minecraft, etc. and were able to maintain "game play FPS" (800+), but nothing like a high end discrete card. Where SWR really shined was on high end HPC visualization software, where discrete cards (if they didn't crash/hang) could only maintain 1-2 FPS. SWR could get 12-17 FPS. Such applications are strongly bandwidth limited.
You could even serialize the Hit classes and throw them on a message bus, and have them automatically applied across the network or something.
Another way to see it is we're interested in what you were saying and we're giving you the podium.
Wow, you sound like a very tough person to interview for.

I agree that algorithm challenges are kind of pointless when it comes to software engineering but you can hardly blame the OP for doing them given that many companies do value them. And the OP did say they also have their own libraries on github and open source contributions too..

> Now if you don't have any uni friends pulling for you, I really have to think that you might just not be all that friendly, in that you might be standoffish or have some kind of personal trait that is putting people off.

That sounds quite harsh really. Makes me feel sorry for the people you interview who might be perfectly nice people to work with and capable of communicating but don't get hired because they aren't good at making friends or don't have "likeability" as you call it.

> Ego in programmers is the worst, and if someone is mansplaining to me in the interview, I almost never hire them (pet peeve).

Are you assuming that the programmer being interviewed is a man? Thats a bit sexist..
As a counter-example for RS-485, my solar roof's data logger consists of an RS-485 to USB converter, a Raspberry Pi and some solid-state relays. They even used the standard Raspberry Pi power supply, but they cut off the micro-USB and use screw terminals connected to the Pi's GPIO (probably so that customers do not have the temptation to swap it with a random phone charger they bought on eBay).
>And this one line is why you're willing to setup all these crap boilerplate supporter classes and take a huge hit in runtime performance?

Hits don't usually happen that often in games relative to everything else the engine is doing unless you're writing something like MMO server code that processes hits from thousands players.

Yours is a classic case of over-optimizing, I think.
I'm not sure about resources but I can explain the basics. BTI happens when there is a constant voltage across the gate/source of a transistor for a long time. An example for a digital circuit could be an inverter held in one state. Either the pmos or nmos will have a large vgs and over time this bias will shift the threshold voltage (vt). Now if this inverter delay is critical, BTI will cause the delay to change and could break timing. To fix it if the inverter is toggled after sometime it will mostly recover to the normal delay. Some people mitigate it by having very low frequency toggling for 'off' gates, but usually only if those gates are critical/matched. Alternatively people just margin the timing for the worst case. Analog circuitry has to be designed for it also, and it's an issue in differential pairs for example.
Ultimately the answer is to use a language in which passing a function reference is as easy as writing a singleton that implements an interface and passing a reference to that. (Or easier—in any language with decent function-passing support, writing a function and referencing it is generally going to be easier because fewer things are happening.)

OO makes sense if the different types of behavior map to object identities and inheritance trees, because it generates a chain of implicit if statements that capture this logic. If they don't—e.g., a hit changes behavior depending on whether the attacker is proficient in the weapon, rather than depending on the weapon class or attacker class itself—you're likely better off writing the if statements yourself.
I don't think C++ has a dynamic multiple dispatch mechanism. You can craft one with the visitor pattern or some precompiling or macro sheanigans. I'd love to hear about the best way of doing it.
Over-optimizing as in, write the one obvious line instead of 15 lines of crap that are also slower?
Lessons on Startup Success from an Olympic Champion
Languages that force you to use the singleton pattern really ought to just let you write A FUNCTION
I really enjoy being in Asia because finally everything is the right size for me. I'm a bit small, and I didn't notice before how everything in the west is slightly too big for me. A minor annoyance, sure, but what a relief when things finally fit!
It's nice that some C++ compilers can optimize this out. It means that it only costs maintainer cycles (less straightforward invocation), and compiler cycles. As every C++ programmer knows, there is an unlimited amount of them.
Maybe you should go back and read it slowly, as it was a good argument.

Don't be a dick.

This is what they always say...strange how OOP is the one paradigm no one ever seems to understand, no matter how much is written about it. Seems to me like there isn't actually anything to understand.

It's not. Developers from various backgrounds frequently fail to understand all different kinds of development paradigms, and I've seen _just_ as much awful imperative code as I have awful OO code.
... on the bright side, Chinese companies are less likely to sell you out to the NSA. Let's face it; NSA is probably far more interested in the insignificant American everyman than the Chinese government.
First encounter: COMPUTE magazine and its glorious, tedious type-in code
Agree! Pranayama and other yoga practices are very powerful and effective. It's very important to have an experienced teacher rather than trying to do it yourself. These practices can have very strong effects and can be misused. There is a lot of misinformation floating around. I recommend finding an experienced teacher in the Krishnamacharya/Viniyoga tradition.
These are absolutely mindblowing. Thanks for sharing!
Right, DigitalOcean load balancer is really handy!

I'm curious to know what you think of swarm after you tried it :-)
Well, that's not really absurd or far for the truth. Music is selected for its effects on the consumer in all kinds of commercial establishments, and besides trial-and-error (this kind of music works best for people to drink more in our bar etc) there are lots of commercial research into it.
> You want to know why OOP is useful and common? Because it's easy.

With as much proof as you have given, let me offer you a counterargument: it is common because academia loves OOP. It's easy to teach, it's easy to test. It is most decidedly not easy and very often not useful.

My favorite example of how everything falls apart in due time is the color of a car. That's it, right? A car has a color. A Porsche Panamera might be a "carbon grey metallic" and it's stunning, but that's just one color still. Aye, up until the Mini Cooper tells you they need two colors. This world doesn't fit the OOP straightjacket. Your programming course does but the real world doesn't and when it doesn't then pain follows.
New to OOP programming. Could you explain what sort of arguments are presented against using OOP? I am genuinely curious.
GitLab 11.5 Released
Liquid nitrogen is actually very easy to make and very easy to melt. You can buy a generator that can make 67 liters a minute of eBay.

The water would be hot though I’m open for debate on another source to rapidly warm the liquid nitrogen.

I wish I had the time or the money and engineering ability to prove it out. Hopefully some other inventor and build on this concept. It will work, my biggest concern would be destroying the atmosphere, but I would predict we would need a lot of nitrogen exhaust to displace enough oxegen.

Thanks for the feedback!
The inevitable march of death?
> Data is more important than code

Nope. Right there at the beginning is where the author goes off track.

Computation itself is the most important aspect of computing. Code and data are just complexity to manage.

> Do I have a Customer? It goes into class Customer. Do I have a rendering context? It goes into class RenderingContext.

I whole heartedly agree with this. The naive approach to domain modelling is to classify the primitives of a domain into classes and stop there. In actuality, the processor of those primitives is likely what your class should be, and those primitives ought to be methodless data structures.

I.e., OrderFulfiller instead of Customer and Part classes.
Yes, OOP is easy. At least the layers of sedimentary cruft were comparatively easy to write. The parts that actually do something, not easier in the slightest. It's still procedural code that must move data. (Usually that code is much less straightforward in OOP because it has to deal with so much boilerplate that is in the way of accessing the actual data).
Yeah, it sounds suspiciously like the real finding might be "putting a peg over the nose for an hour in advance is a suboptimal way of preparing somebody for a smell-based recollection test", which is almost Ig-Nobel worthy
White Liberals Present Themselves as Less Competent with African-Americans
Yeah, its evil =(

6s = 30 -> s = 5

2b + 2s = 20 -> 2b = 20 - 10 -> b = 5

4p + 1b = 13 -> 4p = 13 - 5 -> 4p = 8 -> p = 2

------------------------>

1s + ((1b + 2s + 2p) * 1p) = ?

5 + ((5 + 25 + 22) * 2) = ?

5 + ((5 + 10 + 4) * 2) = ?

5 + (19 * 2) = ?

5 + 38 = 43

----------------->

[6s] + [4p + 1b] = 43

65 + 42 + 5 = 43

30 + 8 + 5 = 43

---------------->

[6s] + [4p + 1b] = 43

[6s] + [4p + 1b] =? 1s + ((1b + 2s + 2p) * 1p)

[6s] + [4p + 1b] =? 1s + [(1bp + 2sp + 2p^2)]

[6s] + [4p + 1b] =? 5 + [52 + 252 + 2(2*2)]

[6s] + [4p + 1b] =? 5 + [10 + 20 + 8]

[6s] + [4p + 1b] =? 5 + 38

[6s] + [4p + 1b] =? 43

43 = 43
Man, this issue is really damning.
> Don't be a dick.

Don't worry, I won't.

> iterative code

I'm not really sure what that is. But I notice OO is unique in that "you don't understand it" is always the main defense. The trouble is that, when people can't even agree on a definition of OO, it is genuinely not clear that there is anything to understand. There is always some OO best practice that is ill defined and contradicts the advice yesterday. No one from OO land seems to enjoy math very much so you don't get precise definitions, you get "patterns" and "I know it when I see it".
Look for "baba ramdev + pranayam". There are a ton of videos online with him teaching pranayam. Like with all things of this nature there's a whole lot of junk surrounding it (marketing etc) that he also indulges in but the exercises themselves are good. Here's what I could find.

You might find some books at patanjali[1]. They have a good list of exercises although the BS part does appear in some books.

[1] https://patanjaliayurved.org/product-category/patanjali-publ...
Until you get a decent combat system in and now your hit has to go through 30+ calculations. It's almost never as simple as "monster.HP - damage".

Besides, if we really want to be snarky, why haven't you wrote it in assembly for performance?
More details

https://pruned.blogspot.com/2012/01/gardens-as-crypto-water-...
only if by "US" you mean north of DC.
These examples are supposed to be examples, not what we would actually do in this specific case. In a huge enterprise system that has 500 different ways something could be done, in which your function would have 30 million if statements, all which is dependent on runtime behavior, polymorphism can help solve that problem.

Imagine there are hundreds of ways Hit can be implemented and used in different situations. That's the reason for breaking out this type of abstraction. I agree this example the author used isn't probably a clear one in which one should use OOP.
Why do billions of people still lack basic sanitation?
Toronto. We're double engineer income with no kids, and spent years saving up. We were also fortunate in finding this place, the unicorn of condos: 1400 sqft, near a subway station, well-built building, responsibly managed condo board.

Is it worth $1m? Oh heck no. I don't think it's worth what we paid even, once the market readjusts to reality.
In the context of the story and Shereshevsky's personality, it is. To him, a person with extremely strong synesthesia, musical sounds literally have flavors, flavors that are as strong as actual real food to a normal person.

He isn't saying, "Restaurants play certain music to push customers to feel a certain way," he's literally saying that the flavors of music can match and enhance the flavors of food.
Lol, no. The TV series has nothing to do withe movie other than the basic premise. It throws the best thing about the movie right out the window immediately.
AI Mistakes Bus-Side Ad for Famous CEO, Charges Her with Jaywalking
Unfortunately, no. While he hasa lot of good arguments, they're drowned out by his repeated use of logical fallacies to push his point across. This long, rambling piece simply comes off as him bullying the reader into agreeing with him.

Note that I'm not saying he doesn't have valid points hidden in that wall of text, but he's certainly lacking the social skills and reader empathy to land a good argument, and as a result its too exhausting to take him seriously.
This is from 2014. Is there anything the State Department couldn't screw up during the Clinton and Kerry years?

Here's an article from 2016, where things are still screwed up:

https://qz.com/702668/afghan-translators-for-the-us-army-who...

Fast forward to 2018 and this program is still not accomplishing its goal.

You have to wonder if things would have been different if Clinton, as Secretary of State, had taken an interest in making this program succeed when it was being stood up and the processes were being put in place. That's a critical time for any program. Once the die has been cast, its really hard to change things.
> OOP programs tend to only grow and never shrink because OOP encourages it.

Most long-lived programs tend to grow, because people add new features to them. This isn't something unique to OOP.

As for growth of OOP programs in particular - does no one ever refactor anything? Shrinking OOP code through refactoring is a daily occurrence at almost every job I've ever had.
I didn't "neglect" that, I'm well aware Lynch distanced himself from the movie and that doesn't have anything to do with whether or not I enjoyed it.

I'm not convinced deconstruction is always useful but I do think it can be fun.
Huh?

If there was a worse example of over-engineering and crappy difficult to use API that would be Swing.
I'm not sure that I agree 100% with all the points raised in this article, though that's possibly just a reaction to what reads to me as invective.

Here's another bit of food for thought along those lines, though: If you take all the elements of what's typically considered to be good object-oriented design to their logical extremes, you end up with a bunch of objects that each have exactly one operation, and are configured at construction time. They may have some very simple internal state (think counters and caches), but you probably want to keep that to a minimum.

The end result starts to look very, very similar to functional programming. An interface with one method is essentially a function. Constructor arguments do basically the same job as closures. Etc.

When you're looking at things from that perspective, the big difference is that functional languages almost force you to work that way, whereas it takes consistent, conscious effort to do it in OOP.
No, I'm not talking about one arithmetic CPU operation. I'm talking about simple, procedural hit(monster, weapon, damage).

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