skysight-inc/HackerNews huggingface dataset:
having used these type of programs for years, I like that your allows targeting a specific screen area rather than full-screen snow. Keeps the headaches down. Thanks.
I think the move to SaaS was a combination of factors:

1. The primary product of many companies got too large to deploy on their own server farms, and so they started moving toward AWS etc. for scalable hosting. Once your product is in the cloud, it makes sense to deploy your supporting infrastructure & tooling there as well, because otherwise you're paying the support, hosting, & sysadmin costs for just your non-critical corporate infrastructure.

2. Bandwidth became a non-issue. In the 1990s there was a very measurable difference between 10BaseT internally vs. an ISDN line to your hosting provider. In the 2010s, there's little practical difference between gigabit Ethernet vs. 10M broadband.

3. HTTPS became ubiquitous, taking care of many security risks.

4. AJAX enabled rich UIs, which previously would've required desktop apps.

5. Employees started to blur the line between work and home, leading to demand for work services that could be used, encrypted, from a user's home network. VPNs were a huge PITA to set up. This was a big issue for much of the early 2000s; one of my employers made some clever network software to punch through corporate firewalls with a minimum of configuration.

6. Development speed increased. SaaS companies could push new versions of their product faster, react to customer feedback quicker, and generally deliver better service. Because all customer interactions go through the company's servers (where they can be logged), they have much better information about how people are using their products. Deployed services were left in the dust.

tl;dr: #1-4 made lots of businesses go "Why not?", while #5 and #6 made them go "Yessss."

It's interesting that many of the arguments about why you should not use SaaS businesses now (like privacy and security, and lack of ownership) were relatively minor reasons then. I do kinda wish (in an abstract way) that something like Sandstorm would catch on, but I think they may be early: SaaS just isn't that painful, and until we have a major shake-out where a lot of businesses get taken out because their dependencies go down, it seems unlikely that it will become so. Or the other way this could play out is that a new powerful computing platform comes out that lets you do things that aren't possible with thin clients, and you see a rush back to the client for functionality.
(lightbulb!)

but, and maybe they were also recompiled, did you keep your tests as well?
I believe that if it's classified as "furniture" then it doesn't need to be permitted. For example, this is just a bigger version of a wardrobe in your office.
Healthcare.gov 2.0 (tech talk)
Impressed daily by the amount of stuff being done to advance Rust as an incredibly useful language.
How do pixels become "stuck" in the first place? What is the mechanism by which this happens, and how does this technique fix it?
I think it's related to the Waterbed Theory[1]. Or, put another way, there's no free lunch. The bill will be paid, either now or later, by you or someone else. You're probably better shifting responsibility than time...

