skysight-inc/HackerNews huggingface dataset:
There are multiple issues, the fact that it's not properly passing validation state being the worst, IMHO.

Filippo Valsorda from CloudFlare has done a write up on it:

https://blog.filippo.io/komodia-superfish-ssl-validation-is-...

I found the flaw early on the 19th and attempted to contact Lenovo and Superfish to disclose. My mail bounced to their security e-mail boxes and I never heard back from anyone at the e-mail addresses that were sucessfull so I then reached out to Komodia directly and have been in communication with them since. They understand the flaw and are working to patch all of their software.

I've really been torn on this one. With the private in the wild it's not necessarily irresponsible disclosure at this point to go public, but I wanted to at least give the software vendor a chance, whether the community views them as deserving of that or not before publishing all the details of my own findings.
There aren't any laws preventing the doxing of everyone, while the gov can't do it, they can buy those services on the open market. So mass surveillance gets outsourced to corps and we have instant fascism.

So the flaw in the algebra is that the government can buy services for things it cannot legally do itself. Which means, doing or buying should be considered equivalent, to regular citizens it does. Corporations and governments have special rights where misdeeds are waved off with warnings or a change in position.
Why is YC funding this?
Article is unmarked PDF
> Otherwise, some OEMs have tried installing versions of Linux, with negative financial results. A few are still trying. The real problems are selling and supporting them.

The problem seems to be that they're always trying to put them on budget machines, which is completely the wrong market. It's chasing the customers who pinch the last penny and you're never going to make any money from them regardless. Meanwhile those customers don't know what an "Ubuntu" is but pick it because it's cheaper, and then you get overrun with support calls when they want to install Turbo Tax.

The place where it makes much more sense is the corporate and professional markets where the customers actually know what they're buying. An IT department which is just going to nuke whatever the OEM installs in favor of their own volume licensed disk image would be happy to save the cost of a [redundant] Windows license for every machine. And professionals like programmers and scientists who actually use Linux would appreciate being able to buy workstation-class hardware with official driver support.
The results of one study could mean anything and I agree it should not be emphasized to the public.

However, the term "scientific consensus" makes truth sound like a popularity contest and worse - a popularity contest by people who claim they are better than you. This appeals to the authoritarian nature of people, not their critical nature. It is basically telling the public they aren't allowed to think. It's not only a jerk thing to do, it discourages scientific literacy outside of scientific professionals.

Another problem with the "scientific consensus" is due to its political influence and nebulous definition it is rife for abuse. If there is no rigorous methodology to determine it in an accurate and replicable manner, then it can be whatever someone says it is.

I agree that we need some sort of way of determining scientific validity by taking into account many tests, theory and perpectives, but "Scientific consensus" (whatever that is) is not it.
I don't think it's that hard. Normally these are people with multi-generational wealth and power, top bureaucrats, board members, and politicians. Add to that corporations, governments, and other institutions as a whole. I think some people get distracted by race, gender, or modest wealth thinking those confer natural power and influence, and they do to a degree, but they're not a valid endpoint of outrage at Internet scale.
Ask HN: What are the benefits of a native desktop app vs. a web one?
Nowadays one can do pretty much everything with HTML5 capabilities. Given I've always loved native desktop apps over the Web ones, but can't really list the benefits anymore, can you share your thoughts regarding the topic? What do you prefer? Why? What are the use cases where a native desktop app suits better? Please, exclude video games from the reasoning. Thank you.
> can fool a person into treating it like another person

"perceiving something as something" and "treating something as something", different verbs. Turing tests aren't about treatment, they are about perception.

The field is wide open for thought tests or games on how to "treat" computers so I would say knock yourself out and make a better one.

The Turing test doesn't do a whole lot of good at answering those questions or for that matter any questions. Other than "will a computer be able to fool a human eventually".

The notion of machine rights existing at all is evidence that Turing's prediction that the way intelligence is thought of would change, but still most people would challenge the idea that computers think.

Maybe in another 65 years that will change further - and machine rights will no longer be a fringe idea.
Resource management is a necessary evil but usually not a primary concern of most applications. Therefore in an ideal world it should be abstracted away and you should not have to care about it ever. In this respect I consider a full blown garbage collector as closer to the ideal than automatic reference counting. But automatic reference counting is of course also a kind of automatic garbage collection mechanism, just with a bit of a different focus.

All solutions are not optimal, but unless you have really many allocations and dealloctions going on, have tight resource constraints or hard timing constraints, current garbage collectors are really good enough. Not that you can not shoot your feet by accidentally keeping large object graphs alive, but that is easy to detect, though sometimes hard to fix.

