The faster you unlearn OOP, the better for you and your software - <AUTHOR> https://dpc.pw/the-faster-you-unlearn-oop-the-better-for-you-and-your-software <comment><USER2> I'm always confused when people criticize OOP, because most of the time the criticisms they use are just plain bad programming. Or they're using hyperbole that isn't really useful.

You want to know why OOP is useful and common? Because it's easy. Easy things allow for faster development, faster onboarding of devs. Humans need a mental models of things and OOP very explicitly gives it.

But like most easy things, OOP still works well enough even when it's done badly. That's not a bad thing. Working software beats non-working software.

We shouldn't be telling people "stop using OOP! It's only for idiots!". OOP will be here forever. We should be teaching people how to do OOP right, what the pitfalls are that lead to bad design, and how to take badly designed OOP and fix it.

<comment><USER3> > 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.

<comment><USER4> > 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...

<comment><USER5> _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..._

And most professionals agree with you. "Prefer aggregation over inheritance."

Which by the way Resharper makes really easy. You add a private variable to your class of the type you want to aggregate and it creates wrapper methods in your aggregating class that just calls your other class.

</comment></comment></comment></comment><comment><USER6> I read this quickly to see if this was the piece that should convince me.

It was not. It is, IMO, a collection of strawmen.

People have abused OOP? Yes.

But

\- citing FizzBuzz Enterprise Edition (which is really funny even for us Java/.Net developers because it is so horribly wrong)

or writing this

\- _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.

What probably is true however is that a lot of people should unlearn the OOP they learned in school.

<comment><USER7> > What probably is true however is that a lot of people should unlearn the OOP > they learned in school.

Can you provide references for proper OOP?

<comment><USER8> [https://en.wikipedia.org/wiki/SOLID](https://en.wikipedia.org/wiki/SOLID)

I wish they would have taught me this in school. Instead, I learned that a cat is an animal, and a car has wheels, and a car is a vehicle. But not what any of these things have to do with one another and how to actually use them.

<comment><USER7> I saw many SOLID code bases hard to grasp and maintain because implementation hides data flow. The most evil workers are [D]-purists.

</comment></comment></comment></comment><comment><USER9> > The vast majority of essential code is not operating on just one object – it > is actually implementing cross-cutting concerns. Example: 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?

Not saying this is the right way to do things but, if you're actually going to go 100% OO on something:

Player.hits(Monster) returns Hit

Hit takes a Player and a Monster in constructor, and has with(Weapon)

You end up with:

Player.hits(Monster).with(Weapon)

Then Hit reaches into said objects and deals with changing the HP, and XP. You then have encapsulated the details in the actual Hit itself, which seems correct.

It does read kind of nicely IMO...

<comment><USER10> Great point... but doesn't it continue to prove the author's point that this is needlessly complex?

It strikes me as bad design if something as simple as an action (hit) now needs to become it's own _class_ that is instantiated merely to execute a single function and then have to delete itself. That just feels like insane overhead/boilerplate, no?

The argument here is that it's far better to have player and monster be simple data structures, and a single function _hit(player, monster, weapon)_.

<comment><USER9> The Hit class may be a Singleton and only instantiated once. Creating a class is like 3 actual lines. Also at least in Java the Hit class can be an inner class of the Person class. It just feels like name spacing in that case.

It is needless complex if the code is simple.

This solution is more flexible that just a pure function. 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? Then you could curry the function and call it something different too and that works I guess. OOP shines when you have lots of different ways things can work in different combinations. OOP is a tool like other programming paradigms, you use it when it solves your problem better than the other ways.

<comment><USER11> Languages that force you to use the singleton pattern really ought to just let you write A FUNCTION

<comment><USER9> A lot of OOP languages have added method references, and lambdas in this day and age.

</comment></comment></comment></comment></comment><comment><USER12> This has been shared on HN many years ago, but I'm linking again in case there are younger engineers who might be unaware of this classic rant: _Execution in the Kingdom of Nouns_ : [https://steve-yegge.blogspot.com/2006/03/execution- in-kingdo...](https://steve-yegge.blogspot.com/2006/03/execution-in-kingdom- of-nouns.html)

<comment><USER13> That was great. I read it for the first time. Similar scenarios happen in so many other fields. Some bad idea takes hold. Then schools teach it. Then more people invest time learning it so that they cannot admit it is bad and this goes spreading like wildfire and become sacred...

<comment><USER12> And then someone discovers that the old way was better and gives it a new name. When I was in school, functional programming was called "programming".

</comment></comment></comment><comment><USER14> I've never liked classical OOP much, but multiple dispatch is a lovely paradigm. One doesn't define _classes_ per se, but rather just plain old boring structs.

       struct Player
           xp::Int
       end

       struct Monster
           hp::Int
       end

       function hit(p::Player, m::Monster)
           p.xp += 10
           m.hp -= 20
       end

The nicest thing is how one one doesn't need inheritance to "add a method" to an object. One just defines my_function(s::String) to be whatever, and it doesn't interfere with anyone else's code.

<comment><USER15> > One doesn't define _classes_ per se, but rather just plain old boring > structs.

in which language are there differences between classes and structs ?

<comment><USER16> "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.

</comment></comment></comment><comment><USER10> A lot of these initial points I don't think are relevant -- you can model your data in objects, data structures are complex because business needs are complex, data models wind up having implicit graph dependencies as well...

BUT, "cross-cutting concerns" is where I think the main valid argument is. In my experience, OOP is just way too _restrictive_ of a model, by forcing you to shoehorn data and code into an object hierarchy that doesn't reflect the meaning of what's going on.

So I totally agree with the conclusion: just store your data in "dumb" arrays with hash tables or database tables with indices... be extremely rigorous about defining possible states... and then organize your functions themselves clearly with whatever means are at your disposal (files, folders, packages, namespaces, prefixes, arrays, or even data-free objects -- it all depends on what your language does/n't support).

<comment><USER17> >In my experience, OOP is just way too restrictive of a model...

Maybe, but if it's cross cutting concerns that bother you, just combine OOP with an aspect oriented programming library.

<comment><USER18> Exactly! So long as the developer approaches the solution with the expectation of scaling and extensibility from the get, this should not be a problem.

</comment></comment></comment><comment><USER19> > 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.

<comment><USER20> 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.

<comment><USER19> There is no one without the other.

The data is unintelligible randomness without some algorithm to process it

The code cant exist without some data schema to reference and has no value if there's no data instances to process.

</comment></comment></comment><comment><USER21> The problem with OOP is that it became so ubiquitous. Everything had to be OO, millions of hours spent trying to fit everything inside absurd taxonomies.

There's good bits in OO. You can find articles about how parameterizing large `switch` statements into objects can lead to obvious improvements.

My only conclusion is to bet on biodiversity~. I learned so much in relational (db) logic, functional programming, logic programming, stack languages (forth threaded code) etc etc. As soon as your brain sense something useless discard it and find another cool trick/theorem to grok.

</comment><comment><USER22> I think for enterprise type software OOP works well. It easily allows us to re-use code and solve common problems once in a parent class and have that solution easily propagated to child classes.

However, when developing a video game, I ran into quite a few OO design conundrums that IMO were the hardest programming problems to solve in my career. I started looking into data driven design, and while I never changed my code to implement it, it looked like it might have been easier for the video game. I do not know for sure. But I do know that getting OO right in the video game I was implementing was daunting. Maybe I was doing it wrong. The one issue we kept running into was how to design it so that the flow of dependencies flowed in one direction. That is to say, classes should not require references to classes that were higher up the food chain, and vice versa. It sucked when you realize that your Bullet class requires a reference to the BattleField class when the BattleField object was not being passed down through all the intermediate objects that separated the two. I would be willing to say that it could have been poor design, or rather not realizing that dependency earlier in the process to deal with it. But many things we did not know till the requirement or change came up. Then it was programming somersaults to deal with it. Eventually we did get better at re-arranging things as things came up, basically we got used to having to change a lot of the design at a drop of a dime.

I do not know if data driven design would have helped, but it did sound like it was worth a shot. I must admit though, I do remember a data driven program i worked on, and it bothered me how much data had to be passed around that was not relevant to the method/class that was using it. And a lot of data got lumped together out of convenience.

</comment><comment><USER23> This article seems to fit the template: Here are some abstract reasons why paradigm X is bad, and here is a class of problems that have a more straightforward solution in paradigm Y, therefore paradigm Y is better than X.

The real message here is that if you have a problem that nicely maps onto a relational database then use the database-like approach instead of OOP.

In my domain, I work on algorithms for a very specialized class of graphs whose structure and manipulation must obey a diverse set of constraints. I have tried implementing the core ideas using multiple popular paradigms but so far I did not find anything better than OOP.

</comment><comment><USER24> Bashing imperative + structured + OOP is valid if you have a viable alternative. That viable alternative is proper namespacing, modularity and functional programming.

If your alternative is another form of spaghetti your problem is not OOP. Your problem is the way you build abstractions.

If your procedures and functions, the foundation of your program, are poorly thought, then you laid a shitty foundation for everything that follows.

</comment><comment><USER25> 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.

<comment><USER12>
      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.

<comment><USER26> I think the claim may have been that the brain is usually doing something more akin to "noun.verb(...)", rather than "verb(noun, ...)".

It's a very interesting question. The concepts of agency and intention are very important in human cognition. If we hear a sound, we wonder if some intentional agent (predator, enemy, etc) that we need to be aware of caused the sound. Or if it was something inanimate like the wind rustling a tree.

The OOP paradigm seems to map more closely to agents taking action. But perhaps my speculations aren't well grounded. I'm not sure.

<comment><USER27> It _is_ a very interesting question. As an FP fan, I'd argue that we model the world primarily in terms of the actions we want to perform, with the objects secondary. But I'm obviously biases.

Furthermore, perhaps how we actually model the world mentally is or should not bear much of a relation to how we do so in code.

I haven't made my mind up about these things, even though I lean towards the FP approach in my day to day coding. But I love (constructive) discussions about the issue because somehow I feel they're about more than just 'making shit work'. Aside from the occasional flame-war I really like the discussions on HN about this stuff, and usually there are at least a few comments that give me new insight into both OOP and FP.

</comment></comment></comment></comment><comment><USER28> > 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.

</comment><comment><USER29> >The vast majority of essential code is not operating on just one object – it is actually implementing cross-cutting concerns. Example: 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?

As an indie dev this is something that I struggled with early on and my solution so far has been to choose the most obvious place where all those things should happen and just do it there (in this case it would be on the Player, in other less obvious cases it gets more fuzzy). What does the non-OOP solution for this problem look like?

<comment><USER30> > 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 }
          }
        }

