skysight-inc/HackerNews huggingface dataset:
My kneejerk reaction is that this is BS but the text has good points and can function as an anecdote on how not to do things.

"... Large functions for which 80% coverage was
impossible were broken down into many small functions for
which 80% coverage was trivial. This raised the overall
corporate measure of maturity of its teams in one year, because
you will certainly get what you reward. Of course, this also
meant that functions no longer encapsulated algorithms. It was
no longer possible to reason about the execution context of a
line of code in terms of the lines that precede and follow it in
execution,"

Unit tests which break code are stupid. Refactoring is good, but just splitting a large function into smaller pieces does nothing to improve the value of code unless it's done so that there is an understanding of the algorithm available and communicated.

Everything can be abused if not used craftly.
Does someone really believe that cognitive dissonance is a bad thing, as the article suggests at the end? I've just always imagined that feeling bad for poor decisions is how you learn not to do poor decisions.
That's assuming the code even makes sense. Have you ever been looking at some code, having no precise idea what it does, with no commit history to give an explanation? That's when unit tests would be useful documentation.
I assumed you were replicating a part by making a mold. :)
Taking the position that linux needs to be unfucked is saying that it was/is fucked, and that systemd is the Savior that will unfuck it. Many people don't beleive that. But that they don't beleive linux is fucked doesn't mean they think it is perfect, because they know nothing can be. And while it is worthwhile to still strive for perfection, you don't do that by shitting all over what people know, their experience, blaming them for problems they didn't create, and making them do extra work. Especially when they are volunteers.
Just to add my two cents to the discussion, Typescript is implementing Non nullable types [1].
I think i'd be convenient that any language being used for large projects would support this feature.

[1] https://github.com/Microsoft/TypeScript/pull/7140
"Unit tests are [...] proof that the work that you just did is correct and you can move on."

Unit tests only can proof your software to be buggy. Even for the extremely simple "two, a function that, given no arguments, returns the number 2", your unit test can't verify that to be _always_ true. It may fail to return on Tuesdays (https://bugs.launchpad.net/ubuntu/+source/file/+bug/248619), internally use a web service that doesn't work on leap days (http://www.wired.com/insights/2012/02/leap-day-azure-outage/), other calls may overwrite the 'constant' it returns (http://programmers.stackexchange.com/questions/254799/ever-c...), etc.
Consolidate bay area government (ABAG) and come up with a comprehensive and cohesive growth plan (housing, transportation, taxes, zoning, etc.) Piecemeal reactive and Nimby policies are antithetical to the needs of the area. Forget about 1960s idyll. It's the 2010s, act like it. The area doesn't have to do growth Chinese-style, but we could to growth Singapore-style/Korea-style with North American values (i.e. less patronizing and more community involvement, up to a point)
NYC needs this too.
I could not agree more. I do however think fundamentals are important, our focus is just wrong.

The fundamentals and mentality need to change. However a wise man once taught me that it is human nature is to cheat and find easy ways out - which is why KPI's never work if they are implemented for more than six months or so. So it is necessary to keep goals fresh and change things every so often.

But more to the original point and a specific solution, more things should be taught of how to be an adult, morals, values, goals, communication, persuasion, how to do your tax etc.
The article says it's a good thing

>Although people may think cognitive dissonance is a bad thing, it actually helps to keep us mentally healthy and happy.
Toyota, Nissan seek battery breakthroughs
> The benefits are being able to have multiple targets for an interface, and being able to more cleanly unit test some systems in a strongly typed compiled language.

The benefit for DI/IOC for me is mainly not having to worry about how to compose the system.

If some new module I'm writing needs a particular dependency, then I just ask for that in my constructor.

I neither need to know nor care how to set it up or initialise it. That's taken care of by the container - either automatically (convention based registration) or by the maintainer of FooService.

This makes it dead easy to create smaller integration/test harnesses: run the normal container build step, and then resolve an instance of my class, out it pops with all the dependencies handled.
For the last three days, we've had a Teletype Model 14 tape printer following the Reuters RSS feed [1] at a steampunk convention in San Jose, printing hundreds of feet of 8mm paper tape. Trying to condense RSS down to all-upper-case Baudot tape printing is harsh. All markup is deleted. All links are deleted. Most characters outside letters and numbers become "?".

For the Reuters feeds, this works out fine. The content is text, not markup. There are few or no HTML tags. The Reuters feeds are headlines and a sentence or two. The Associated Press also has RSS feeds, and it's very similar. The Voice of America's feeds are much wordier; they often have the whole article.

Space News has an RSS feed.[2] The Senate Democrats have an RSS feed covering what's happening on the Senate floor.[3] (The GOP discontinued their feed.[4]) The House Energy and Commerce Committee has a feed with markup in embedded JSON.[5] Not sure what's going on there. Even The Hollywood Reporter has an RSS feed.[6]

So for real news, RSS is in good shape. RSS seems to be doing fine for sources that have something important to say.

[1] http://feeds.reuters.com/reuters/topNews
[2] http://spacenews.com/feed/
[3] https://democrats.senate.gov/feed/
[4] http://www.gop.gov/static/index.php
[5] https://energycommerce.house.gov/rss.xml?GroupTypeID=1
[6] http://feeds.feedburner.com/thr/news
I remember running FVWM quite comfortably back then on 16MB. I dual-booted with Windows 95, which also ran quite smoothly.
I just bought a jailbroken iPhone which I'll upgrade to a newer release supporting SMS handoff, etc; then use for running a message server so that I can send and receive synchronized messages on my Windows development PC the same way I can on my Mac.
Don't know enough about the latter two, but Facebook had the benefit of Zuckerberg being from an upper middle class family in a county famed for being filled with old money (& Wall Street money), Westchester County. Hard work obviously came into play as well, but these factors break the point for that example.
Panduan Umrah Haji
A tear-down starts at $2 million in PA, so you would need a combined family income of about $350,000 to qualify for a mortgage - just to tear it down.

Factoid: there's a house in downtown PA with a yard the size of a small farm. Of course, it was bought when the surrounding area was farmland.
Sure. But an awful lot of failures in refactoring in dynamically typed languages would be avoided by a static type system.

As it happens, I am a Rust fanboy with all that entails, so I (like everyone else in such discussions) am clearly biased.

My point was in jest, as the “;-)” (because HN simply discarded a U+1F609) indicated.
He poses the question asking what Object Oriented Programming paradigm is, and then responds that the obvious answer is the notion of Classes, Inheritance, and Objects. He then goes to correct that notion by suggesting that "what it's really about is...you figure out what the domain abstractions are for you, and here we give you these mechanisms to implement those. But in the end you don't write your programs with objects and classes, you write your program with the domain abstractions which you have defined."

