skysight-inc/HackerNews huggingface dataset:
It gets lauded because the range is enough. It's not great, but it's enough that you can mostly treat it like a car, rather than a glorified golf cart. 265 miles is enough to treat it as gas^H^H^Hcharge and go, rather than needing elaborate planning for everyday activities.

You're completely right that the range and price demonstrates the limits of current technology. But the Model S is great because it makes different tradeoffs from usual, and tradeoffs that make it a great car if you have the money. Other attempts at electric cars have tried to keep the price down, and that means sacrificing range to a huge degree. Tesla responded to this tradeoff by making an expensive car with a good range that has comparable features to other cars in that expensive price range, rather than making a cheap car with crappy range the way others have done.

And yes, dual motor is no real innovation. It's cool, and 3.2s 0-60 is fantastic, but all it really took was throwing extra money into the machine.

As for 200 mile affordable electric cars in 2017, we'll see. The battery is the limiting factor right now. The Model S battery pack by itself costs more than an entire Nissan Leaf, and you can't reduce the energy needed for that range that much beyond what the Model S needs. Battery technology, whether chemistry or manufacturing or both, needs to get substantially cheaper for that to happen. I assume that's what everybody's betting on happening.
Yes. For instance, Vim necessarily knows how large the terminal it is in is. Vim also supports mouse input, allowing you to click around in different windows and whatnot.
This reminds me of another schooldays riddle - "a plane crashes on the US/Mexico border, where do they bury the survivors?"
it would be great if the site had an about/imprint to know who's behind it
His point was that it is a bullshit tax that you must pay.

The Jiffy lube analogy is wrong. It is more like buying car insurance, registration, inspection, and filling the car with gas. Those things are "bullshit" that has nothing to do with what I am trying to accomplish with a car, which is going places faster than walking, and carrying more stuff. I must do them, but they have little to do with what I want to accomplish with a car.
Lower insurance rates. And I don't care how much you love driving, no one loves to accidentally rear-end someone that just slammed on their brakes while you were distracted by checking adjacent lane prior to moving over to get to an exit. And automation can help both situations (when putting on the lane change signal, I want some type of alarm if a car is entering my blind spot, for example).
backlog (can be applied to sales & implementation pipelines)
I think the biggest issue is that beyond the setup phase of development, these tools don't get used by the new researchers the author works with. If I'm developing a new program, having to run ten programs I've never seen before just to get started can be frustrating if I won't be actively using as them I work.

Programmers should learn the tools to stay efficient. Version Control, build tools, etc. are priceless. But if you force feed too much at once, nothing will stick. Couple that with what for some may be their first time on the command line, and you have a recipe for bullshittery.

I'm having a hard time understanding other commenter's grief that explaining git to someone who's never typed "ls" before is anything less than bullshit to slog through. These things are best learned one or two at a time.
Folks, this prof isn't saying the command line isn't worth knowing. He's saying that learning it costs time which would be better spent on actual research. Becoming the three-millionth sed expert does not expand CS.

The command line is the best available technology for many tasks. We're going to need these skills for the foreseeable future and maybe forever. CS PhD students are trainees and its OK if they invest in learning it. But for the prof, it's completely reasonable and rational to want to minimize the total time his group spends on this stuff, for productivity's sake.

I'm a CS prof and I spend way too much time wrestling with flaky build scripts, incorrect docs, overly-specific dependencies, etc, because the original author did not put in the extra effort to make the code usable by a third party. This apparent economy costs a huge amount of other people's time.

Bearing this stuff in mind, a prof can actively try to minimize this overhead by (i) decent design, (ii) a bit of spit and polish before releasing code, and (iii) maintaining lab environments that already work (VM/container images, etc.). Let's train the students to care about this stuff.

edit: To clarify, I'm not saying that the author of some open source code owes me anything in terms of usability or my time. But if they want to maximize their impact, a little effort in that direction can pay off. Like writing a paper that is easy to follow rather than an ugly brain-dump.
Using Presto in Our Big Data Platform on AWS
While the original article didn't particularly garner my sympathy, I get concerned when people start complaining that others don't know how systems "actually function".

