skysight-inc/HackerNews huggingface dataset:
The short answer is no. We're doing personalization instead of testing. It means that we're applying machine learning pipelines to deliver the best possible / most relevant content (page elements or landing pages) to every single visitor. Like, for example, if a page with product-video works better for people in the evening, and product screenshots works better in the daytime - we'll find this pattern and deliver the most suitable version based on visitor traits and behavior. While with testing approach usually only one variation is a winner, with personalization approach - all variations are the winners, cause they're working great for the specific group of visitors.

Regarding the question about multivariate - we're currently support only A/B personalization (create few variations and we will show the most convertible one) and Split URL personalization (when we're splitting traffic between multiple landing page URLs)
I'm not sure if it is so, but I would hope browsers attach an expiry date to each hash, not each hash set, and that hashes can't be revoked simply by later omission. i.e. if you have keys A and B, and an attacker takes your domain and sets a header solely for the hashes of keys B and C, I would hope that you can still use a cert built using key A until the expiry.
Dump a few hundred megabytes from /dev/random into an encrypted file with a provocative name. The thing every Cypherpunk dreams about.
This appears to be the rebranded AlchemyVision product from AlchemyAPI (bought by IBM last year).
Sounds like an Iain M Banks ship name.
He doesn't have to be a great artist, and the style lets him complete the comics in less time. Clearly his ideas are interesting enough that the comic is wildly popular regardless.
What you and everyone that is voting me down seem to overlook for some rather crazy reason (The only thing that makes any sense is protective defensive excuse making for Apple) is that they are shooting themselves in the foot. Sure, people buy the 16GB phone, usually thinking they are getting 16GB and thinking that is a lot without realizing that out of the box it's only 14GB and once they install some things and want to buy some music and take some pictures they are running out of room on double time.

Now they are stuck with a phone that is of an inadequate size in order to not only fully utilize it, but also it impacts developers and sales and companies that are constantly trying to push their incidental apps onto people.

I don't get your opposition to bigger storage when the increased storage would probably cost Apple literally next to nothing. Do you understan that the delta between the cost of 16 and 32 GB, let alone even 64 GB is basically negligible for them? It does not seem at all to be about cost, it's all about perceived price maximization, but I am rather certain their calculations either don't quite make sense or they are not properly considering and weighting their inputs.

I also don't understand why developers are not up in arms because Apple's foolishness keeps their app from being installed and used, which leads to decreased revenues. It really undercuts the whole ecosystem because people with 16 GB phones are not installing the hilton app, not installing the app for every airline, not installing health kit apps, not installing care kit apps, and not installing various other incidental apps that the ecosystem really requires you to have installed but take up way too much space to justify keeping installed on a regular basis.
> I don't see why we shouldn't be moving to languages like Rust given the chance, as C makes it far more difficult to write safe and correct code

I agree in principal, however the timing is wrong.

Rust is a very new language (less than 6 years old), and is undeniably totally unproven. It is the latest "buzz" language, and may not be around long term... nobody knows.

What-more, a full-fledged re-write of CoreUtils in Rust is unlikely to be used by any production environment, because this new CoreUtils will also be undeniably totally unproven. This is the same growing pains LibreSSL have been experiencing, lots of gung-ho fans, but very few actual users (outside of OpenBSD/FreeBSD) - and their undertaking is arguably a lot easier, since they're just cleaning a codebase, not starting from scratch.

Average users who just consume distro's are not going to switch to a new unproven CoreUtils (even if they knew how), and distro maintainers are not going to switch until it's proven either. It will take a huge company with a huge install-base switching and testing it in production for many years before others start to feel comfortable... however this is also an enormous burden on said mega-corporation, for little-to-zero perceived benefits.

Yes, in principal, it's "safer" code, but to a mega-corp with thousands of installs, the risk is too great. New bugs, language pitfalls, behavior potentially changing, etc. Perhaps Rust dies, perhaps it's replaced with an even better alternative. It will take a LOT of time to work all this out.