This to me is a ridiculous statement. EVERY paradigm is about providing tools to handle the domain abstractions which we have defined. Object Oriented Programming is exactly and specifically defined by a paradigm expressed by Object instances of Classes, meant to embody Encapsulation, Inheritance, Abstraction, and Polymorphism. OOP clearly means something to this person that it doesn't mean to the rest of the world, but he strikes me as someone who has spent the better part of the last 2 decades in pure academia.
Well, that's sort of my point - with how many different items "could" be studied and quantified, not a single study has been produced to measure even one aspect just to say "we noticed no discernible change after the freezing process". There isn't even really a good baseline statistic for what the success rate is.

In the 30 some years I've been hearing the freezing idea, I find it really peculiar that nothing besides anecdotal evidence, not even amateur studies of just like a server farm testing failing drives or an IT desk recording their attempts that gives a sample size of more than ~10ish.

Conjecture and theories are great, and it's good to hear that these drives came back online. But, without exaggeration, I've tried this on hundreds of drives over the course of my career when doing IT support, and I can think of maybe 2 instances when after the freeze, the drive spun up long enough for data t be recovered. And everyone's stories seem to be this way - just this one or two times, after a freeze, it worked. There are no stories where a company comes out and says "man, freezing drives has saved our butts and customer data tons of times!"

I can't stress enough that this isn't a declaration that freezing doesn't do anything. But I feel the skepticism is absolutely appropriate given the voodoo qualities of the process and the overwhelming failure rate the process has. The lack of research on it and the fact that it's just a "hail mary" for most people rather than a cemented procedure just seems to me like the procedure is just ceremony, and that if put to any sort of actual trial, the success rate would fall well within the range of chance.
In most of Palo Alto, it's against the law to build anything but the most expensive kind of housing—single family homes with big yards. People who already bought in get to enjoy their walled-off neighborhoods at the expense of families with less money. It's nice that they feel bad enough about it to do something, but instead of legalizing cheaper housing on less land, they're trying to fund a lottery as a totem to make themselves feel better about the artificial affordability crisis they've created.
If anyone is curious, it's one of many Cognitive biases. For more of these check Wikipedia.

https://en.wikipedia.org/wiki/List_of_cognitive_biases
In case anyone is interested, here's another mirror of the CVE: https://marc.ttias.be/oss-security/2016-05/msg00255.php
That app is such a hunk of junk, on every platform. It's disgraceful.
Think about something you wanted and couldn't have. You probably tried to convince yourself you didn't want it anyway, and it was better for you that you didn't have it. It certainly keeps me more happy! But I also try to be conscious of it and use it like a tool more than a crutch.
Functional programming by itself doesn't scale.
This is definitely an application for VR. You are rigged up in a room somewhere, and you become a gigantic robot building a ship or a bridge or something elsewhere.
I've got a Mac at home which I use for my own personal iMessage bot to do certain tasks in my house. I specifically left this Mac at Mountain Lion, since I sort of anticipated problems further down the line with the newer versions of OS X. I can probably safely upgrade to 10.10 but it was finicky enough to set up the AppleScript to work with my scripts.
> I have some other hobbies that leave me at risk for serious injury