Some developers seem to have some kind of resentments against garbage collectors because real developers of course manage their resources on their own, but many of their arguments are not well founded. Garbage collectors nondeterministically pausing program execution to free unused resources is a common point, but they usually don't realize that automatic reference counting has the same problem - you never know when a reference count drops to zero and triggers the deallocation of the object possibly with a large object graph attached.
Incredibly, incredibly misleading title.
We use keypairs for identification. Usernames and passwords don't really apply to the current architecture
at least it manages to link to the wp page for 'glacier'
I haven't read the Vogelstein paper yet, but from the abstract it seems that when its talking about 'luck', its talking about errors in DNA replication. The rate of these errors is pretty constant in healthy cells (about 1 per duplication), so its pretty much a matter of luck whether you acquire a mutation in a place that matters or a place that doesn't, and it doesn't really matter who you are or where you are. He seems to be contrasting this to other mechanisms that cause mutations, like chemicals, radiation, or viruses. Sure there is 'luck' involved at the individual level once you've been exposed, but the point is if you reduce exposure across the population, you reduce incidence rates. With DNA replication, there isn't anything you can do to reduce incidence rates.
Interesting that it implements Lua 5.1 rather than any of the newer versions. Is it because LuaJIT implements 5.1, thereby making that the de facto canonical language version?
I'm glad you think so! :)
Flagged for transphobia.
There was a tweet about this today, thought I'd share

https://vine.co/v/OxmjlxdxKxl

https://twitter.com/_ryanmack/status/567795669848616960
The 'normal conference' (aka Startup School) does admit women.

I was admitted last year but couldn't attend. This event supports and encourages a community.

This will be my second and there isn't an event I went to last year (when I was starting my first company) that was more productive or helpful, including several I paid a lot of $$ for (this is also a free conference).

more here if you like: http://www.fastcompany.com/3042308/the-y-combinator-chronicl...
fun! wrote something similar a few years ago.
What sort of details are you interested in seeing drawn up? I can definitely put something together
Note that Netflix did not commission Marco Polo. It was originally developed for Starz http://en.wikipedia.org/wiki/Marco_Polo_%28TV_series%29#Prod... and only later picked up by Netflix.

It is also done by the Weinstein Company. The brothers have a long history of original content that others wouldn't touch, and turned out good. For example they did Tarantino's earlier works.

I would much rather they take chances and sometimes fail, rather than only bet on sure things. The latter leads to the sequel only mediocrity that is Hollywood's current output.
Sort of, CPython has both reference counting and a normal Garbage Collection. You can disable the latter and still avoid memory leaks as long as you don't have cycles
My favorite resource for learning how to test your code is http://getpython3.com/diveintopython3/unit-testing.html

Once you start testing your code, it's addictive. Testing gives you confidence.

- By forcing you to detail your requirements, writing tests helps you make sure that you're building the right thing.

- Testing lets you refactor your code with confidence -- if your old tests still pass after you refactor, your new version works the same way as your old version.

- Testing makes your code much (MUCH!) more maintainable. As long as your old tests still pass, you can be confident that the new code you wrote didn't break any of your old code.
Based on...what, exactly?
It's worth pointing out the Android devs finally started noticing this for Lollipop (probably due to their animations) and the API now has lots of places where it passes Java primitives instead of objects, which is the distinction between passing by value and by reference.

This is simply not true. The API has always been heavily based on Java primitives. They didn't even use enums in the older APIs, preferring instead int constants. (I hate that one personally). GC pauses have always been a point of focus for the Android platform.
You're assuming fans only care about fresh content and have seen everything in the past. Thats not true.
Interestingly enough, the company that wrote Superfish (Komodia) is based in Palo Alto, California.

I don't think it was malicious intent by Lenovo to install adware on user's computers, rather, they were negligent to the fact they were dealing with an incompetent software vendor.

I wouldn't hesitate to buy another Lenovo.
James Shore's TDDJS series is supposed to be excellent:
http://www.letscodejavascript.com/
> Not to mention alternative energy sources.

If I needed to rebuild civilization, that'd be the last thing on my mind.
It's not necessarily for institutional purposes.

I use it to view my own https traffic in Fiddler.
Protection of the Church and feudal system?
Febraury Week 3
Does this primarily refer to H.264?
Uremie TRATAMENTE NATURISTE
As far as writing tests... I'm sure you are testing your code manually yourself already, right? When you make a change, you do something(s) to make sure your change had the effect you wanted, and your software still worked. You just do it yourself, manually, and do different things every time of course.

Take those things, write automated tests to test them. Run the automated tests instead of testing manually, every time you can. Especially when making changes don't run the software yourself to see if your changes did what you wanted, write a test to do it and run that. The first time one of your tests catches a bug that you never would have expected, you'll be hooked.