1: https://en.wikipedia.org/wiki/Waterbed_theory
My password manager loves to fill those in, for some reason.
Ditto. My name's likely in your Linux distro, but I also started in 98, and even then you would never expect a given package to work without default config files.
I just tried it on a 14MB file to confirm, and Atom can open files larger than 2MB. (I also scrolled through the whole file just to make sure Atom wasn't cheating somehow, and it seemed to be working fine.)
My only shock here is that this wasn't done sooner.

I have kind of seen Git as two tightly coupled systems (and IIRC, other VCS's have modeled their design with a similar separation of concerns): a content addressable store, and a tagging/tracking system for metadata.

I actually kind of expected that someone would eventually try out replacing one of the two with their own "better" system to see how that worked out, but obviously the more interesting opportunity is to see if one or both of the components might be useful for an entirely different purpose.
The funny part is, in good old game theory fashion, the prime motivator for hiding your negatives and trumping up your positives is everyone else is doing it, so you must as well just to keep up.
Ask HN: Should I learn only one language until I know it all?
So I pretty much want to learn a lot of things. I want to learn Ruby, Go, Swift, Elixir, (few more things)
I haven't really mastered one language, and I want to be able to do that. I've got some advice saying that it takes time and to keep learning.

Should I put my focus into mastering one language or have fun with the languages I want to learn and find which one I want to master?
No way; use Clojure: https://github.com/incanter/incanter
Have you tried comparing how this serves as a KV store as compared to other engines?
In the world of lossy counting. This [1] could be something to look at if you wanted to answer the question "how many requests/secs towards jgc.org at noontime, two months ago"

[1] https://github.com/dgryski/hokusai
>human drivers realize they can be incredibly aggressive around the self-driving cars - cut them off, etc - and the self driving cars will happily accommodate the human driver

well, as my driving school instructor was saying - "Do yield to the moron".
I some how submitted this without my content on accident.

https://news.ycombinator.com/item?id=9781555
You should make an npm module and have it conform to this: https://www.npmjs.com/package/abstract-blob-store
Do you really do your work on a computer where an 80MB install is a problem? No argument on the file size limit.
In my observation, most software companies are not technology/engineering companies in the sense you've used above. They have an application that provides value to an industry, or to a group of civilians, but which didn't require any particularly deep insights into new algorithms or into low-level code.
I just took a quick look at the code. This is non-persistent as it relies on the global `$ITEMS`, right? What benefit would this bring over simply storing directly into the variable?
J has pretty good - but may be small - community on Jsoftware forums. J libraries are small but ever growing - are there particular examples of R libraries which are sorely missing in J?

I should admit I was asking myself the question of this topic.
Gold Hamster Club
If candidate fails to submit link for any of above then just don't interview them.

Since when has every person worth hiring had their own blog?

Edit: sorry, your use of "any" was ambiguous, I read it as "if missing any of the above".
The Google Maps API for Android is one of the rare SDKs that continually gets worse over time. In the Android beta it actually had more features like driving directions, but the classes were moved off into undocumented classes, then made unreachable completely driving people to use JS APIs or competitors like Skobbler. It's pretty clear Google isn't eating their own dog food with this and that it's just a back water that has nothing to do with their own Maps app. Kind of a shame because they could be making every mapping app on their entire platform better with a good SDK, making their entire platform much better, instead of only helping their one app.
Ad hominem is where you discount an argument based on the person making it. I'm not sure where the name thing is meant to come in to it.
R is... _interesting_ language. Its main power really comes from the comprehensive libraries that are available. I think there is an interesting option if other languages can figure out how to make the R libraries easily accessible in their environments, which is not that easy, because even the libraries can use the _interesting_ R design features :-).

That said, in F# (which is a functional-first language with some solid programming language design background), one can call R functions in a fairly nice way using a type provider: http://bluemountaincapital.github.io/FSharpRProvider/.

This probably cannot replace R for typical statisticians, but it is a nice option for programmers...
I'm not blaming them, just saying there's evidence the authors are quite familiar with Go. =P
> This is non-persistent as it relies on the global `$ITEMS`, right?

In a sense. $ITEMS is a hash ruby-object whose keys are what is set as the key by the input, but its values are the hashes that are stored in the git filesystem. There are about 10,000,000 improvements this could have and by no means would I consider it production quality software. Any ideas on a better means of persistance knowing this? Could back up the dict itself as a string in the git filesystem and have it be restorable on instantiation, possibly...
OfficePOD is $24,000!
Depends what interests you, where you want to work, for how long, etc.

You can probably survive with Java or C# in corporate world for the rest of your career. In webdev you can probably stick to one language, but will have jump between frameworks as new ones become more popular and there's no work in old services anymore. Although that's still likely more than one language (php, js, sql for example)

If you're anywhere near systems administration, you'll have to deal with anything that comes by anyway, so shell, perl, python, ruby are going to be your friends.

So the answer is as usual - it depends.
Pick one where you have a friend who knows it well, and can help you through the pitfalls. Then build something complicated enough that you aren't entirely sure how to do it yet.

"Mastery", "until I know it all", "find which ones I [like]" all kinda fit into this process, so you end up doing them all at once.
Depends what interests you, where you want to work, for how long, etc.

You can probably survive with Java or C# in corporate world for the rest of your career. In webdev you can probably stick to one language, but will have jump between frameworks as new ones become more popular and there's no work in old services anymore. Although that's still likely more than one language (php, js, sql for example)

If you're anywhere near systems administration, you'll have to deal with anything that comes by anyway, so shell, perl, python, ruby are going to be your friends.

If you just enjoy the programming and you want to learn more languages, then of course it's a good idea. Each new language will allow you to understand the other ones better and stop you from doing things only one way because you only know one way.

So the answer is as usual - it depends.
I've done no benchmarking yet. It is a piece that evolved initially from a project I was doing to just explore git's innards a bit more. I eventually gave a talk on what became v0.1 of this (only string store, no typing) at the Columbus Ruby Brigade, and have just been hacking on it a bit in the last couple of weeks because I've found it intriguing.
Our outcome is much larger than you might think. Definitely more than what the average startup founder (who might have tried to raise more funding to chase growth over profits) under a similar exit, because the founders maintained a large portion of our equity to the end.

Now, I still have equity in SurveyMonkey and their amazing story is still in progress (one that also balances growth vs profits in a very similar way), but our outcome could be the equivalent to a traditional exit 3-4 times our size when all is said and done.

Also, a startup feels completely different when it's profitable and we were profitable 9 months after launch. Running a company on the edge is incredibly stressful and I'm glad I didn't have to do so for 4 years. I'm not saying I couldn't have done it, but I'm glad I wasn't forced.

This is not to say I believe every startup should run like ours, because sometimes you don't get the luxury or choice to do so. We were lucky to get to choose to grow the company the way we wanted at Wufoo. Sometimes growth comes to a startup and they have to do everything they can to hang on including raise money. If that's the right path, I won't be afraid to recommend that route.

The reason I'm at YC is because we don't try to slap a one plan fits all model for the startups. There are many paths to success and I'm delighted to be a testament to that.
Given a choice between 'clean design' (which is certainly not a truth universally acknowledged) and 'getting stuff done with libraries that somebody else did the hard work on' I'll choose r any day of the week.
It really doesn't ease the pain of dealing with an awkward language. I think the general lack of technical sophistication in the R community just adds to the aggravation. So as far as community experience goes, I might actually rate the APL-family higher.
Congrats to the Atom team:) what happened to rAtom?
Maybe something worth pointing out..