<comment><USER31> Good example, I think that's why people struggle with OOP, they do think that "programming objects correspond with physical objects". This is the same reason they struggle with storing states in databases because they try to map OOP to tables.

</comment></comment></comment><comment><USER32> Some things never die. comp.object on usenet (15+ years ago) had a regular 'guest' explaining why table-oriented programming is better than OOP:

[http://www.oocities.org/tablizer/top.htm](http://www.oocities.org/tablizer/top.htm)

<comment><USER33> In the context of creating a formal model for decision-making, yes table- oriented design can be a superior choice.

[https://www.hillelwayne.com/post/decision- tables/](https://www.hillelwayne.com/post/decision-tables/)

</comment></comment><comment> Const-me 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.

<comment><USER27> I don't necessarily disagree, but wouldn't you agree that libraries like React seem to pull GUI's toward a more FP approach?

<comment> Const-me This react? [https://reactjs.org/](https://reactjs.org/) Their web site says following:

> Component-Based

> Build encapsulated components that manage their own state, then compose them > to make complex UIs.

Wouldn't you agree that components managing their own state is a textbook definition of OOP?

They even have inheritance-based examples on their main page:

> class HelloMessage extends React.Component

<comment><USER27> Yeah, that's a fair point. React isn't purely functional, but in practice I'd say it still leans heavily toward a functional approach

You're encouraged to keep state only in top-level components, or in a functional-style state management library like Redux, and pass the data as props/parameters to pure components that are just functions. There's a huge emphasis on immutable data, and composing your various components/functions, passing them as props, etc.

The fact that React switched to using classes makes it seem less functional than it is, and honestly I'm not entirely sure why they decided to do so.

Anyways, you're not wrong, but the point I was trying to make is that React is definitely much more functional than other/older approaches to GUIs, and is popular in (large?) part because of that difference in approach.

<comment> Const-me > You're encouraged to keep state only in top-level components

Doesn't state grow unmanageably large for complex GUIs?

> React is definitely much more functional than other/older approaches to GUIs

I'm not sure about that. Take a look, both projects are much older: [https://github.com/dotnet/reactive](https://github.com/dotnet/reactive) [https://reactiveui.net/](https://reactiveui.net/)

<comment><USER27> > Doesn't state grow unmanageably large for complex GUIs?

Yes, and there are various ways to make this less of a problem. Still, React generally favors explicitly passing props down the component hierarchy, keeping the actual UI bits pure functions and composing them in various ways that is typical of FP.

> I'm not sure about that. Take a look, both projects are much older: > [https://github.com/dotnet/reactive](https://github.com/dotnet/reactive) > [https://reactiveui.net/](https://reactiveui.net/)

Perhaps I should've specified that React, _as a very popular_ 'GUI' library, is much more functional than many of the _very popular_ libraries that came before it.

Anyways, my point was not that it's the first of its kind, or 'fully' FP, but rather that it's an example of how FP-style UI libraries can be a good solution, and even be popular _because_ they're less OO in nature.

<comment> Const-me > it's an example of how FP-style UI libraries can be a good solution

On the lower level, FP approach indeed sometimes causes much cleaner architecture, even for GUI code.

My point is, there's no good alternatives at higher levels, where you want to build complex systems by combining components developed by different people/companies.

> and even be popular because they're less OO in nature.

That's debatable. I don't think the main reasons why React is popular are technical ones. Facebook is popular, and half year ago it's market cap exceeded $600B. It's $392B now but still it's a huge company with 2.2B monthly active users. Many people want to achieve such success and view their technology as a silver bullet.

P.S. I'd like to add that OOP and FP are almost completely orthogonal. Here's a good article about OOP in FP languages: [https://medium.com/@gaperton/let- me-start-from-the-less-obvi...](https://medium.com/@gaperton/let-me-start- from-the-less-obvious-thing-7f49e87a45ca) And many traditionally OOP languages adopted a lot of FP stuff: C#, JS, to lesser extent even C++ have now a lot to offer for functional-style programming.

</comment></comment></comment></comment></comment></comment></comment><comment><USER34> Don't know why people keep insisting on this. OOP is a model. Functional is a model. Data oriented is a model. We as programmers just have to use them , in the most effective way possible to architect a solution to a problem. No one model of those can substitute any other. They complement themselves. There is bad OOP and effective OOP, just as there is bad Functional and effective Functional. The models are never bad by themselves. The programmers are. Any programmer that bashes OOP in favor of any other model is just making a fool of himself and exposing his ingenuity.

</comment><comment><USER35> There's something very important here. It also tends to be overstated. As a former OOP guy, I struggle with explaining what's going on with people that don't see it yet.

Perhaps beginning with praise might work best. OOA as a group analysis tool is probably one of the most powerful things coming out of computer science in the past 50 years. Oddly enough, nobody does it much. Many if the problems this author brings up with OOP actually work for the best in OOA.

It's not all bad. But there are problems with where we are. Big problems. We need to understand them.

</comment><comment><USER36> > 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.

</comment><comment><USER37> Sometimes the best way to decide what to do, is a OOP-like 100,000 line long legal code. Sometimes the best way to decide what to do, is something short and sweet yet possibly not entirely clear, like the Ten Commandments. When what the original designers chose was correct, everything will work quickly and reliably. When they don't, you'll suffer for a long time. Given that, you'll spend almost all of your wall clock time suffering and complaining about the designers selection being wrong. With a side effect of most of your suffering will be due to poorly implemented examples of the dominant paradigm. "AKA OOP SUX"

In summary, given all of the above, there are two true statements that OOP works AND simultaneously you'll spend almost all of your mental effort on OOP not working. Generally, OOP being inappropriately hyper dominant at this time, means that non-OOP solutions will utterly master some very low hanging fruit for first movers who abandon OOP.

I've seen some truly horrific object relational mappers trying to connect OOP to inherently functional software APIs, hardware device interfaces, "chronological engineering" in general, and persistent data stores. Not surprising if you're working in those areas, abandoning OOP will lead to massive success.

</comment><comment><USER38> 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.

</comment><comment><USER39> > Object-oriented programming is an exceptionally bad idea which could only > have originated in California. > — Edsger W. Dijkstra

I don't understand why Dijkstra gets quoted so often when he has been demonstrably wrong on so many topics (see his opinion on BASIC too) and he was such a dogmatic and unreasonable person overall.

</comment><comment><USER40> I pretty much believe that all we have are bad solutions. OOP is a bad solution that is acceptable at a set of problems. Data oriented designs is an also bad solution that is acceptable at a set of problems. Anyone who has ever used any paradigm for big projects can do a write-up about how bad that paradigm is.

The problem of OOP is not OOP, but actually knowing only OOP. That creates a lot of hammer and nail problems. The same would be true if data-oriented had the same popularity, and everything was data oriented.

So, unless you ARE going to give me a __good__ solution, a silver bullet, it is silly to state that a whole paradigm is an absolute inferior. Especially when all you can give me is examples of bad paradigm-tech-problem matches or snippets of incompetent usage.

</comment><comment><USER41> > Instead of a well-designed data store, OOP projects tend to look like a huge > spaghetti graph of objects pointing at each other and methods taking long > argument lists.

Uh, what? FP projects are the ones with crazy argument lists, has OP even heard of the Law of Demeter? Does FP magically prohibit a huge spaghetti graph of functions and ad-hoc types pointing at each other?

> The main point is: just because my software operates in a domain with > concepts of eg. Customers and Orders, doesn't mean there is any Customer > class, with methods associated with it.

What an observation, it's all a bucket of bits so why name anything? Rub your hands together, mutter an incantation and voila, software without all that obnoxious structure!

</comment><comment><USER42> 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.

</comment><comment><USER18> This is coming from a business consultant (BA/PM and configuration primarily), but in my experience, it seems like the OOP paradigm is fine in most cases and is leveraged in a functional/compositional fashion typically, so I fail to see the issue with OOP a paradigm. Generics and polymorphism can be used to basically create a functional system that only uses domain specific classes to handle edge cases.

In short, OOP as currently used, in my experience working on numerous RIA/municipal/county government enterprise document management systems, seems perfectly adequate to the tasks at hand and can be used in an effectively functional way.

<comment><USER43> What is the point of OOP then, if you are using it in a functional way ? This just proves author's point.

Do you truly use it in a functional way though, that would mean, that you care about separation of state and identity. If you are mostly using immutable collectons/objects with pure functions, then it's fine, but this is not OO.

</comment></comment><comment><USER31> I think most people forget that Edsger W. Dijkstra was a computer scientist not a software engineer. He most likely wrote programs, but not build software systems. As much as I've enjoyed most of his writings and musings, one must bear in mind that they most likely apply to programs not software systems built in the large. If you are writing one little program and have one type of data, it's easy to begin with data. When you have a complex system operating on 500 different types of data, it becomes easier to encapsulate with OOP.

</comment><comment><USER44> 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.

</comment><comment><USER45> Should be pointed out that this refers to C++/Java/Ruby/python style objects, and not smalltalk/erlang style objects, which is a message passing model for data storage.

<comment><USER46> Could someone enlighten me as to how Java style OOP differs from Smalltalk's variant? I've read the Alan Kay quote on how he's sorry for focusing on objects instead of message passing but I'm still unsure on how Smalltalk is so much better not having used it.

<comment><USER47> This may not answer your question and may not be 100% correct.

Message passing means that objects have their own data and do not have shared access to it. This makes multi-threading and parallelized code very easy to do because you don't have to worry about data changing unexpectedly. Clojure, and other languages, achieve this by making data immutable, which has a similar effect.

As you mentioned, after Alan Kay used the term "object-oriented" to describe Smalltalk, people focused on the objects instead of the messages and created languages designed around the idea of being object-oriented instead of around message passing (I believe Objective-C and Ruby do message passing), thereby missing the benefit. All OOPLs not based on message passing should die.

Also, unlike Java, Smalltalk has no classes. Any existing object can be used as a template to create a new object.

</comment></comment></comment><comment><USER48> I really think these kind of articles are valuable in the sense that they make us question the way we code our applications.

But I still think it's too easy to point to a problem without discussing possible solutions. I know the functional paradigm, focused on data streams and procedures, is where he is pointing at. But how does this facilitate the graph reference problem, for example?

The thing with oop, besides that is easy, is that is diffuse. Any o'll tutorial will have an order+client example.

</comment><comment><USER49> "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?

</comment><comment><USER50> I find that I generally agree. However, I have the intuition that good data- oriented design requires an exceptionally solid understanding of the problem domain.

You might say that any good design requires that. I'm not going to disagree. But if there's a place for OOP, maybe it is as a preliminary abstraction, something to hold the chaos at bay while we build our understanding of the task at hand.

Of course, preliminary abstraction has a nasty habit of becoming permanent.

</comment><comment><USER51> 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.

</comment><comment><USER52> It's crazy how passionately people get behind their preferred paradigm. I think they all have a place, and can all be abused severely.

I'm all for people —at least those who don't answer to me— picking one and running with it, but if you're going to try and tear another one down, at least make sure you understand what it does for the people that like it. TFA's author does not appear to.

</comment><comment><USER53> Encapsulation never was my favorite aspect of OOP too, in fact I always try to create different classes for data and code - it brings in a lot of benefits. But OOP patterns described by GoF are brilliant things in terms of code reuse and maintenance costs.

</comment><comment><USER54> Learning and developing projects in Distributed Systems using Elixir made me realise the same..

</comment><comment><USER55> > the Customer concept is just a bunch of data in a tabular form in one or > more DataStores, and "business logic" code manipulates the data directly.

where lives this business logic? are different functions accessing the same data and modifying it? problems appears.

</comment><comment><USER56> Most of the problems pointed out can be reduced into "confusing indirection as abstraction", which _is_ a sin of many OOP developers, particularly those obsessed with design patterns.

IMO, OOP is not inherently any more flawed than any other paradigm.

<comment><USER57> This claim is not refuting any of the points presented.

</comment></comment><comment><USER43> Reading some of the comments here reminded me of a great talk by Stuart Halloway called Narcissistic Design.[1]

[1] [https://www.youtube.com/watch?v=LEZv- kQUSi4](https://www.youtube.com/watch?v=LEZv-kQUSi4)

</comment><comment><USER58> Previously on HN: [https://news.ycombinator.com/item?id=13850210](https://news.ycombinator.com/item?id=13850210) "Was object-oriented programming a failure?"

</comment><comment><USER59> > For concurrency and multi-threading, I typically glue different logical > components via message passing

There's a word for the programming paradigm where you glue logical components together via message passing...

</comment><comment><USER60> 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.

</comment><comment><USER61> Well, obviously the guy is not using Lisp(or Julia), because his problems are easily solved by multiple dispatch.

Blame mediocre OOP languages (Java & friends), not OOP itself.

</comment><comment><USER39> OOP is successful because it's very good at modeling the world that surrounds us. As much as people like to hate on inheritance and recommending composition instead (a reasonable advice), the bottom line is that you will encounter the pitfalls of inheritance only on very rare occasions.

And inheritance enables so much flexibility and ease of maintenance that nothings comes close to it, not even FP.

Specialization and polymorphism(s) are the reasons why OOP is around, successful, and will remain so for a while. Anyone pretending it's bad or broken is just click baiting and does not understanding the fundamental issues.

</comment><comment><USER9> > Encouraging complexity

Picking a satire piece on how something can be abused is not a great argument of "this thing is bad".

For example, I'd argue anything written in an OOP language is going to be more readable than this (from the obfuscated C contest) [https://www.ioccc.org/2018/algmyr/prog.c](https://www.ioccc.org/2018/algmyr/prog.c)

Also, complex systems tend to benefit from OOP because complex systems can have multiple combinations of behaviors. Something IMO OOP is useful for.

</comment><comment><USER62> 1\. Stop teaching OOP with C++. 2\. Document the anti patterns.

OOP is not bad otherwise. I can't see how GUI frameworks can be easy and powerful without OOP.

</comment><comment><USER63> I'm a simple man. I don't have an advanced education in computer science (I did have a SICP-inspired first course in programming as an undergrad and an algorithms course in grad school using Dasgupta and Kleinberg/Tardos).

Like everyone who's doing stuff with data, I live in Python now. I'm fairly conversant in functional idioms (wrote a monad tutorial when it was all the fashion), but like objects because they're a straightforward way to keep data and code together in a bundle that can be passed around and serialized.

The typical situation for me is machine learning - I could have "fit_to_data" functions that return matrices or otherwise sum/product types (as they called it in Haskell) containing the estimated parameters and "predict_from_param_struct" functions, but having the whole thing in a bundle erases the whole problem of having to remember a weight matrix comes from a logistic classifier and not a linear regressor. That, or use an idiom like

         data LogisticParams a = LogisticP (Matrix a)

(I don't remember Haskell syntax anymore) but I'm not sure how I'm better served by that. The scikit-learn-type idiom where every regressor is expected to have .predict and .fit methods helps me build new regressors while reutilizing all of the scikit-learn cross-validation/hyperparameter search tooling. The idiom above would require me to study the hierarchy of types upwards and whatever advanced features of the language they're using; but even if the scikit-learn team is using features of Python outside my understanding (say, async, or low-level numpy/communication with C libraries) I'm still able to adhere to a convention.

\---

That said, have y'all ever heard of Formal Concept Analysis [1]? It seems to me that a lot of the malaise about OOP is that tutorials and examples and maybe even production code (what the hell do I know) are struggling to define ad hoc concept hierarchies -- is it Kitchen.Lights.off() or Lights.off("kitchen")? What scikit-learn (and the universe around it that tries to adhere to the dialect) is simply to embed data (parameters which are derived from data) in code that knows how to use it. No one's trying to decide how TopologicalSpace.MeasurableSpace fits with IntegrableFunctions.ProbabilityMeasures...

[1] [https://www.researchgate.net/publication/275540145_Formal_Co...](https://www.researchgate.net/publication/275540145_Formal_Concept_Analysis_- _Overview_and_Applications)

</comment><comment><USER64> Give a man enough rope and he'll hang himself.

</comment><comment><USER65> > The vast majority of essential code is not operating on just one object – it > is actually implementing cross-cutting concerns. Example: 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?

You have a function that has access to these objects. Based on that it will update the player and monster.

        Function onAttack(from as player, to as monster, weapon)
        player.addXp(weapon.xp)
        monster.addHealth(-weapon.damage)

Probably you'll want to have immutable data instead of mutating this.

(I'm on mobile so I can't put too much code)

The reason you do this is to decouple code. You don't want the player to be aware of the monster, at least not in this scenario.

</comment><comment><USER66> I completely agree. For a DataStore in Python, I may often use a Pandas DataFrame or such. For random label-based access it can have an index too.

Unfortunately, when asked to design an OOP architecture in a job interview, if you don't adhere to its religious enterprisy notions, you can risk failing the interview.

</comment><comment><USER67> "OOP apologists will respond that it's a matter of developer skill, to keep abstractions in check."

In my experience, the proliferation and use of ORMs makes keeping abstractions in check nearly impossible... in fact, I see ORM use as the primary design decision leading to the bastardization and convolution of sound OOP design.

<comment><USER31> The conversion is about OOP, not ORM

</comment></comment><comment><USER68> Yeah I agree so much. OOP is good when you are in school and you a have perfect use case like Vehicule, Car, Bicycle, but when you work on something else, you end up with abstract, absurd and bloated objects. OOP is only profitable for IT consultants, because they can sell books and bill many hours working on this mess.</comment>


"The governments don't rule the world… Goldman Sachs does" - <AUTHOR> http://www.youtube.com/watch?v=lqN3amj6AcE

<comment><USER2> In the comments a viewer had a good observation: this trader makes his money as a speaker, and fear mongering probably helps his bottom line.

That said, I live in Europe/Spain and I'm perfectly aware that A) a bailout of Spain would be nearly impossible considering the size of the economy here, B) any return to a past currency, like the Peseta, would constitute a massive default, C) a default would fall heavily on German Banks who hold these debts, pushing Europe's lead economy into danger, and/or a bailout would also have to be funded by Germany among other countries with similar effect.

Thus, it's like a dead-end street and I think that marginal markets (Spain, Greece, Italy, etc) should immediately remove speculation from the trading of their debt by limiting the use of options, short sales, etc. It increases short-term risk, but what a terrible situation when outside forces (or outside speculation) push your country into bankruptcy.

<comment><AUTHOR> Yes, I had the same thought. By appearing on BBC with this powerful message, he's created a viral campaign for his services.</comment></comment>


Bringing First Timers to PyCon Through Financial Aid - <AUTHOR> http://pycon.blogspot.com/2013/03/bringing-first-timers-to-pycon-through.html

<comment><USER2> This year was my first PyCon ever. Being a student, I did not have the funds to pay for a 4 night hotel and a 600$ flight. I really wanted to go, so I just decided to put what ever it would cost on my almost full student line of credit. Thanks for the this financial aid, I was able to reimburse everything, and my final cost for attending PyCon was near zero.

While being at PyCon, I also decided to help the best I could. I was a session runner for 4 different tracks. This led me to meeting amazing people (Doug, Dave, etc) and having a few minutes private talk with the speakers as we rushed down the stairs to their room.

Overall, what really amazed me during the weekend is the community itself. I still can't put words on how incredible the outreach that the community is trying to accomplish is (Financial Aid, PyLadies, The Yound Coder, Poster session, etc). This is what makes PyCon and the Python community so unique.

<comment><USER3> This is why having a way of getting people who deserve it but cannot afford it is a very good thing for conferences. I hope more conferences adopt it as a policy.

</comment></comment><comment><USER4> That was awesome. I couldn't go to PyCon without Financial Aid. This is the biggest amount of aid I've ever heard in a conference. 100.000$ is really big.

Conference was hillarious, I was glad to be there. Thanks all for the aid program.

</comment><comment><USER5> It would be great if that blog post ended with a big "Donate" button so that after reading the great story I can give money to help fund some scholarships for next year.

</comment><comment><USER6> I don't really want to go if I can randomly lose my job.

<comment><USER3> Seriously, that issue has been talked to death and this isn't the place to reignite it.</comment></comment>


'Master key' to Android - <AUTHOR> http://www.bbc.co.uk/news/technology-23179522

<comment><USER2> >'Master key' to Android phones uncovered

Well isn't that just a terrible headline.</comment>


13M people tracked over 300 years to build massive human family tree - <AUTHOR> https://arstechnica.com/science/2018/03/giant-human-family-tree-traces-how-people-moved-and-married-over-300-years/ <comment><USER2> How long before we simply hit 'go' on a relatively dumb AI that can methodically work through all recorded data? It feels only a few years before most of what can be mapped, will be mapped.

This seems like personal data that is hard to obscure - I (As a private person) am assuming that this will be public record.</comment>


Some of Greenland's coastal ice will be permanently lost by 2100 - <AUTHOR> http://exactlyscience.com/archives/11867.html <comment><USER2> Blogspam copy of

[https://news.osu.edu/news/2017/03/31/greencoast/](https://news.osu.edu/news/2017/03/31/greencoast/)

with actual author credit (Pam Frost Gorder) cut out.</comment>


The web button budget, or why Starbucks cups don't catch featuritis - <AUTHOR> http://mortenjust.com/2010/03/25/putting-designers-on-a-button-budget/

<comment><USER2> I actually have a button budget. $400 this month.

I'd like to tell you "And they're kicking my old, cheap buttons' hindquarters in an A/B test" but that would be the exact opposite of the truth. _sigh_ Can't win them all.

</comment><comment><USER3> Can't wait for that kind of cups to be available. Not the projector, but the other stuff.

I could imagine it might actually be easier to achieve than one might think. Printable electronics...

Does anybody have good resources for printable electronics?</comment>


Hiku: Barcode scanner + WiFi = easier shopping lists - <AUTHOR> http://www.kickstarter.com/projects/934651649/hiku-lets-simplify-the-way-we-shop

<comment><USER2> Must be one of the most useless inventions ever created, already made obsolete decades ago by post it notes and pens.</comment>


Microsoft launches Azure Event Grid, a fully managed event routing service - <AUTHOR> https://techcrunch.com/2017/08/16/microsoft-launches-azure-event-grid-a-fully-managed-event-routing-service/?ncid=mobilenavtrend <comment><USER2> I'm from the Event Grid product team and happy to answer any questions.</comment>


Forking Docker will lead to more fragmentation - <AUTHOR> http://www.linux-toys.com/?p=745 <comment><USER2> Or it will lead to more choice, I do feel overwhelmed when I go to an American grocery store and I see an entire aisle full of bags of chips, and I say to myself why? Who needs bbq flavor or even kale chips? But somebody apparently does. So even if it nows takes more time to choose, choice is giving everybody exactly what they want. Anyway I guess only time can tell and predictions are difficult to make. Just in the recent past, there were good and bad results out of forks as this article describes [http://www.makeuseof.com/tag/forking- good-great-ugly/](http://www.makeuseof.com/tag/forking-good-great-ugly/)

</comment><comment><USER3> I see it more as market segmentation between enterprise and SMB development needs. Although honestly, for the companies that appear to feel it might be worth the effort to fork Docker, there are already other options: at the point it makes sense to fork Docker, building a different solution on LXC is not much further away.</comment>


One Year After India Killed Off Cash,  What Other Countries Should Learn - <AUTHOR> https://hbr.org/2017/11/one-year-after-india-killed-off-cash-heres-what-other-countries-should-learn-from-it <comment><USER4> The author is a known critic of the demonetization policy. This was a complicated decision and it is still unclear whether it worked or not. I personally know a lot of business owners and merchants who really hate Modi for this move - which I feel is a good sign given these are the very people who kept the so called black money hidden from the govt and were negatively affected. Of course, the GDP would fall given economic activity got affected at the grass roots level.

That said, there were some benefits 1) people would think twice before hoarding onto cash and keep it hidden from the govt 2) more people would use banking facilities as the govt basically forced a lot of people to create bank accounts and deposit cash there for easy tracking. Also, there are long term tax benefits for the govt too given now it has a snapshot of who exchanged how much black money (in old notes) with the new notes. As such, the answer isn't black or white here.

<comment><USER5> > it is still unclear whether it worked or not.

Didn't they report that almost all the cash came back - proving that there was basically no black money returned and the only people they inconvenienced was ordinary citizens with their hard-earned cash reserves?

<comment><USER6> In india two third economy was unaccounted. With demonetization everyone had no other option but to deposit it in to bank accounts. Which made a money trail.

\-- 2$-3$ billion worth of old currency IT department last year.

\-- The total tax base is increased. Evidence of this is that PAN card applications have increased 3x (Daily Issuance of PAN Nearly Triples Post Demonetisation), number of people filing tax has grown a lot [Income tax base expands by 9.1 mn people after note ban) and net tax collections is also significantly up. This is good for a lot of reasons. It makes the taxation fair and also can help government increased budgetary allocations.

\-- Economy is able to run normally with 20% lower currency levels.Which makes it harder for households to hoard money. When money is not hoarded, it makes for greater efficiency in the economy.

\-- Bank deposits have grown significantly

\-- Digital banking became a way of life atleast in the urban India.

<comment><USER7> > Which makes it harder for households to hoard money.

In other countries, we call this 'saving for retirement.'

<comment><USER8> If you are saving for retirement by hoarding cash and not investing it at least in bonds or the very least a savings account with some interest, you are doing it wrong, or you have breaking bad problems I'm not familiar with.

</comment></comment></comment></comment></comment><comment><USER9> While I wonder what makes HN interested about India's demonetisation, The biggest irony of Demonetisation is not how the ruling government started listing down auxiliary benefits as the intended objects, It's how rural Indian is always being ignored by the people who celebrate the success of Demonetisaion. We who live in Cities like Bangalore have got Card swiping machine with every merchant, Imagine a village where there is only a few ATM machines, That's where the real impact - the failure is. It may not be even captured by a metric like GDP but when you travel across the country - <USER2> just hopping from Station to Station but actually to places, you'd find it out!

Edit: Ppl celebrating demonetisation doesn't refer to HN but a broader group in India.

<comment><USER10> Travel to rural India and talk to a money lender. There was a nice much needed shake down. They were all sitting on cash that had to be pushed into bank accounts. This is a long term net positive in shedding light on the shadow economy which has been exploiting the unbanked rural poor for the longest time.

<comment><AUTHOR> just don't lie, for god sake

[http://www.thehindubusinessline.com/money-and- banking/indias...](http://www.thehindubusinessline.com/money-and- banking/indias-rural-economy-hit-hard-as-informal-lending-breaks- down/article9391669.ece)

<comment><USER11> Wow so in your reality what was reported about money lending one year ago, one week after demonetization still holds? All the money lenders in India went into retirement is it?

Go find an article on what moneylenders are doing today. They are still lending. But from their bank accounts not from under their mattress.

Just blind reactions without knowing how the world works has become very fashionable today.

<comment><AUTHOR> This is after a month - [http://www.business-standard.com/article/economy- policy/10-i...](http://www.business-standard.com/article/economy- policy/10-interest-rates-money-lenders-make-a-comeback-due-to-currency- shortage-116122601048_1.html)

</comment></comment></comment></comment></comment><comment><USER12> The only winners are the credit card companies and the banks here. Getting rid of cash is the final step of their financial prison for the average Joe.

<comment><USER13> So large chunks of a country not paying any taxes is an OK place to be?

Unclear what the right solution is but clearly there was a problem.

<comment><USER12> ", the cash component of undeclared wealth in India was estimated to be only about 6%. In other words, the policy instrument was aimed at the wrong target: most undisclosed wealth is held in noncash assets. " And this is not only true for India.

<comment><USER14> That's wealth, not transactions. Digital could still bring to light "under the table" taxable transactions.

<comment><USER12> The problem is that its a digital prison for normal people. If there is no cash then bank accounts, CC and transactions should be free, as cash is free itself. But they are not. It's just a money making machine for banks and CC companies. Furthermore if people want to hide something they'll manage, especially if it about big money.

<comment><USER14> Technically paper money is not free either, people support the paper money machine with their taxes and in the cost of goods. Money must be printed & reclaimed & replaced, bills must be counted & sorted & transported, etc. Any currency system has overhead, the paper money overhead is just very hidden.

So if the fees are appropriately low, a system of private banks and CC's could be ultimately similar in cost to normal people.

</comment></comment></comment></comment></comment></comment><comment><USER15> The most relevant quote:

> Third, in a recent analysis of income tax probes, the cash component of > undeclared wealth in India was estimated to be only about 6%. In other > words, the policy instrument was aimed at the wrong target: most undisclosed > wealth is held in noncash assets. All of this data was readily available and > should have given the policy makers pause.

Assuming the data is correct, demonetization was flawed from the beginning.

</comment><comment><USER16> When I was riding my kick scooter, I had this recurring thought: What would my trajectory be if I would to roll my steering handle by 180 degrees?

I never got to try, but India did.

<comment><USER5> Best part of demonetization - the free policy lesson for every country.

<comment><USER16> Well, North Korea did similar things five years prior, with similar results. Not everybody got the memo.

</comment></comment></comment><comment><USER17> The title itself is a misnomer. No one checking stuff in HBR? Only denominations of 500s and 1000s were made illegal. This was replaced with new 500 and 2000 Rupee notes. All the other denominations remained valid throughout.The intent was to control counterfeit currency. It also appealed the public to use more digital transactions.

Today, in TV there was news about a district in Kerala (Malappuram) having 50000 crores worth of old currency in the hands of various people there. The person whom the reporter interviewed was an agent who sold these old notes to some people for a percentage of the value of the old notes. They didn't say for what purpose the old notes are bought. A friend of mine who knows some Gujrathi cloth merchants in Kochi's main market was told these old notes are bought so that its thread can be taken for counterfeiting new notes.

<comment><USER18> 5000 crore. in Kerala.

Theres so many things that raise flags there.

Thats a non trivial percent of the missing cash, whihc is very unlikely to be in one place.

Kerala gets most of its money via remittances, the idea that they would be a store of cash, especially when most of people convert it into gold around India anyway, makes it extremely hard to accept just from the face of it

<comment><USER17> It is not in one place, but in the hands of different people. Hawala ([https://en.wikipedia.org/wiki/Hawala](https://en.wikipedia.org/wiki/Hawala)) is very active in certain northern districts of Kerala.

I agree, its a fairly non-trivial amount of money.

<comment><USER18> Heh, even hawala couldnt account for those numbers.

Total amount demonitized is 15.44 lak crore, 15.28 returned.

thats .16 lakh crore - or .16 * 100000 = 16000 crore missing.

and 5k of that is in Kerala.

It stretches my credulity.

<comment><USER17> Even I am not sure who is correct here. Either the guy is lying about the amount or the Govt is lying about amount received. Things aren't quite clear here.

There's this thing which goes by the name "Kunjalikutti fund" which isn't that trivial from what I heard ;)

<comment><USER18> The govt isnt lying - if they were the economy would lose altitude and correct at a much lower level - thered be no reason to keep faith in any of the govt numbers, and we would have moved much closer to banana republic status.

If the govt wanted to lie, they would have put up better numbers - meaning a _larger_ gap between money demonitized and money received.

<comment><USER17> An old report on Hawala: [http://www.frontline.in/static/html/fl2123/stories/200411190...](http://www.frontline.in/static/html/fl2123/stories/20041119002903301.htm)

</comment></comment></comment></comment></comment></comment></comment><comment><USER19> Lesson one: Payment processors are taxing bodies. The degree to which your society operates without cash is the degree to which your governing bodies lose all control over the supply of money in your nation. Value of your currency is handed over to payment processors who do little beside moving numbers from place to place, and charge a percentage cut of every such movement on the fictional basis of moving larger numbers somehow costing more or being a harder service to provide. Should the payment processors wish your currency to be in greater supply, they will lower their rates. Should they wish to restrict the supply of money, they will raise them. Their influence is more flexible and has many fewer restrictions than stodgy old things like 'central banks'.

<comment><USER20> So a digital Fed. Who says a government can't regulate the payment processor?

<comment><USER19> They certainly could. And I would argue that in the USA right now they absolutely should. If not providing a modernized federal ACH system that can handle realtime funds transfers, then at least by absolutely and criminally forbidding charging a fee which scales based upon the amount of money changing hands (a small flat fee would be warranted, the problem is that they charge more just because the numbers are bigger which is nonsensical, we're not talking about them extending credit or doing the liability hot potato that credit card transactions are, this is just pure transferring from one account to another). Ideally the government would establish their own cryptocurrency, but I think that ship has sailed. Society in general has accepted that the standards of cash - anonymity, non-traceability, non-freezability, etc - <USER3> simply too dangerous to trust people with.

</comment></comment></comment><comment><USER21> Wasn't something like 99% of the targeted cash, ultimately redeemed at par value? If so, it was quite ineffective...

<comment><USER22> That was the goal.

<comment><USER21> No, that was not the original goal, which was to strand and demonetize the black money.

After that failed, they changed their stated goal (after the fact).

</comment></comment></comment><comment><USER23> You can't kill off cash or other forms of anonymous payment. Humans will always find a substitute. Stamps is an obvious choice.

And then there are cryptocurrencies, which are about to teach the world economists all kinds of lessons.

</comment><comment><USER24> This is one of the largest transfer of money from individuals & small businesses to corporate sector. Since notes were denotified, people had no choice but to move to businesses which could support digital payments. This led to huge loss of business for smaller players who were dealing in cash and a drop in economic activity. And the small businesses are the ones which employ highest number of people, so the subsequent job loss. Additional domino effects is loss of man hours spent in exchanging the notes and the general anxiety it caused amongst people. Moreover data shows [1], the whole exercise only caused a temporary change in behaviour & cash in back in vogue, so essentially a pointless & damaging exercise.

[1] - [http://www.livemint.com/Industry/S0AwBRAYuGbJw0SoXOaUaO/One-...](http://www.livemint.com/Industry/S0AwBRAYuGbJw0SoXOaUaO/One- year-after-demonetisation-cash-is-still-king.html)

<comment><USER25> Those small businesses were the ones taking cash only, paying employees in cash, and generally continuing the trend of no one paying any taxes what-so- ever.

Of course they could employ more people- they were unfairly competing with the companies that were following the law. I have a hard time sympathizing.

<comment><USER18> Unfairly competing?

Thats the weirdest example which doesnt describe India.

<comment><USER22> It does, not paying taxes is unfair competition.

<comment><USER18> against who?

Most of those firms earn less than the barrier for payment being required. So which taxes and who?

<comment><USER25> How would anyone _know_ if they're below the taxable level?

Paying taxes shouldn't work on an honour system. Not reporting income is tax evasion, which is what the Indian government wants to stop.

</comment></comment></comment></comment></comment></comment><comment><USER26> All the destruction that was unleashed in its aftermath, could have been avoided, if PM Modi had heard the best economist he had at his disposal, and not an accountant masquerading as one.

[http://www.huffingtonpost.in/2017/11/07/a-year-later-it-s- sa...](http://www.huffingtonpost.in/2017/11/07/a-year-later-it-s-safe-to-say- this-if-only-modi-had-listened-to-the-economist-he-had-at-his- disposal_a_23268888/)

</comment><comment><USER27> If I were to make a statement on this, I'd say that other countries shouldn't attempt such an exercise, and if they do, they should certainly look at how it was done in India as a classic case study of "how not to do it." There's close to nothing that came as a benefit from this exercise. But the so called "collateral damage", that the richer classes ignore, on people's livelihoods, their very lives (many people died) and the economy was significantly bad.

The "first cashless village in India" touted during that time has gone back to using cash. [1]

Dreams about digital money alone won't do. There's a long, long way to go on telecom/Internet infrastructure improvement, availability of electricity, availability of devices that are easy to use, education and awareness on security, etc.

I believe any future government in India would be downright foolish to consider doing such a thing again. Now all that the government has done by eliminating the Rs.1000 note and introducing the Rs.2000 note is made it easier to hoard and transport large sums of cash.

[1]: [https://www.bloombergquint.com/demonetisation-one- year/2017/...](https://www.bloombergquint.com/demonetisation-one- year/2017/11/07/cash-is-king-again-in-indias-cashless-village)

</comment><comment><USER26> BBC nails it better.

      Invalidating 90% of the stock of currency notes to catch 6% of illegal wealth was a clear case of using a hammer to kill a fly.

      The rationale of a crackdown on counterfeit notes was also misleading since India's central bank's own estimate was that fewer than 0.02%

      India's stock of high-value currency was growing in line with GDP and the share of such currency in India's GDP remained constant at around 9% for half a decade

[http://www.bbc.com/news/world-asia- india-41896865](http://www.bbc.com/news/world-asia-india-41896865)

</comment><comment><USER26> Narendra Modi fulfilled just 9% of his poll promises [http://www.electionpromisestracker.in/governments/central- go...](http://www.electionpromisestracker.in/governments/central-government)

</comment><comment><USER26> Slipping GDP growth, declining private spending and investments, falling jobs, decreasing industrial production, rising inflation, and rising current account deficit. [https://qz.com/1090478/no-matter-how-hard-the-government- tri...](https://qz.com/1090478/no-matter-how-hard-the-government-tries-it- cant-sell-indias-growth-story-to-the-world/)

</comment><comment><USER28> I live in a country that is rapidly becoming cashless.

This was not a government program. It happened naturally and was deemed to be in the best interest of all. At every purchase people can freely choose to use cash or a card/phone.

An advanced economy, low corruption, efficient banking system, top level infrastructure and supreme faith in civilization are not things you can just implement.

</comment><comment><USER29> >"It most recent GDP growth figure has fallen to 5.7%, and part of that, too, can be attributed to the policy move from last November."

It would be interesting to quantify what "part". AFAIK GDP growth has many contributing factors both short term and long term. It would really help readers to better comprehend the affect and also help policy makers to be cautious going forward.

>Lesson One: Choose Your Experts Carefully : Agreed, we must choose our experts carefully. However, author is silent on "how". Instead what author presents is his take on who are experts. I am not questioning the authors credentials but as HBR article, I expected authors to present a methodology instead of what seems a subjective view to me.

>Lesson Two: Don't Ignore Basic Data : Authors criticism that basic data was ignored seems more of a speculation. No concrete sources that such data was not consulted at all.

>Lesson Four: Beware of Digital Silver Bullets : Here I feel author selectively uses the citation to benefit his narrative. The very citation states the following verbatim. [http://www.moneycontrol.com/news/business/economy/digital- pa...](http://www.moneycontrol.com/news/business/economy/digital-payments- growth-dips-27-in-aug-from-peak-bhim-upi-to-take-charge-2380617.html) >"Still, it is appreciable that the numbers have not come down by a large amount. There are many who have permanently moved on to digital, which is a bigger benefit."

</comment><comment><USER30> The article axiomatically attributes demonetization as the reason for a reduction in GDP growth, even 3 quarters after the event. Is it that obvious as I don't see the direct connection - more currency flowing through official channels = increased GDP and taxes. What am I missing?

</comment><comment><USER31> I don't think anyone should be learning from India until they fix with their massive list of problems.

<comment><USER32> Can always learn, what not to do.

</comment></comment><comment><USER33> Many in India consider demonetisation a great thing, it's mostly the political opponents of Modi trying to defame it

<comment><USER5> Who does? Source?

<comment><USER34> BJP winning election in UP with huge margin is an indicator.

<comment><USER35> It's not... elections are not won by good policy. It's won by populist policies.

<comment><USER33> Yes but the argument for those who didnt like demonetisation (the corrupt ones with things to hide) was that poor people were badly affected. However one of Indias poorest states still went with BJP. The statement that poor people were affected was political spin, everyone was affected.

</comment></comment></comment></comment></comment><comment><USER36> kuddos to Indian Govt. for taking this step. South Asian economies are rife with black money and small vendors and regular citizens rarely pay taxes.

Any attempt to rectify this menace is a welcome step -- hopefully regional countries like Pakistan and Afghanistan can implement similar measures.

</comment><comment><USER37> Seems early to declare demonetization as a failure.

</comment><comment><USER38> 1) Lesson One: Choose Your Experts Carefully

The Trump administration would never make a mistake like that, would they?</comment>


Why does brainpicker run affiliate marketing scams on the side? - <AUTHOR> http://nostrich.tumblr.com/post/36619706595

<comment><USER2> Maybe she created these some years ago to earn some money, before she landed a full-time job as Insight Patternist at the large ad agency TBWA Worldwide. -- [job source: [http://www.nytimes.com/2011/05/05/fashion/05Twitter.html?pag...](http://www.nytimes.com/2011/05/05/fashion/05Twitter.html?pagewanted=all)]. Or her web-space got hacked and somebody placed these silently on her homepage to earn money...</comment>


Ask HN: How did you resolve intense disagreements with your cofounder? - <AUTHOR> <comment><USER2> There are quite a few ways to resolve any sort of disagreement one can find.

Without knowing more about your particular situation it is hard to provide useful advice.

However, a generic way to resolve any sort of problem is to base the decision, whatever it is, on an objective criteria as opposed to a matter of opinion.

If there is no objective way, one can ask for one or three outside mediators with no particular interest on the matter and ask them about what they see to be the right decision and why think like that.

I had a dispute with a co-founder a few years ago and with the help of a external party we came to an agreement completely different than the initial solutions each of us had in mind.

<comment><AUTHOR> Thanks tucaz, it'a great to hear how other cofounders deal with disputes. I'm trying to figure out the most effective methods great cofounders use to resolve their disputes/disagreements when making critical decisions about the company/product.

</comment></comment><comment><USER3> Make a bet. 10% ownership stake. If your cofounder is right, then they get a bigger share of the company. Otherwise, you do.</comment>


Google Chrome Cheat Sheet: Tips and Tricks - <AUTHOR> http://www.maximumpc.com/article/features/google_chrome_cheat_sheet_10_tips_and_tricks <comment><USER2> I love Chrome's incognito mode when developing. Let's say you're logged into your site checking things. Then you want to login as the admin without logging out and logging back in. Just pop open an incognito window and away you go!

<comment><USER3> That sort of thing is very handy when testing workflows between users on a system that uses cookies for session state, though is actually handled better by IE of all things.

Using "new session" from the file menu in IE8 (or just running a new instance of iexplore.exe (instead of just creating a new window) under IE6/7 if you have the "reuse windows" option turned off) you can create several independent sessions. There are not many cases when you need a lot of concurrent sessions, but there are a few I hit occasionally where four is useful (for instance a workflow where a file quality reviewer, adviser, adviser's supervisor, and a compliance officer all interact with the process at some stage).

You can do the same in Firefox but in a slightly more long-winded way: you need to setup independent profiles which is a little more faf initially. Each profile gets its own firefox.exe process and addin-ins, which can be handy: I keep a clean profile (no addins at all) for some testing (for instance to rule out an oddity being due to interaction with a particular plugin) without having to disable all the add-ins on my main profile.

</comment></comment><comment><USER4> The most important is missing:

Ctrl-shift-t: reopen last closed tab

<comment><USER5> and don't forget, easy access to incognito:

ctrl(cmd for mac)+shift+n

handy for testing session/cookie issues without having to reset everything

<comment><USER4> aka porn mode

</comment></comment></comment><comment><USER6> Does anybody know how to use a search engine other than the default from the omnibar? I see you can set a keyword under "Edit Search Engine", but then I cannot attach a query. (Say, "d" takes me to DDG's front page, but "d water" just googles for that, which makes sense.)

<comment><USER7> Search engine keyword are meant for exactly that. For queries to work though you need to configure the search URL: double-click on the DDG entry for the engine in the Manage Search Engine dialog and make sure its URL is set to <http://duckduckgo.com/?q=%s>

<comment><USER6> Thanks. I had set that up already, and gone back to Google as my default search engine since then (too traumatic a step for now!). However, I occasionally want to look things up through DDG. I have figured out how to do it now. (See my other comment.)

</comment></comment></comment><comment><USER8> Hadn't heard of about:DNS before.

While using it I was surprised by how pervasive Facebook is on the sites I visit.

<comment><USER9> you can also clear DNS cache here

chrome://net-internals/#dns

and it comes with a very handy HTTP req/response capture tool

chrome://net-internals/#events

</comment></comment><comment> tha-dude Chromium has a "Network" Tab in its development tools. In Chrome I cannot find it. Is there a way to bring it up? Why was it even removed (hidden) like that?

<comment><USER10> Are you talking about Chromium OS / Chrome OS? Yes, it is slightly different than Chromium/Chrome. I have both Chromium/Chome installed and I don't and haven't ever seen Network. It is present on my CR-48 though.

<comment><USER11> Did you get a free CR-48 ?

<comment><USER10> Yes.

</comment></comment></comment></comment><comment><USER12> This is not a cheatsheet. Who needs a cheatsheet for their browser? Damn title bait.

Nice tips still.</comment>


What is a Neural Network? No maths explanation - <AUTHOR> http://mussol.org/2018/05/28/neural-networks-no-math/ <comment><USER2> Very useful for beginners.

<comment><USER3> indeed

<comment><AUTHOR> thanks :-)</comment></comment></comment>


Life is quantum - <AUTHOR> https://aeon.co/essays/quantum-weirdness-is-everywhere-in-the-living-world <comment><USER2> Quantum Mechanics is real and has an important role in the low level "implementation" of Chemistry (I make my living from that). But this article is full of misleading (or almost wrong) parts.

> _Genes turned out to be made from a single molecule of DNA, which is a kind > of molecular string with nucleotide bases (the genetic letters) strung out > like beads. [...]And, just as Schrödinger predicted, 'every group of atoms' > does indeed play 'an individual role', with the position of even individual > protons – a quantum property – determining each genetic letter. There can be > few more prescient predictions in the entire history of science. The colour > of your eyes, the shape of your nose, and aspects of your character, > intelligence or propensity for disease are encoded at the quantum level._

This can also apply for the position of the atoms in a salt crystal, or the molecule of nitrogen in the air, or water or everything in the universe. So it's not relate to life at all.

> _Photosynthesis is the most important biochemical reaction on the planet. > [...] This energy transport process has long fascinated researchers because > it can be so efficient – close to 100 per cent. How is it that green leaves > can transport energy so much better than our most sophisticated > technologies?_

It's not very clear what he is talking about, but photosynthesis has many steps, and the global efficiency is very low (1%?). There are a few recent results of quantum coherence in one of the intermediate steps but 100% even in one step is completely unbelievable. Most of the steps transform one molecule into another and each can "store" a definite energy amount, so the excess must be wasted.

This article has many grandiloquent affirmations but few information. [https://xkcd.com/1240/](https://xkcd.com/1240/)

</comment><comment><USER3> And they are still some that deny the existence of an intelligent designer...</comment>


The Importance of a SIP Aware Firewall for the VoIP-Dependent Enterprise - <AUTHOR> http://www.mushroomnetworks.com/blog/2015/12/15/the-importance-of-a-sip-aware-firewall-for-the-voip-dependent-enterprise/ <comment><USER2> _Most SIP aware firewalls utilize SIP Application Level Gateway (ALG) architecture._

Verizon Wireless does this in the US, and it completely breaks most SIP applications, unless you connect to your server over a VPN:

[https://www.onsip.com/blog/in-depth-verizon-blocks-sip- traff...](https://www.onsip.com/blog/in-depth-verizon-blocks-sip-traffic- using-alg)</comment>


This is why I don't like autofill in web forms - <AUTHOR> https://twitter.com/anttiviljami/status/816585860661518336 <comment><USER2> I'm not sure I understand.

Does Chrome store your e-mail and address data for easy access in any website? So, if I go to amazon.com and put in all of my information, it stores it in some generic place rather than only amazon.com.

And then, if I go to smallgameshop.com, it offers to automatically fill out fields like Address and E-mail based on the info I provided to Amazon?

This is a problem here because said info fields are hidden so I actually don't know what I am auto-filling.

I don't think Firefox allows me to save a generic address/credit card/phone number to be used across all websites.</comment>


Lld - the llvm linker - <AUTHOR> http://lld.llvm.org <comment><USER2> When this was submitted 11 hours ago[0], amboar[1] commented[2]

        I found the design page[3] to be interesting reading

[0] [https://news.ycombinator.com/item?id=6157338](https://news.ycombinator.com/item?id=6157338)

[1] [https://news.ycombinator.com/user?id=amboar](https://news.ycombinator.com/user?id=amboar)

[2] [https://news.ycombinator.com/item?id=6157776](https://news.ycombinator.com/item?id=6157776)

[3] [http://lld.llvm.org/design.html](http://lld.llvm.org/design.html)

<comment><AUTHOR> Submitter here: I actually couldn't imagine that this hadn't been submitted before, but a couple of searches didn't turn up anything and the dup-detection also didn't pipe up...no idea why.

<comment><USER2> No idea why the HN dup detector didn't work. This search finds it:

[https://www.hnsearch.com/search#request/all&q=title%3Allvm&s...](https://www.hnsearch.com/search#request/all&q=title%3Allvm&sortby=create_ts+desc)

<comment><USER3> _No idea why the HN dup detector didn 't work._

Inspecting the source, one of the links has a slash at the end and the other doesn't.

<comment><USER2> Curious. That would explain the discrepancy, and indeed, when I look at the source it is as you say. However, when I hover over the links they are identical, including the slash at the end.

Most curious. It seems that FireFox lies.

</comment></comment></comment></comment></comment><comment><USER4> This is pretty much the last piece in the LLVM "puzzle", they've been relying on the GNU linker up until recently, which has made some optimisations more difficult to implement (notably whole program analysis targeting specific architectures)

</comment><comment><USER5> "It can currently self host on Linux x86-64 with -static."

Does that mean we can finally build true, 100% static binaries? I dream of being able to scp-and-run on an arbitrary Linux machine.

</comment><comment><USER6> To the developers: I'd strongly recommend reviewing the Solaris Linkers and Libraries Guide in your quest to create a new linker:

[http://docs.oracle.com/cd/E26502_01/html/E26507/index.html](http://docs.oracle.com/cd/E26502_01/html/E26507/index.html)

There are loads of generally useful technical details about ELF and linking in general that apply to almost any UNIX-like platform.

For example, full details of the System V Application Binary Interface (ELF):

[http://docs.oracle.com/cd/E26502_01/html/E26507/glcfv.html#s...](http://docs.oracle.com/cd/E26502_01/html/E26507/glcfv.html#scrolltoc)

Rod Evans and Ali Bahrami have decades of experience in this area and often added new functionality to the Solaris linker long before the GNU folks ever considered it.

Rod in particular has a very valuable set of posts with insight into linkers and related vagaries on his blog:

[https://blogs.oracle.com/rie/](https://blogs.oracle.com/rie/)

The Solaris linker was made to deal with crazy things like 4GB+ executables, multiple processor architectures, and hardware capabilities.

</comment><comment><USER7> from the page:

"End-User Features: ... * Remove clang's reliance on the system linker"

Very good news! full independency :) i was planning to embed clang in custom c/c++ compiler tools but the lack of a full linker library was odd, and in platforms where you dont know if theres a linker as in windows, it means you would have to distribute a vc redistributable with it, and rely on executing a batch operation for the linking process

Not to mention whatever optimizations that guys will be able to get their hands into in the linking process.

Nice work!

</comment><comment><USER8> It still seems weirdly unix-centric to talk about "the system linker" as though all systems include development tools as a matter of course. I'm glad they are continuing to build all of the pieces they need for a truly independent toolchain.

</comment><comment><USER9> People are still using SVN for new stuff?

<comment><USER10> For certain workflows and types of software projects and teams, Subversion performs admirably well.

There is a world outside of git.

(a world with the saddest, most rage-inducing branching model in existence, but a world nonetheless)

<comment><USER11> I don't think it's worse than the models for SCCS, RCS, and CVS, which I used in various projects before SVN. ;)

<comment><USER10> Well bless your kindly heart. :)

<comment><USER11> Thank you for sharing that. :)</comment></comment></comment></comment></comment>


Software NRSC-5 Receiver - <AUTHOR> https://github.com/theori-io/nrsc5 <comment><USER2> The whole shift to digital for radio is a bullshit exercise. Radio functionality does not in any way increase in some measurable way by going digital, digital does not degrade gracefully and analogue radio used hardly any spectrum at all to begin with. I really don't see why radios should need processors, it was a perfectly good medium that served a ton of people with limited access to technology the world over.

The only reason this got rammed through in my opinion is that it allowed for DRM to be imposed on radio.

<comment><USER3> Indeed, imposing DRM is the whole idea :) [https://en.wikipedia.org/wiki/Digital_Radio_Mondiale](https://en.wikipedia.org/wiki/Digital_Radio_Mondiale)

But there are some benefits which you didn't mention, such as including text & images in the broadcast for people without internet access, kind of like what Microsoft attempted a decade ago with FM subcarriers. There isn't that much bandwidth available for analogue AM radio either; using DRM would at least double that. And then there's the claim that switching to DAB allows for decreasing the output power, but I don't know if that really holds true in practice.

</comment></comment><comment><USER4> Some more information (I posted this yesterday but it didn't get much traction). I'm personally really happy about this project, because something about proprietary technology being used for general radio broadcasts rubs me the wrong way. I really wish we would have adopted a system like DRM (digital radio mondiale, not digital rights management) instead of the deceivingly named HD Radio.

[http://www.rtl-sdr.com/decoding-and-listening-to-hd-radio- nr...](http://www.rtl-sdr.com/decoding-and-listening-to-hd-radio-nrsc-5-with- an-rtl-sdr/)

<comment><USER5> I have always hated HD Radio from the pedantic standpoint that "definition" describes images and "fidelity" should describes audio.

<comment><USER6> They never said it was "high definition".

<comment><USER5> The codec is HDC, High-Definition Coding

[https://en.wikipedia.org/wiki/High- Definition_Coding](https://en.wikipedia.org/wiki/High-Definition_Coding)

</comment></comment></comment></comment><comment><USER7> For those of us like me who don't know what NRSC-5 is: [https://en.wikipedia.org/wiki/HD_Radio](https://en.wikipedia.org/wiki/HD_Radio)

<comment><USER8> And here is the standard: [http://www.nrscstandards.org/SG/NRSC-5-C.pdf](http://www.nrscstandards.org/SG/NRSC-5-C.pdf)</comment></comment>


What Happens When Maths Goes Wrong? – With Matt Parker - <AUTHOR> https://www.youtube.com/watch?v=6JwEYamjXpA <comment><USER2> This is an hour long, but I know the speaker, I know the material, and I find it engaging and entertaining. Your tastes might not be the same as mine, but I really like this.</comment>


First VR Headset with a 2.5K Display - <AUTHOR> http://www.roadtovr.com/gameface-labs-first-vr-headset-block-2k-display-mobile/

<comment><USER2> This headset sounds terrible. Resolution is the least important factor in presence (of resolution, persistence, latency, frame rate, tracking). It sounds like they have bubkis for the other areas, and low standards besides.

Oh and what is that higher resolution going to do for latency and frame rate? Hmmmmmm.

It kind of shocks me how uncritically positive this article is. The situation to me reads differently, more like "any joker can plug a higher-res LCD into an Oculus DK1 spray painted white."

</comment><comment><USER3> GameFace is putting the computer (CPU and GPU) into the headset itself. They may be about a year behind Oculus, but I think a self-contained wireless mobile unit could be more interesting.

Let the competition begin.

<comment><USER4> John Carmack has been working on an Oculus Android project since he joined the company.

<comment><USER5> Woah, can you point me to an article or something with more detail?

<comment><USER6> [http://www.engadget.com/2013/10/18/oculus-rift-john- carmack-...](http://www.engadget.com/2013/10/18/oculus-rift-john-carmack- interview/)

</comment></comment></comment></comment><comment><USER7> After reading this story it became immediately clear why Facebook bought Oculus: the VR war is in full swing. Virtual reality is a happening thing and before we all know it, every major company will have a VR headset they're selling.

Interesting thoughts below that Apple could be making a VR headset, I doubt they would be entering the market considering the lack of content, but for all we know Apple have been working with developers launch a new VR product with a lot of content.

Microsoft recently said they're not interested in VR, but surely they're not stupid enough to miss out on a potentially new market once more like they did with mobile phones and tablets, are they? I think it is safe to assume most companies are working on a VR product in some way, shape or form.

I think 2015 is going to be a very interesting year for VR. Exciting times ahead.

</comment><comment><USER8> Seems like a giddy puff piece. 2.5K is scarcely higher resolution than 1080 (1.9K) and they have far poor latency than Oculus and borrowed optics. Wireless is good though.

<comment><USER9> Is the latency that bad? Because you wouldn't want to go below the Oculus there; the Oculus is great because of it's low latency. More latency will just make people vomit and definitely not sell units.

<comment><USER10> Latency in general is bad. This is why theres a big rush to get DisplayPort 1.3 variable framerate monitors onto the market (should be out late 2014, early 2015)

</comment></comment></comment><comment><USER11> I have a hunch that Apple is working on a similar device too (and that is what actually motivated the Facebook deal; Zuck had inside information). Everything about the deal sounded that they don't want 'someone' to beat them to the punch. After all, it doesn't require anything else but strapping an iPod in the housing. A7 runs 2K display already very well on the iPad. There has been rumors of two new large iPhones, because Apple has sourced displays in two new sizes (4.7 and 5.7). Actually, one of them might be for the VR display.

</comment><comment><USER12> I do not believe a mobile GPU can handle rendering in 3D @ 1440P. Even desktop GPU's have problems rendering it at 75hz.

<comment><USER13> A $250 card from 2006 had no problems rendering in 3D @ 1440P at a solid 60Hz. Sure, it couldn't do Crysis 3, but there were games available that ran fine. Android games aren't anything like Crysis, a K1 should run most of them @2560 @75Hz without breaking a sweat.

<comment><USER14> For VR you want 120 Hz, to avoid motion sickness and you need 2 images.

<comment><USER15> I think what you say is true when the entire display is used for each eye, not when half the display is used per eye. (No need need to send a full frame that will be discarded by filtering glasses.)

</comment></comment></comment></comment><comment><USER16> Can someone tell me how headset manufacturers will differ from any other display manufacturers? Won't VR content eventually standardize to work across different headsets to reach the broadest audience?

</comment><comment><USER17> Was thinking the other day, VR is the perfect use-case for those outrageously high-ppi displays Sharp and Samsung have been showing off recently.</comment>


How To: Prevent Airplane Seats From Reclining - <AUTHOR> http://tech.nocr.at/hacking-security/how-to-prevent-airplane-seats-from-reclining/ <comment><USER2> The trouble is not bringing the zip tie -- that's easy to hide and hard to detect. The trouble is onboarding a tool to remove the zip tie, discretely, at the end of the flight. Otherwise, it may be fairly easy to determine who tampered with the customer experience -- and airlines do not appreciate the competition.

</comment><comment><USER3> so instead of dealing with the reclined seat, you can deal with some motherfu#%s jumping around like a 5 year old _trying_ to put their seat back repeatedly?

not sure that's the best trade.

<comment><USER4> Or, they simply look over their seat, notice what you've done, and escalate the situation.

You're usually better off talking to the person before engaging in technical fixes.</comment></comment>


Owned? Legal terms of video hosting services compared - <AUTHOR> http://advancingusability.wordpress.com/2009/05/06/owned-legal-terms-of-video-hosting-services-compared/

<comment><AUTHOR> And here I was thinking that Vimeo was pretty darn cool... Anyone have any rationalisation for:

 _VIMEO shall be entitled to unrestricted use of any Submission for any purpose whatsoever, commercial or otherwise, without compensation to the submitter._

?</comment>