Flatly, re-writing a several decade's old, matured codebase in today's flavor-of-the-week language is not a good idea. It's a waste of time and effort.

Let the languages mature more, do more systems work that doesn't involve replacing the foundation we all stand on... and maybe, in 5-10 additional years, we'll see where Rust goes.
There are actually some cases where you can gain by losslessly compressing these. For example, EXIF data in a JPEG is plain text, so gzip can help:

$ curl -sS http://www.exiv2.org/include/img_1771.jpg | wc -c
32764
$ curl -sS http://www.exiv2.org/include/img_1771.jpg | gzip -9 | wc -c
31323

In this case, though, it often makes more sense to just remove the EXIF data.

PDF files can be even more compressible, at least ones that are text and layout as opposed to embedded images:

$ curl -sS http://www.polyu.edu.hk/iaee/files/pdf-sample.pdf | wc -c
7945
$ curl -sS http://www.polyu.edu.hk/iaee/files/pdf-sample.pdf | gzip -9 | wc -c
4336
"Without seeing it coming" might be a stretch here. When I was at BRU some month ago, the whole airport was patrolled by heavily armed military guards. AFAIK this has been the case since the Paris attacks.
Realistically? Never. If you're running on a UNIX system, libc is your only portable interface to the system. You can use the syscall layer on some NIX-like platforms (such as Linux), but it will leave you to replicate a lot of the work that it already does.

On Solaris, as one example, there is no stable syscall layer -- libc is your only interface to the system. There's good reason for that too; on Solaris, libc is updated with security and performance improvements on a regular basis for each new hardware generation and other improvements in the operating system. It automatically accounts for things that might cause pipeline stalls (think memcpy, etc.) in newer processor generations, and so on.

Now with that said, what you could advocate is that libc, etc. be rewritten in RUST, but exposed via the "C" ABI convention that RUST provides. It wouldn't be as great as native RUST, but it would still be an improvement.

There are no compelling arguments for getting rid of libc that I've heard yet for platforms where libc is well-maintained. On Solaris, there are strict compatibility guarantees for every interface, so applications can assume changes in libc will never break them as long as the interface they're using lists an appropriate stability level in the manual page.

A world where every language implements its own version of libc seems like it would increase the number of defects, not decrease them. We could of course argue that those implementations might be better than libc, but I think whatever possible benefit there might be there is lost in the likelihood that each language will have its own flaws in its implementation.

I believe the best view of an operating system is as a fully-integrated set of components. Everything from the kernel up to the system libraries should look and act consistently, and that's impractical to do if every component is viewed as interchangeable. Integration from top to bottom in an OS stack can produce incredibly great results and provide unparalleled reliability, availability, and performance.
I take kbenson to be saying that what Mr. Hipp claims isn't a problem for SQLite is or has been a problem for other projects. That is, other projects have been bitten by relying on undefined behavior (such as what a variable's initial value might be) that may have been consistent across a variety of implementations, and then suddenly wasn't. Perhaps it's safe to say that today we don't need to address these issues on this project in this language, but that's taking on technical debt and setting ourselves up for work in the future (that may be difficult to identify at that time).
Problem with that lies in different balancing.

For example, while banelings, are considered hard-counter to marines, stimpacked marines are still faster than even speed-banelings not on creep and just a little bit slower on creep. Pros use splitting to minimize damage, but here, as you can see, it can be just ultimate showdown.

Another example would be high templars vs ghosts. It is fairly difficult for Terran player to target high templars, but just two EMP shots basically puts templars out of combat, and miss of those shots renders ghosts mostly useless.