I wanted to download this but after clicking every link I still hadn't seen a way to do it anywhere...

Obviously if I go to the homepage now the first thing I see is a big download link, which is great.

I think a 'download' link on the site though would be good since if anyone links ANYWHERE else it's hard to find.
I am completely unfamiliar with Elixir but I love the aesthetics of the language. That's a really neat piece of work, thank you for sharing.

I often wonder what are some good usecases for Elixir? What kind of problem do you solve using Elixir?
> My only shock here is that this wasn't done sooner.

This was my initial reasoning for making it. However when I began looking into it on Twitter @steveklabnik informed me that Rust's crates.io uses a similar system [0]. I found this especially intriguing, but have not gotten in touch with someone who knows the codebase better to give me some more insight.

[0] https://twitter.com/steveklabnik/status/608778665825083392
You should take a look at the garbage collector (git gc) of git as well. I'm pretty sure that it'll clean up your KV-store, as the objects are not referenced anywhere. Choose a storage model that'll survive `git gc`. Maybe take a look at the tree objects git itself uses?
That would definitely be interesting! My JavaScript is rusty, it would be a good excuse to do a refresher. Bookmarked and added to my todo notes :)
Huge milestone! Congrats.

And in case you're wondering about the video, well, its this 50 year old documentary "The Home Of The Future: Year 1999 A.D.": https://www.youtube.com/watch?v=0RRxqg4G-G4
That's the ++ in the ASP++. Stock ASP/VB works (or worked) too, but lots of new syntax was added to support .net.
It is definitely very worthwhile to get to the depth of at least one language and one framework, because with the scope of what you'd learn about these ones, you will have a frame to more easily understand and learn to use the others, even if you never become expert with the other languages and frameworks you will have to use.