Image that, the next time you sat down to write come code, you're asked for the value of Planck's constant and to solve a couple of Feynmann diagrams for holes in a semi-conductor before you can write a single line. After all, a programmer can't just live with the high level abstractions of machine code and Kirchhoff's rules - she should know how the systems she works on actually function!

Everyone uses some abstraction when they think about writing code. High quality abstractions (e.g. machine code) should be encouraged and things which violate those abstraction (e.g. bombarding memory with radiation) should be avoided. Low quality abstractions (e.g. monads are burritos) should be avoided. Being charitable, the professor seems concerned that poor quality abstraction are dominating and students are being forced to drop to abstraction levels that aren't relevant to their studies.
As another commenter noted it's not a complete durability solution. However it is useful in a number of places - and not just to do with durability.

AIO is also very extensively used, and bmap is pretty important.

It's really important when writing comparison pages like this to not play down the weaknesses of the thing you're trying to sell - it comes across badly. O_DIRECT, AIO and to a lesser extent bmap are feature that are required of a general purpose linux filesystem.
I'm sure you'll have them all working in ZoL soon enough, but please don't try to pretend they aren't important.

I'm also not sure why you have NFS in there - network filesystems are not local filesystems, and aren't generally going to have identical feature-sets. It feels a bit like you just stuck NFS in there so that there'd at least be something with more missing features.
The same could kind of be said of JFS - I haven't heard of anyone using JFS on linux in a serious way in a very long time.
Because Ubuntu is known to give shit about freedom (and it's a Ltd.), while Mozilla boasts about their users' rights (and is a Foundation).
Pointers and memory leaks in C
hi Minimaxir, we are far away from being a blef and its years of work behind this post.

Hope you can check this out please and would appreciate your feedback on this last reply.

a) product:
http://www.gesturekit.com/ its cross and already works on iOS, Android and Web platforms.

You can check all plugins and demos here:
http://www.gesturekit.com/learn/downloads/

This is our Github repo.
https://github.com/RoamTouch

b) We have a nice crew of enthusiasts people around gesturekit and are following the project.

We will take the proper consideration and measures next time to avoid this.