"Test-Driven Development" actually refers to (almost) always writing the tests _before_ you write the code they test. Not everyone subscribes to this, at least universally. I wouldn't worry about that for now, I think if you just start writing automated tests every time you would have been manually testing, you'll be on the path and things will fall into place.
Well it certainly beats javascript on the fibonacci benchmark, clearly this is the language of the future.
For the most part, as you suggest, they're average/"normal" people. Many are probably young/immature but many I'm sure are not. If you called them on it, I imagine many would mumble a bit and say something to the effect that they were "just having fun."
I think this problem could be solved with relative simplicity: partially nationalize all patents based on publicly-funded research. The state becomes entitled to a percentage of royalties from the commercial fruits of all such research, and in return, it offers uniform percentage-based licensing terms to all comers.

In one sweep, we capture some of the value of publicly-funded science for publicly-funded science, and we get rid of patent trolls, and we strongly reduce the intellectual-property risk of building a product based on others' research.
I very rarely have any issues with Arch. Like, maybe once a year. And they're always easy to fix.

One big difference is I don't run a desktop environment (kde, gnome, or whatever crap is out there now). I suspect that makes things a lot less likely to break when I do updates.
Really, you start by starting.

First grab a testing framework for your language, if it's not built-in. Something that runs the tests in your project once you run a command.

Following that, add a test to a function in your project. You can start with an easy one. Try that and see what works, try covering corner cases, etc

Then you can go for actual TDD once you write new code.
Yes, if you can't distinguish between hardware and software you shouldn't be buying a computer from anyone.
C++ and Rust both provide reference counting pointer-like-things (shared_ptr and Rc respectively). C++ has been around for quite a while, of course, but Rust is pretty new, and deliberately eschewed garbage collection.
I watched it and it's painful. I got up to this part where the bearded dude says this:

> we're not doing it, its doing it.

Actually they, the spambot owners, are doing it and saying they aren't doing it is a 100% lie and is very untrustworthy. While there is a slim chance they have no control over the bot, we can expect technology to quickly give them an 'out' on that particular accusation. Autonomous corporations will be capable of building their existences based on a simple set of rules put into place by us humans, and running autonomously. They will literally be uncontrollable from the standpoint of the creator.

Excusing yourself from blame based on a presumed disconnect of intent has to be a type of cognitive bias as the argument "I'm not doing it, it's doing it!" is a fallacy.
I suspect that a lawsuit-happy society is a good part of it.

Having been on the other side a few times (the one who quietly fixed an error without acknowledgement), there are a number of other factors at work as well:

1. Sometimes, fixing the error is within my power but talking to the customer is not. For example, when I was at Google, I was an engineer - fixing a bug was something I could do merely with a code review, but talking to the outside world was forbidden by company policy, and I didn't even know who the people were that were authorized to speak to the outside world on company behalf.

2. Very often, the error is one of several dozen in a bug queue, and you just want to fix it and move on. Talking to someone - particularly a customer - is a big mental context switch; it means that 5 other people won't get their errors fixed at all.

3. Sometimes the error is a distraction from your normal job duties, you feel like you can do a good deed by taking 5 minutes of your day to tweak a config file, but you don't want it to blow up any larger than that, and usually once a user has your attention they feel free to ask you to fix all their other annoyances. This is a big problem with working on open-source software; I've never yet had a good deed take less than 5x the amount of time I budgeted for it, and usually involve a few people mad at me. (I often find out later that many other people are very appreciative, but the latter never seem to speak up).

I think the fundamental problem is a mismatch between our expectations as human beings, which are shaped by millenia of face-to-face interactions, and the reality of modern society, where we are just a ticket number to a faceless corporation. Internet companies like Google and Facebook have roughly a million users per engineer working on the product; Whatsapp has 50 million. Imagine the scale of insignificance of any one problem; by the numbers, a user of a consumer product is roughly as consequential as a hair on your head. That could be why we get such shitty service from basically every major consumer company out there.
Compact ed effective CSS animation loader
There've been a few stories recently about internet shaming and their lasting effects.[1] Ironically, this seems to have caused old photos and negative articles to resurface.

Now if you search for [Lindsey Stone] you will once again see the original photo and the negative stories about it.

Her personal site and LinkedIn profile (presumably created by Reputation.com) are at the bottom of page 2... That is, nowhere to be found.

[1] http://www.nytimes.com/2015/02/15/magazine/how-one-stupid-tw...
> The water would blow to the cold side and freeze there.