I'm very curious what you meant by this, if you can elaborate. The first thing I thought of was skydiving, incidentally. :D

Also, just to clarify, you browse exclusively inside VMs that you then immediately destroy? That's neat, although it sounds like a lot of work.
Look I get that many people like to make these broad statements about the quality of one model vs the other, when the reality is that they do better for different things. OOP works really well for abstracting and creating easy to read and write code. Functional Programming works much better for data science related tasks. The truth is both are here to stay, and that is a good thing.
Another rant against OOP, while on the real world every successful mainstream programming language has some form of OO paradigm support, yes even the FP ones.

C and Assembly are probably the only non-OOP languages ones still left.
Previous discussion: https://news.ycombinator.com/item?id=11737232
The assumption is that yes, other modes are more hackable because they're running much larger kernels. The code inside TrustZone is supposed to be much smaller, more focused and thus more easily auditable.

Unfortunately the constant stream of hacks of TrustZone applets that amount to "I smashed a buffer on the stack and got access" make me think that too often people forget the "more auditable" part.
Thanks, very interesting reading. It can be valuable not just for games development but for any case when performance is important.
It's only 7 pages. People often exaggerate such things online.
>Facebook

No one denies that Facebook was built through hard work and perseverance, but how many people have doctor parents, a software engineer for a private tutor in middle school, admittance to the richest private boarding school in the country, a (former) best friend whose father is a wealthy industrialist, and a number of other untold privileges?

Using Zuckerberg as an example of a self-made person really hurts your argument.
Both are equally clear, and equally easy to type, so unless “++it” comes with a drawback, I see nothing wrong with the suggestion. If the compiler is smart it doesn't matter, if it isn't it will help.

Do you have anything particular against this suggestion ?
Just picking some nits..., but being on a separate die still can mean that it's in the same package.

https://www.google.de/search?q=multi+chip+package&tbm=isch
I'm sad that in this thread and https://news.ycombinator.com/item?id=11786193, nobody is actually talking about the technical arguments at play. I've only read the EWD692 "opening salvo" but already there are interesting things to point out.

EWD1303:

> The profound significance of Dekker's solution of 1959, however, was that it showed the role that mathematical proof could play in the process of program design. Now, more than 40 years later, this role is still hardly recognized in the world of discrete designs. If mathematics is allowed to play a role at all, it is in the form of a posteriori verification, i.e. by showing by usually mechanized mathematics that the design meets its specifications; the strong guidance that correctness concerns can provide to the design process is rarely exploited. On the whole it is still "Code first, debug later" instead of "Think first, code later", which is a pity, but Computing Science cannot complain: we are free to speak, we don't have a right to be heard. And in later years Computing Science has spoken: in connection with the calculational derivation of programs —and then of mathematical proofs in general— the names of R.W. Floyd, C.A.R. Hoare, D. Gries, C.C. Morgan, A.J.M. van Gasteren and W.H.J. Feijen are the first to come to my mind.

Backus as quoted in EWD692 (Djikstra attacks this):

> One advantage of this algebra over other proof techniques is that the programmer can use his programming language as the language for deriving proofs, rather than having to state proofs in a separate logical system that merely [sic!] talks about his programs.

From a perspective of a PL person like myself, these ideals are very compatible. Without correctness by construction, there is not enough proof reuse so formality will forever be doomed for niche applications (aka computers embedded in dangerous things). Likewise after trying out intuitionistic type theory--based things (e.g. Agda) separating the program and proof langauges just seems clumsy. Overall separating programming and proof whether spatially (seperate languages) or temporally (correctness proved after the fact) is bad, and the reasons hardly depend on the dimension of separation
I think most people would be more repulsed if a child's own parents mis-treated them, rather than if an orphanage did. The whole scale is just shifted up for humans. Bias towards "ownership" still exists.
No, Hydra works with every existing solution :) You can read more on this topic in the guide: https://ory-am.gitbooks.io/hydra/content/oauth2.html
I find "as the bishop said to the actress" to be a much classier version of "that's what she said", plus it can go both ways (as the actress said to the bishop...)
Ok let's stop writing UT and see what happens. Wait... we've already tried that, and we know the result pretty well:

1. In dynamic languages, simple type mismatches, wrong variable names etc. are now caught in "top level system level test". Yes these are bugs that should have been caught by a compiler had we had one.

2. There's no documentation as to how something should work, or what functionality a module is trying to express.

3. No one dares to refactor anything ==> Code rottens ==> maintenance hell.

4. Bugs are caught by costly human beings (often used to execute "system level tests") instead of pieces of code.