So, any area-of-effect attacks would be mostly useless due to infinite APM. That means minus colossi, tanks, banelings, thors and many other units. Probably that means that some race will be somewhat (or, maybe, insanely) overpowered (my bet is on Terran due to possibility of multiple drops, which themselves could be useless, though (because AI can't "miss" a drop), and stim-marine micro). So, the game will require massive rebalancing.
Portugal trolled it hard back in 2011, when we sent the "Men of Struggle": https://www.youtube.com/watch?v=4bDN53Rqh54
How We Got Our First 100 Customers (It Ain't Pretty)
Why does this site return status 500 but still work?
Heh kids these days, I bet the next thing you're going to demand is a consistent configuration format that all aplications will use! (a man can dream)
Signal does too. We're talking about contact discovery, not key verification. Contact discovery is the problem of, given a list of contacts, returning the ones that are on the service.

Contact discovery without the server seeing the list of contacts is hard.
Psychology is in crisis. Scientist's confession explains how we got here
I think the idea that "elite" developers can write bug-free C (or even just network-facing C free of security-sensitive memory safety problems) is pretty well refuted at this point. Now you can write bug-free C if you're willing to spend enormous time and money on testing: this is to a first approximation what SQLite did. But that only makes economic sense for a small minority of projects. Just putting "elite" developers on a C project, without the huge verification cost, is by itself not enough to eliminate bugs, as much as we as hackers would like to think it is.

(The one exception may be, like, DJB. But djbdns/qmail are very unusual C programs in many ways.)
> No one argued with that because what they said is true. Apple are simply out of the VR picture. At least for now.

Until they release their own VRKit.

> Good enough I suppose, given that soon after Steam Machines were released, Sony and MS rushed to announce that they plan to update their hardware more frequently. Competition works. It doesn't mean it won't get even better.

So what are those dangerous the numbers of Steam Machines running SteamOS sales?

Sony and MS have little to fear from those sales on a global scale, specially since most Steam Machines were actually being sold with Windows.

> You keep talking about it as if it's some single mind. It's not.

I was an IGDA member, attended a couple GDCE bot at London and Cologne, was part of the regular meetings of a game developments degree, had the opportunity to visit a well known AAA studios, including SCEE.

Didn't stay as my position in regards to private life is not what the industry expects from the majority of developers.

What is you experience on the industry?

> You can forget about OpenGL. I expect Sony to add Vulkan supprot first, and then MS add it under pressure a few years later.

Sony will only add Vulkan on their Android phones, because Google added it.

They will never replace LibGCM with Vulkan, when their API and existing tools can do so much more.
As a quick measure, you probably should have a simple feature list somewhere obvious. The code snippets on the front page are nice, but only show tiny aspects. Also, link to the example projects until docs are ready.

Right now it seems like a lot of great features are not presented at all.
I was making a general point using his statement as the impetus, not a specific point in the case of SQLite. Undefined behavior (specifically, developers relying on it being consistent) has caused many problems in the past, and will undoubtedly do so in the future. Relying on behavior which by it's definition is impossible to rely on, is not a situation I think we should be defending.
The Rust standard library does assume that allocation succeeds. The language itself knows nothing about the heap, and so you can write allocators that do whatever you wish. Side note: on most Linux distros, overcommit is on, and so malloc will basically always succeed; the OOM killer will kill your program before you'd get a failure. I am less knowledgeable about OSX and Windows.

I cannot speak to SQlite in this regard.
I actually noticed the same thing in Hawaii, lots of Japanese tourists
Is OSX affected?
Open source is useless if the majority of people in the open community -- for whatever reason -- can't build it.

If a person can't build the thing, they effectively have no power to contribute to changing it. If they have no power to contribute to changing it, it's... spiritually, missing the most essential parts of open source.

This is the fundamental issue driving comments like the quote above.

You can tell me that not having a dependency management system, not having a sane version control system, using "some" C compiler (sans a matrix of tests specifying a range of expected good compilers), arbitrarily fine-grained platform specificness meaning an average OSS contributor can never reasonably test their changes against all targets..... all of these things can be "worked around". But at some point, the litany of issues -- some of which take a new contributor dozens of hours to work around -- becomes a simply overwhelming barrier to contribution.

It's time to admit that a foundation of workarounds in FOSS development processes at the very core of our systems is a problem.

Re-writing it in language $x may not be the solution, but it's certainly understandable that there's a widespread desire for simply getting better toolchains underneath our most basic essential systems.
If it got people to update, then it worked.
Distributed Systems and The End of the API
I'm way ahead of you :)
Terrorist Attacks on Brussels (The Guardian Livefeed)
conda supports pip installation within the context of an environment (much more gracefully, in fact, than does virtualenv). So you're not giving anything up by using conda in this regard.

I don't see the desire to have pip as the baseline. For me, the conda packaging is much more informative and placing everything you need for multiplatform support into an /info directory with a meta.yaml is a lot more effective than going through the steps of PyPI. conda also makes uploading and hosting on anaconda.org extremely easy.

Normally there is the whole "gee, I don't want to learn another package manager" -- but conda / anaconda.org is extremely worth it. It really is a major engineering step forward from the existing package deployment strategies in Python.

I even configure my travis.yml CI scripts to download Miniconda, create a conda environment from a requiremenets.txt, and then build and test my code via conda on the contiguous integration VM itself.

The only worry is how strongly tied conda and anaconda.org are to the future of Continuum. Given how much Continuum speaks of open-source work, one would hope that these projects essentially live independently (or that forks of them would) but you never know. I do admit that is a major downside.
I don't think Twitter will receive the kind of donations Wikipedia does, from either individuals or institutions. The increasingly toxic nature of discourse on Twitter (whether you agree with what people are saying in a particular instance or not, most viewpoints end up being accompanied with death threats and doxing) makes it unlikely they can make a successful case for filling an important need of humanity.
vim (+ sh) cover all those things, except maybe the last two.
Observations on the Surveillance That Resulted in the Capture of Salah Abdeslam
joke image -> joke book. It's 4 pages (not to knock the content, I haven't actually read it. The author does say " The book is written in a deadpan manner.")
I don't see this as classic clickbait (as opposed to, say, "The shocking change at your kids' high school you absolutely must know about") so much as an attempt at cleverness, which is not uncommon for human-interest NYT stories even if it obscures the actual meaning.
For people who don't know the "New Coke" story, https://www.youtube.com/watch?v=WuMxXw9TeE4 is an interesting watch.

Americans take their soda very seriously (or at least did in the 80s). It makes the hoo-ha over Kraft buying Cadbury, a British staple similar to how Coke is/was an American one, and the changes they made since (some of them within days of the purchase despite having promised the government otherwise to get the deal to go ahead) look like a storm in a tea-cup.
Though I like ideas behind Rust but the code is awful. If you look at the code you'll see a lot of misterious symbols (as in Perl) and strange constructs like wrap, unwrap, Arc etc. They make the code less readable.

Also Rust doesn't have exceptions so you have to wrap almost any function call with let/match/Ok/Err. Ugly.

I looked at one random file which turned out to be a `du' command implementation: https://github.com/uutils/coreutils/blob/master/src/du/du.rs...

Are they really starting a new OS level thread for every directory found? Looks like an easy way to exhaust system resources to me. Also I don't see the code that would collect error information if if the thread panics.
It's still important to distinguish the two. The source code has bugs, but in the year 2016 it builds binaries that do not have bugs.
There are exactly zero records of prosecutions obtained using evidence collected by a detector van.

It would be one thing to detect an analog TV IF signal, another to triangulate its position precisely enough to identify a specific house in a street or room in a block - given that every other TV in the area would be generating exactly the same IF oscillator signal - and a third to prove the TV was tuned into a program and not being used for pong, a computer, or watching a video.

And it would be unnecessary. The licensing enforcers have always kept a record of addresses without a license. If - like me - you don't have a TV, you get a regular stream of letters threatening prosecution anyway, and an occasional knock on the door.

If you're an enforcer, the easiest way to check if someone has a TV is to look at a house after dark. Most living rooms in the UK are visible from the street.
Realistic Robot Lady Cheerfully Agrees to Destroy Humans
It's a philosophy you can apply to art.
Which is a better career launch pad. A large company or a medium size startup
I have two offers: one from a medium sized company and one from a very large company. This will be my first job out of college. The offers are comparable (both in the Seattle area). The positions are also similar, full stack at the medium sized and back end development at the large company.

I was wondering which will be the better choice in terms of solidifying my career experience. At the large company I see that there is brand recognition. The downside is that the team is mostly senior developers and it moves slowly. Of course working with senior is a benefit because I will get to learn a lot.

At the medium sized company, there are about 200 developers. The team is mostly young so I see more visibility and a faster work environment.

Both have good points and bad points. Then there is also the matter of the positions. If I work mainly in the backend, I can specialize in it. In full stack I become more versatile. Both options seem good but I feel full stack developers are more common. Nonetheless, I wanted to know what you think might be a stronger career launch pad.
Not to be too cynical (but here I go anyway)...but how long before it becomes "hey, instead of a few funny comics, let's do a whole textbook this way!"?

Then we continue the de-evolution into a mix of hillbilly, valleygirl, inner-city slang and various grunts.

Please forgive us, Mike Judge.
Indeed you are no art critic. And I doubt anyone would defend XKCD as great technical art (although some of its experiments are really cool and well thought out). It's just a medium for a message (and that medium suits perfectly the message and let's not forget the medium is the message anyway).

You might not enjoy it but if it's because of the art direction and art direction is what usually entertains you then maybe you shouldn't read it ? Don't try to believe you don't enjoy it because it's not up to your standards (or what you think is today's standard) when it really is not to your taste. Don't make it sound like it's an argument because it's not, it's a preference (which is as valuable and as good in its own right). FTR I upvoted you because I don't believe you should be downvoted because you badly defended your opinion.
What I learned from this: If you have to call your mommy when you quit your job, you're not ready to start your own business.

Also, 2 years after the call to mommy is not quite mature enough to start doling out advice.
More & better trained detective-type police can be useful, but the vast majority of any police force isn't doing detective work.
http://www.tesco.com/groceries/product/details/?id=266230936

Looks like it's ~$3 for a pack on this side of the pond.
127M More Ways to Move DoorDash Forward
https://news.ycombinator.com/item?id=11290577
SymPy Gamma: An Open-Source, Python-Based Alternative to Wolfram Alpha
Man Hunting, the Sport of Security Forces
Show HN: LevelUp.pm – Evergreen Product Management Resources
> Git makes it easier to accept contributions and code review from a larger developer community, thereby allowing building a higher-quality product.

It is very easy to contribute if you know git. But you can mess it up if you don't know. I made a two-line bugfix patch to flycheck, and heck, I was nearly pasting the patch into a comment in issues because I didn't know anything about how to make a pull request on github and how to commit so that the puller would be happy. I didn't want to do sth. embarassing and spent two hours reading and reading how to submit my patch properly. And the whole fix was made and tested in about two minutes. If only I was able to submit a dumb patch, I wouldn't have to care if they used git, cvs, or tarballs and quilt.
Supernova shockwave seen with visible light for first time
Silicon: C++14 web framework
We are witnessing the rise of global authoritarianism on a chilling scale
Autocompletion: YouCompleteMe + racer + racerd

Source formatting: rust.vim + rustfmt

Automatic building: https://github.com/passcod/cargo-watch

Error display: tmux, terminator or iTerm2 split planes

Rust has pretty good tool support in vim and Atom, for example (can't speak for the rest). We don't have stellar IDE support yet, but it's on the to-do list: https://www.rust-lang.org/ides.html

Personally, I don't miss IDEs. I like the approach of small, single-purpose, composable command-line utilities more.
If this claim were true, the admissions rate at Yale would be rising. In fact it is falling/steady at Yale and most (all) of Yale's peer institutions.