You missed the part where the glaciers on the night side get big enough to flow despite being frozen.
This should worry us all! Someone halfway intelligent has to do something other than finance, or standards of living will stagnate and fall even for the financiers.
Sure, you're welcome. If you would like to grasp where you can go with test driven development and continuous integration, check out this article: 'How Etsy Deploys More Than 50 Times a Day":
http://www.infoq.com/news/2014/03/etsy-deploy-50-times-a-day
(Btw. I won't say that deploying 50 times a day is a best practice in all cases)
Frozen Waves on the Great Lakes (Amazing Photo’s)
Yeah, addictive it is.

I remember last year contributing[1] to a 2048 python game, where the maintainer committed[2] test suite lengthy than my commit and He was doing it like a charm.

I think I should start from that very repository as I know it very well already.

1. https://github.com/bfontaine/term2048/commits?author=pravj

2. https://github.com/bfontaine/term2048/commit/6f9a46283c2cc0a...
State Department Trashes 30,000 Fobs After Hack
Jellybean and Lollipop didn't get better smoothness by replacing objects with primitives, the Android API is fixed by backwards compatibility requirements. They did it through a mix of better graphics code and implementing a stronger GC.

If you look at the most advanced garbage collectors like G1 you can actually give them a pause time goal. They will do their best to never pause longer than that. If pauses are getting too long they increase memory usage to give more breathing room. If pauses are reliably less, they shrink the heap and give memory back to the OS.

Reference counting is not inherently predictable and can sometimes be less predictable than GC. The problem with refcounting is it can cause deallocation storms where a large object graph is suddenly released all at once because some root object was de-reffed. And then the code has to go through and recursively unref the entire object graph and call free() on it, right at that moment. If the user is dragging their finger at that time, tough cookies. GC on the other hand can take a hint from the OS that it'd be better to wait a moment before going in and cleaning up .... and it does.

It gets even worse when you consider that malloc/free are themselves not real time. Mallocs are allowed to spend arbitrary amounts of time doing bookkeeping, collapsing free regions etc and it can happen any time you allocate or free. With a modern GC, an allocation is almost always just a pointer increment (unless you've actually run out of memory).

The problem Apple has is that their entire toolchain is based on early 1990's era NeXT technology. That was great, 25 years ago. It's less great now. Objective-C manages to excel at neither safety nor performance and because it's basically just C with extra bits, it's hard to use any modern garbage collection techniques with it. For instance Boehm GC doesn't support incremental or generational collection on OS X and I'm unaware of any better conservative GC implementation.

Some years ago there was a paper showing how to integrate GC with kernel swap systems to avoid paging storms, which has been the traditional weakness of GC'd desktop apps. Unfortunately the Linux guys didn't do anything with it and neither has Apple. If you spend all day writing kernels "just use malloc" doesn't seem like bad advice.
Oh, many of the people you list are indeed the endpoints of outrage at Internet scale--though some (like politicians) are certainly more visible than others. But we sort of expect politicians and the less-liked CEOs to be the regular targets of Internet vitriol and don't pay much attention when it happens. What described here is when it happens to people who aren't prepared for it and whose companies just want to wash their hands of the problem. (Note though the case of Brendan Eich--although it was a non-profit in that case which made the mob harder to ignore.)
> they were negligent to the fact they were dealing with an incompetent software vendor.

Was Lenovo's repeated downplaying of the problem also just negligence?
I'm an immigrant - but this is nonsense.

Out of the top 10, only Google (1 out 2 confounders) and Qualcom (1 of 7 cofounders) I'd count as companies that were built by real immigrants.

Incidentally both are Jews whose families left persecution in Europe (Italy and USSR).
Calaos: Open Source Home Automation
H.264/AVC, AAC, and MP3.
Long time ago I also didn't write tests. Now this software causes me the most problems. For start you shouldn't focus on testing with any methodology like TDD, BDD, etc., just ignore it. Better read about Right-BICEP, this going to help you shift way of thinking. Anyway after some hellish struggling you should be able always to think out tests before code.
Personally I love Uncle Bob's videos. He has some great TDD theory and work throughs - it is how I got started: https://cleancoders.com/

Specifically episodes 6 and 7. But if you have time - I recommend most of the videos
Hammurabi is cited by lawyers because it demonstrates some advanced legal principals that are still with us, specifically the separation of civil and criminal law.

There other, older, legal traditions but they rarely are relevant to modern jurisprudence.
For example:
http://developer.android.com/reference/android/graphics/Canv...

Notice the introduction of methods with API level 21 that recreate existing functionality without RectF objects being allocated. Touch events, for example, still spit ludicrous amounts of crap on to the heap.

All this is why the low latency audio is via the NDK as it's basically impossible to write Android apps which do not pause the managed threads at some point. Oddly this is stuff the J2ME people got right from day one.
Aside from the obvious problems with keeping an atmosphere, can tidally locked planets have a magnetosphere?
Plenty of people complain about SO but no one is stepping up to challenge them.