Thanks very much for the feedback.
Jose
Yep that's what I was thinking. If he's annoyed that students are wasting too much time setting up software, they should hire some folks to build a nice repository of packages and maintain them.
There are still layouts it can't solve, for which I'm using Javascript to manually calculate the size of elements
And you probably won't have to work in 'The House of Blue Lights' in order to afford a pair.
Elon Musk CEO of Tesla Motors Unveils Dual Motor and Autopilot
How do you feel about using Sencha? I used ExtJS a few years ago (and also Ext-GWT). At that time, out-of-box ExtJS was great but customization was painful :( and ExtJS feels a bit heavy. Is that still the case?
Maybe he's pining for a development environment that looks like this: http://fc05.deviantart.net/images/i/2003/2/5/0/Operation_Swo...

Then his students will know that it's on the bleeding-edge of The Future.
Yes, exactly. I'm fine with an imperfect solution to this problem, but I think that seeing a page N which was not the page N I would have seen had I clicked the link 30 minutes ago is far preferable to getting a silly error and being forced to navigate back to the front page.
Dairy Queen confirms hack of customer card data at 395 stores
From my (not-so-big) experience in IT, the sub-fields of this field are really tightly networked together (e.g. if you understand piping in bash, you can then learn about stdin and stdout concepts in your future C program, or the other way around). Therefore I really can't see how could one try to excel in one area and not touch the others.

While you are learning about the area of your choice, you inevitably understand ideas that hold true for many other areas (provided you possess the perception to see them).

Expanding on these ideas, in turn, may help you understand something new about your area of choice again. Not willing to do so feels like a wasted opportunity.
> (...) underpowered, user hostile design that requires lots of unnecessary memorization.

User hostile I can understand. Underpowered is just plain false. Parsing log files, relating data between them and aggregating results is a common task for any decent sysadmin. I know no interface as powerful (measured as the ratio of information quality over time spent) as the Unix command line.

Many powerful interfaces have ultra steep learning curves. The Unix shell is one of them. Steep learning curves are a flaw, of course, but they do not invalidate the other qualities of the interface.
The problem that Dan Geer pointed out at his NSA talk [1] isn't that they have some surface level vulns, it's that they are mostly all running linux from 5 years ago and rarely get security updates. Home routers are insecure by default. The problem is that even if your home router gets hacked and bricked, you go to BestBuy or Newegg to buy a new router and they are all running the same old broken OS by default - not including the questionable services and awful vendor-created software included (ie Asus cloud management software with 5x CVEs).

So he posed the question: What if all home routers get hacked and wiped in a mass attack against a country? People can't go out and buy new ones since they are just at risk and will probably just get hacked again. This puts a large amount of any countries technical infrastructure at risk.

The router manufacturers really need to step up here. And even technical users could benefit from more options on the market for secure routers, instead of just DIY OpenBSD boxes.

I'm curious if the gov will ever pressure these companies for better security, although they seem to prefer insecure-by-default.

[1] http://geer.tinho.net/geer.nsa.26iii14.txt
I would say the opposite: After a small initial hump, flexbox is actually very simple for what it gives you, but it's ultimately fairly limited. It's not up to implementing every kind of grid layout cleanly, and it's not even in the same ballpark as constraint-based layouts.
I'm honestly not sure if your post is meant to be satire or not.

>lists: ls -1 | wc -l

The computer has taken a real array (probably an array in C), joined all the items together into one big string using magical characters as dividers, and then split it again on those magic characters to try and reconstruct the metadata that it threw away. I think the problem is pretty obvious and well known.

>would unix be better if it were cwd.files.count

Well, at least that is going to give you the correct result. Correctness seems like it should be pretty important, no?

Are you really arguing for shells being easier to learn using an example of a complicated command with 4 pipes, 2 different quoted strings, several single letter arguments, and that requires implicit knowledge about the structure of the output from several commands? Compared to a much shorter, simpler, type safe, and self documenting bit of code?

Also, yes my original post was hyperbolic. That was because I was responding to a histrionically overwrought post claiming that unix is perfect.
It's common in the keto dieters.

The trick seems to be finding yourself a loose weekly meal plan (5 meals you would be happy eating every weekday for a season) and freeze portioned sauces - my mother in law uses zip lock bags as they freeze flat and are quick to thaw in warm water, skipping the need to thaw in the fridge.

So basically you pick your meat for the evening and have that thawed, then you might have a choice of 3 sauces or seasonings that you can quickly thaw and mix in.

My biggest problem with prepared food is not feeling like it at the end of the day, it just makes you miserable and prone to getting take out.
Seems like more and more cars have radar/ultrasound sensors. Won't this eventually lead to interference? Can such a system be influenced by, say, a nutter with a stronger radar?
From Intern to Full Time: Knowing What It Takes
Agreed. I find any of R, Python (with scikit-learn, pandas, etc), or even SAS far more palatable than SPSS or Excel.
Clearly a lot of HN readers have Unix command-line Stockholm syndrome.

It's a sad fact that having facility with the Unix command line enables one to be more productive, but that's because because it gives you access to a huge array of useful tools, not due to any innate qualities of the interface.

It's a clear case of worse-is-better.
Coming up with a competitor to CSS, HTML and JavaScript is a fruitless "if I were king" fantasy.

The way forward is to develop what we have to make it better, incrementally. Local maxima be damned, there is no alternative.
Apple iOS prereleases support more devices than Android, which only supports two: Nexus 5 and 7 (unsure if the first generation of Nexus 7 is supported).
>an underpowered, user hostile design

In your opinion, of course. Many of us find the * nix command line not only elegant and highly-productive, but actually enjoyable.

In fact, the only Linux command line tools that I did not immediately start using in a highly productive manner are `tar` and `find`, arguably two of tools that least abide by the ideals of * nix command line tools (I've since gotten used to `find`, but `tar` may always send me searching for my personal wiki's corresponding entry[1]).

If you want to argue that there are better ways to program on the console, I grant that it's possible -- although as mentioned, I find the composability of * nix tools to be an almost magically productive approach.

But to condemn anyone to a life of GUI tools is not only going to drastically increase their chance of developing carpal tunnel syndrome, but also inevitably will slow down their work flow -- often drastically. It's simply not possible for even an experienced user to point and click with a mouse as fast as an fluent typist can issue commands on the terminal.

1. http://xkcd.com/1168/
One of the big positives of Spark is that its architecture is amenable to having workers run on spot instances, which are even cheaper than reserved instances.
So I'm try to access the site on my note 2. The little popup says to rotate wide. I am. Then I try to click on the search box. The popup returns and I can't type.
These also work with cold milk (3C), and heating the foam in a microwave afterwards.
I'm going to quote the majority of an entire section of Guo's post because it (a) demonstrates what I believe to be the core of his problem, and (b) is incredibly offensive to me as a computing professional:

"Here is a common productivity bottleneck faced by students working on applied computer science research:

"1. Advisor and student discuss high-level research ideas by doodling on the whiteboard. Awesomeness ensues.

"2. Student leaves advisor's office feeling pumped and knowing exactly what they need to do to implement those ideas in code.

"3. Student tries to get started on programming but immediately gets stuck since they don't know how to handle all of the command-line bullshittery required to set up their coding environment with the proper libraries, tools, and frameworks.

"Many students get discouraged and turned off from research when they hit the wall in step 3.

"There is a huge disconnect between the elegant high-level ideas discussed on the whiteboard (while presumably sipping cappuccinos) and the grimy, grungy, terrible command-line bullshittery required to set up a computing environment suitable for implementing those ideas in code. This gulf of execution is tremendously frustrating for highly-capable and motivated students who just didn't happen to spend 10,000 hours of their youth wrestling with nasty command-line interfaces."

If I were to try to write a summary of this complaint, I believe I would have to boil it down to, "Useful work is indeed often difficult."

I'm certain the HN community is familiar with the concept that ideas are a dime a dozen, that execution is indeed the important part. I'm also certain a significant chunk of the readership has also spent "10,000 hours of their youth wrestling with nasty command-line interfaces", by which I mean "has learned the fundamentals of how computers work" and "has spent some time understanding how to use their tools."

So along comes Philip Guo, who has, in his career, developed the ability to convert whiteboard doodles to working prototypes (I'll withhold my rant about academic quality code for today). Now, however, he's in the position of every developer promoted to management: he has whiteboard doodles that he would like his loyal minions to convert to functioning code and his minions are having difficulties. And, like almost every other recent promotee, he blames the tools involved. Because, after all, "this bullshit is not intellectually interesting in any way", at least to him; he's only interested in the whiteboard awesomeness, after all.

Programming is difficult. Guo knows this. The tools could be better. (Are there significantly better tools out there than "command-line bullshit"? Not that I'm aware of. Maybe the Plan 9 stuff, Acme, etc., but that comes with its own stack of bullshit and a reduced environment to boot.) But is actually learning to program really incidental complexity? Is it really "bullshit"?
Great stuff as usual :)
Despite the amount of criticism on here (and while I agree the article is a bit over the top), I do think I am strongly partial to this sentiment nevertheless.

I think part of the problem is that amongst coders (a much greater population than that of people doing real research in computer science) fluency in a number of arcane syntaxes is perceived as something 'cool', finally it's a standard that's been ingrained for years and years.

But the amount of say 'command-line-tool' or 'library' specific syntax, that must be re-learned for a new tool (which you might use once in a month, or a library you might use for one function, is very often a giant time sink). It's not cool. It's not intellectually interesting to memorize syntax.
I don't care to share street space with those, either. Or sport bikes, or tractor-trailers, etc.

The track is an appropriate place for those kinds of vehicles. (Also an enormous amount of fun!)

Not-fun is trying to drive a twitchy high-horsepower car in a congested urban environment.

Somewhat fun is opening up that car for the one clear block that you get, except that it's extremely dangerous for everyone around you. Only sociopaths incapable of thinking about the effect of their actions on others do that kind of thing. Not even street racing, just stepping on the gas out of frustration.

I'd be way more interested in the "autopilot" features if they worked in urban settings, such as automatic braking for obstacles.
> strait text + links is both pure HTML and a responsive layout

It's a responsive layout, but not one that somebody is willing to pay me to build. Those that people will pay me for are, in my experience, easiest to build with CSS.
There's that, but also the realization that you need to brake "as hard as possible"-- we're not trained to do that often so there's additional delay before that happens.
It goes both ways. I hate developers that write some code, dump it on GitHub and say "It's open source, you can always fork it." Whatever happened to taking pride in your work and making it work the best it can?

Like other people have pointed out, handling unicode properly does not mean internationalization. Handling utf-8 isn't even difficult if you just keep it in mind.
+1 for introducing me to the term "bullshittery."

My undergrad was in music and when I went for a master's in CS, I knew like, nothing, and suffered under a lot of the command line bullshittery he refers to. And most profs at the master's level were unwilling/unable to help with that sort of thing. One of the most useful classes I took was a (totally non-degree fulfilling) undergrad course in Unix system administration.

Nonetheless, I believe that mastering the command line and general Unix environment is still rather essential. Things like basic vim usage, or readline shortcuts (http://www.bigsmoke.us/readline/shortcuts). I still see experienced folks cursoring around on the command line a character at a time, which sort of makes me cringe.

It might be interesting to see some sort of catch-all "systems skills" CS course that covers a lot of this sort of thing.
The article actually irritated me a little bit.
If the command line were underpowered, it would have been abandoned decades ago. It's still around precisely because it's incredibly powerful, and nobody has come up with a suitable replacement that doesn't involve sacrificing a lot of power.

Further, all of the "No, obviously this would work much better!"s have been tried already. Dozens of times, if not hundreds. Some of them you can even download right now. Nevertheless, the command line persists. It may not be perfect in every detail, but it's far harder to exceed than it seems at an initial, frustrated glance. If you hope to someday so replace it, it would be wise to understand exactly why that is, lest your effort completely fail in exactly the same way as so many prior attempts.
FWIW, in 2011, Google wrote that they achieved a PB sort in 33 minutes on 8000 computers, vs. 234 minutes on 190 computers with 6080 cores reported by Spark here.

http://googleresearch.blogspot.com/2011/09/sorting-petabytes...
Comcast Internet went out at my girlfriend's once. After several phone calls of BS it turns out Comcast came to service the apartment next to hers and decided to unplug the cable from the street that goes into her apartment. Their rationale was that it was unmarked so obviously it couldn't have been important.
sounds like three radios: remote, remote or office, office
But right now, they aren't. :)
The psty links in README file are broken. A working link is http://pigshell.com/v/0.6.2/psty.py

As mentioned in the README, you need to run psty server locally and establish websocket connection (mount in pigshell). This will enable you to harness local filesystem from pigshell.
Sounds like a docker/vagrant use case.

I do disagree with the thesis though. If youre building on a tool you ought to learn how to use it properly. Otherwise what happens when something breaks? Placing "sensible defaults" works until you need to change the tools functionality, at which point, if you dont know how to use the tool you will be once again lost.

It's a whack-a-mole method vs the dynamite approach IMHO.
CFTC Says the Bitcoin Protocol Is Here to Stay