On the other hand, since it takes ten years to become expert, you may not want to wait before starting to learn alternatives. But as a newbie, you don't want to switch to other things too early either. You should have written a couple of non trivial programs (eg. a real application) with a language before you switch to another.
As a non-Sikh Indian, that's the first time I've come across the meaning of the word "Sardarji".

Not proud of myself for this, but as kids, we'd crack "Sardarji" jokes which are basically the Indian equivalent of blonde jokes.

And it's still the first thing that comes up on Google :/
Yep. Too much information in the absence of symptoms can actually a bad thing.

https://www.sciencebasedmedicine.org/a-skeptical-look-at-scr...

"When pharmacies in the UK started offering glucose and cholesterol tests, the number of visits to doctors increased, but only 10% of people with positive tests needed treatment"
Exactly! There are many good languages for data analysis (Julia is one example) but no other language (not even Python, which is BTW leaps and bounds above all the other alternatives) can match the library support and statistical maturity that R has.

And R is not so bad as a language. It's OO is really bad, but it has functions as first-class members and great support for NAs. Combined with Hadleyverse and pipe operator (magrittr) is makes a very readable code.
Awesome! But I was really hoping it was going to be multiplayer. It would be much cooler if you could just hop straight in to shooting at some other people...
Dude, you explicitly said you're "100% okay with [violence] personally"

You then said, "the only things fascists respond to is violence. Ignoring them or letting them attack you doesn't help."

You then linked to a Woody Allen video where he confidentially states a Nazi march in NYC should be attacked with "bricks and bats" rather than taking a civilized approach against them.

You explicitly endorsed violence against political groups you dislike several times, don't try to pretend like you didn't now..
Here is a 20 minute video on it: https://www.youtube.com/watch?v=6HtKy7_n1LA
Android Toolbar dropshadow on all API levels
How can you get a Toolbar dropshadow on all API levels on Android? I created a repo to demonstrate this exact issue :
https://github.com/lawloretienne/ToolbarExample
I only see a dropshadow on API level 21+ .
This would hopefully play well with the potential of use of a more robust git tooling like rubiquity had mentioned in another comment. I had thought about the gc aspect but didn't dive into it too much since its so immature still. Definitely will be considering all this as I plan 0.3. Thanks.
Who cares how many languages you "know"? What counts is the things you've built in those languages.

That usually means that you should be focusing on one or two languages, building enough to have "used them in anger", and then figuring out what to do.
Woah...this takes me back a long time.

Posting just in case anyone finds it interesting...here's an (admittedly weak) lambda calculus interpreter, in Oz:

https://gist.github.com/shermany/ad41ccf93fc969c5d759
I don't really think the word "just" belongs in that sentence ;)
but you brought up Iraq and Afghanistan.

Note that example was done specifically as a study of armed irregulars vs the US--your examples of other Western states were in a very different vein. :)
Well if you drive around any college campus you'll quickly find the results of that.
Rust will deal with it by being swifter than Swift. Significantly so: Rust's unique feature is safety without requiring reference counting or GC for all pointers, which makes it a viable replacement for C and C++ in many situations where other languages would be considered unacceptable, and close enough to viable in others that future versions of Rust have a decent chance of making up the difference. Plenty of applications don't need that, and I look forward to competition between Rust and Swift in those arenas. But the enduring popularity of C++ in the face of the many newer, safer languages out there is testament that Rust's performance advantage is likely to be attractive to a lot of people.
Was discussing self-driving cars with a few colleagues on a drive the other day, and a question came up:

Does anyone have a sense how the cars handle situations where traffic is being directed by a human, with hand signals, etc? I.e. a cop standing in the middle of the road, waving through cars through an intersection where there's been an accident, etc.?

We pondered a few scenarios -- are they reading the hand signals? Are they judging other cars' movement? What if it's not a cop but a crazy random person who jumps into traffic and decides to play cop? We humans are remarkably good at determining "soft" things like "that guy looks crazy - let's get out of here" vs "that's a cop, I better pay attention", etc. The rabbit hole gets quite deep here...
You don't even need Turing-completeness, just any form of recursion will do.
OUTLAW TECHNO PSYCHOBITCH
No kidding, my first thought was, this device is irresponsibly large. I don't know everything that is in it, but having made devices like that before, I would bet with some engineering investment it could use a coin cell, and not be much larger than 2 or 3 of said coin cells.
Indeed, this is the critical question. If L. Ron Hubbard secretly but accurately predicted the lottery numbers for last week, it doesn't mean we have to go back and change them. Things can seem wrong/impossible/against your worldview, but that sense doesn't help quite so much as _just looking_.

Fundamentally, calling things into question has little value until we generate an answer to the question it was called into. Considering it's relatively easy to judge him on the technical work, why not?
I think it's useful to make a big qualification to the question. Of course, if you need to use a library written in R, then you use R. Same with Java or anything else. So the question is assuming your choice isn't governed by need for a particular library.
For those who still think manual memory management and especially malloc and free are fast, check glibc implementation.

https://fossies.org/dox/glibc-2.21/malloc_8c_source.html#l02...

Also see this benchmark between different, faster allocators: http://locklessinc.com/benchmarks_allocator.shtml

The extra work doesn't end at allocation. When you actually implement a concurrent system, you'll usually end up having corner cases at object lifetime changes, which you need to synchronize. If the memory is only claimed when there are no more references to it, this extra synchronization step can be avoided. If you can't rely on this, you'll probably end up doing synchronization, such as (atomic) reference counting.

Synchronization is very expensive and it can quickly become the performance bottleneck for the whole system. On modern X86, you can do 5-20k floating point operations during one contended atomic sync op. Reference count increase or decrease is one sync op. A simple mutex needs two of those.

The more you have CPU cores, the more there will be synchronization (cache coherence) traffic broadcasted to all cores.

Words like "JIT" and "GC" seem to cause knee-jerk reactions in some developers. Likewise for manual memory management. It's not so black and white. There'll always be trade-offs. I usually write low level (firmware and kernel driver) and high performance code. C/C++/SIMD. Code that might need to react under a microsecond.

My message is just please be more open minded.

Analyze where your code spends its execution time. You might be surprised how much of it is spent in things like C++ streams, xprintfs and memory allocation. Unfortunately inter-core synchronization is more insidious. It's not visible in benchmarks on small systems. Often you only start to see hints of this problem when actually running on more cores. Enough of them, and that's all your code is doing.
* 20+ years of development experience 15 of those professionally
* published author of various books
* worked in systems that most startups would shit their pants with the requirements
* some of the big name companies have tried to poach me based on the products I've worked
* used professionally: C, C++, F#, C#, Ruby(Rails), Swift, Obj-C, Kotlin, Haskell, Scala

I would never be called based on that criteria as I have no inclination to spend my free time doing stupid shit online for hipster new developers that think GitHub is the end-all.

ps: to be fair, I probably wouldn't want to work in a company that has this mentality, so maybe that really does work
Anything with 20% false negatives is fine if you expect to have five or more hireable people apply every time you advertise. But if you are in a situation where you might get 200 people applying and perhaps one or sometimes two are actually worth hiring, a 20% false negative is crippling.
Few of the sites we use at work have captchas that:

* Often don't load
* Quietly expire the session on the server within a time that is shorter than it takes to fill the form in
* Are trivial to crack by a computer
* Are difficult to pass for a human

This is an improvement.