5. When something does break in those "top level system tests", no one has a clue where to look, as all the building blocks of our system are now considered equally broken.

6. It's scary to reuse existing modules, as no one knows if they work or not, outside the scope of the specific system with which they were previously tested. Hence re-invention, code duplication, and yet another maintenance hell.

Did I fail to mention something?

UT cannot assert the correctness of your code. But it will constructively assert its incorrectness.
https://github.com/rust-lang/rfcs/blob/master/text/0230-remo... and the PR/issue linked there.

There are also old mailing list discussions on rust-dev somewhere which discuss this IIRC.
This has been already thought of: https://en.wikipedia.org/wiki/The_Futurological_Congress
" Instead, papers are distributed in hard copy and speakers call out paragraph numbers to call attention to their most salient points."
10,000 hour rule 'completely' wrong? Not even according to the quoted article which says the number is somewhat arbitrary, though deliberate practice correlates with expertise.
> "But the point is that something like 95% of occupations are either skewed toward men or balanced, and you have to go looking hard for any skewed toward women"

I will now recommend that you look at some actually numbers. To take Sweden as an example, 78% of women and 82% of men are employed. 70% of all professions are skewed towards being male or female dominated.

Basic number awareness, do your 95% number above sound reasonable? Its not, and I do not have a hard time naming professions thats female dominate. I can just go down the list if you like, as the state produce statistics each year.

Dentist. Hair stylist. Psychiatrists. Veterinarian. Bank teller.

Above are some of the 90+% list. Want me to continue?

Nurse. Preschool personal. Teachers. Hotel and office cleaner. Animal husbandry personal. Administrative assistant. Chefs.

Want me to name a few typical male dominated professions?

Mechanic. Truck driver. Warehouse employee. Carpenter. Operator of heavy machinery.

Here, link! http://www.scb.se/Statistik/_Publikationer/LE0201_2013B14_BR...

Go to page 66. There is the 30 largest professions (as per number of employed persons). The left side is number of women and right side is number of men. Notice how the two side is almost identical in number of professions that are skewed towards a single gender?

Its not just nursing. Its not just about preschool. The IT profession is around 70% ratio of men. Veterinarian in contrast is often each year the the most sought after program in universities (counted as number of student applicants, divided by number of available seats), and it got somewhere around 90% ration of women vs men.
That's why people of the ancient times invented sandpaper.
Yeah, but that is just copying the other OSes, mostly mainframe features that are just relevant for a few selected souls.

As for the desktop, yeah the experience has improved, but still no proper GUI stack in place, all is built on top of X architecture.

Nothing compared to the work done at Xerox, DEC/Olivetti or even what Microsoft does at MSR.

I came to me thinking how similar the coding experience in Mac OS X, Android and Windows or the whole OS stack is to the way I experienced Oberon back in the day.

Yes Mac based OSes and Android have a UNIX kernel, but when using the official APIs for applications, one would hardly notice it.
This sounds completely agreeable in GPU programming.

It's not feasible to provide elegant one liner solutions. It's about managing a state for a quite complex piece of hardware and the exact point of Vulkan was to provide a bare-metal low-overhead API without complicated utility routines. So yes, it's supposed to be like that.
I think it went sideways when developers abandoned the menu bar accross the top of the screen like all OS X apps have, and all windows apps used to have, but are now hidden from view). I think this was replaced by icons because translation into other languages was difficult with the tools of the time, and is difficult now because even with web technologies like Angular and PoEdit making the tools side of things easy you still need someone who understands the language to do the translation. So text translations got dumped for icons, and oftentimes the icons are terrible (like the hamburger menu which is just awful imo).
In C++ it does, because they are different function calls.
Depends, if you use JWT you can cryptographically verify that the token and the token claims are valid. Right now, Hydra does not issue JWTs but it would be easy as pie to add that functionality.

Writing an integration guide for this is a very good idea. Hydra's APIs are validating all requests using that technique, but it's not documented.

Auth0.com is pretty cool, they have done some cool projects that help OAuth developers. However, they are overpriced imho. Hosting hydra is definitely something I will consider. Thanks! :)
Just to add another perspective. There is a (pretty sad but real) business case for unit tests (don't need be good just need to exist :( ). In some b2b/enterprise fields it is an excellent sales pitch to be able to say we have X% test-coverage or 500 unit tests OMG. The people that make the buy decisions want to sleep well no matter if it is based on sound reasoning or not. Test coverage is almost a "feature" (in the bad enterprise IT sense). Sounds less risky to buy the product with more test coverage. Less risk I can understand it's like buying insurance...which is great since insurance turns risk into a budgetable item...yes please sell me this awesome software with that high test coverage.

/cynic
Integrating that in lambda should not be hard. If you want, create an issue on GitHub and I will try my best.