skysight-inc/HackerNews huggingface dataset:
It's a statement that said that they asked them to address some critical issues via their regular support channel. The statement said they have already reached out, and they had nowhere else to go so hence the open letter.

Or in other words, to answer the question I was asked (which was "Did they who filed the letter ask?"), yes, they did ask. Apparently repeatedly.
Corollary: Write code such that it's easy to use grep to find where things are used.

One of my pet peeves is when OO programmers take class's separate namespaces as a license to use super-generic method names. Method names like "add", "update", etc. Makes it near impossible to figure out where those methods are used!
Ask HN: What Linux distros avoid systemd?
Are there any production-ready Linux distros that don't and won't require systemd?
Old hardware was my introduction to Linux. A 2011 Apple computer can run the latest version of Ubuntu or many other distros. Homebrew won't matter, Chrome will run. The latest development tools -- other than those required for iOS/OSX development will be available.

Eventually, I switched from Windows completely, but it's the same thing...I removed a dependency.

Good luck.
The example at the start would be equally mildly confusing if it was written as SetMagic(ConjureMagic());. The problem is not the auto. It's a normal case of non-ideal function names.
this is essentially an options contract; if you can trade against irrationality then you will win every time; the data is clear that the difference between a couple's expectation of the success of their marriage versus statistical reality is a significant one; that is why if you can manufacture this trade you will reap the economic surplus.

this is partially how las vegas and state lotteries work; despite a negative expected value people continue to gamble partially because of irrational overconfidence
Do you have any non tech friends who own small businesses? Mine live in some for of bad SEO, the need to buy ads, etc.

I worked at Google for a while and am a fan of their tech, but I also have a realistic view of how a few large web properties extract more wealth than value.
Also, with regards to openness: First Android does have an option to sideload apps, and while Google can exercise control and limits on the OS, it usually only does so with regards to ad-blockers, and even that only partially.

And are ROM's hard to install ? For the technical user ,No,At least for large enough variety of phones. And as for the non-technical users - they always needed to pay someone or ask a friend when they wanted an OS install, so nothing's different.

And if look deeper, Android is open-source ,so it's undoubtedly offers much more freedom than windows.
Not sure what you mean by complete event loop. But I have a strong feeling that you are comparing apples to oranges in your benchmark.
C preprocessor macros can also be a great tool for making things ungreppable -- building families of functions using preprocessor token pasting to put together the function names certainly avoids repetition in all those function bodies but it also makes it really hard to find the definition later...
> DRYness for DRYness sake might feel satisfying when writing the code, but when changes need to be made, it often scatters constraints and requirements throughout the codebase, making any change an unestimatable mess of sneaky traps.

This also applies to "one-liners" when writing code. For example in ruby:

Model.where(...).foo { ... }.flatten.bar { ... }.join(...)

Looks nice and all, but it can be confusing when you need to fix a bug that you aren't sure of the source (foo or bar? maybe we shouldn't flatten yet? maybe we should join sooner?). It's much better, IMHO, to write more lines of code here so that you can easily test each step manually when a bug occurs.
Alien Kids
AT&T Joins Verizon in 5G Testing: What Is 5G and Do You Need It?
Look, I use x86 CPUs. I don't have much choice in the matter. But frankly, this stuff needs to be tracked, because there's too much of it to keep in my brain anymore, and if you look at Intel CPUs in particular, the level of malevolence seems to increase with every new tick/tock.

Although there are some interesting moves in the works: https://www.phoronix.com/scan.php?page=news_item&px=Talos-Se... Expensive though.
Yes yes yes. When I'm coaching junior developers (or developers that like over engineering) this is what I try hammering home more than anything.

If you looked at my code at 10-70% solution complete you'd find so many egregious DRY errors, magic values (likely with a comment above for my own memory), functions that are too long, and a whol ball of mess. If you looked at it 90-100% complete it would be nearly unrecognizable in writing style to what you saw earlier.

Figure out how to solve the problem first, spend all your efforts on that, then figure out how to clean up your code and make things nice/performant/secure/etc.

I've found that as I've gotten better my sloppy is better than a lot of people's clean, which means I'm spending less time on cleanliness, and getting done faster.
This is ridiculous. Name ONE option for a "completely open smartphone". I've spent the last 4 years in search of just ONE open phone and the closest we've come is the Neo900 (stalled, out of money) the Freerunner (production run of 100?), OsmocomBB running on an ancient candybar (illegal), and this hobby project [1] that is more toy than anything viable.

The Nokia n900 was the last "openish" phone to come out and they stopped making those in 2011 when, guess what, they were bought by Microsoft.

[1] http://www.seeed.cc/rephone/
PostgreSQL [9.5.0] vs. MariaDB [10.1.11] vs. MySQL [5.7.0] year 2016
> Once you add a transpile step, your "transpile step" can give you a lot more confidence, with linting, and flow, and ecmascript 6.

Linting is separate. Transpiling, for me, gives me less confidence because I write in one language, it has to run a transpiler to turn into another language giving me an extra point of failure (transpiler bugs suck; I ran into a few with CoffeeScript a few years back. Turned me off from ever using one again). Unless you have mappings debugging also has to be done in a separate language than what you write in which is really hard for me to get used to (I had to debug CoffeeScript back before it had chrome mappings).

> Minifying, concatenating, and compiling only used code paths/files and assets is only a few lines of code (with webpack).

Also only takes a few lines without webpack. For example my open source project, msngr.js, uses grunt and it's only a few lines of code specifying input and output.

I also have a private project that does the step with a loop and a few additional lines of code (uses no grunt or gulp).

> JSX to me is the more natural way to use React. I don't understand what the benefit of moving away from <html> is. It's more verbose, and harder to read if you construct your views in pure-js. (imo)

JSX is probably a more natural way of working with React but it still abstracts away from the awkward JavaScript and HTML realities of the day. I've become jaded with frameworks that do that because I've run into far too many developers that don't understand how HTML and JavaScript really work and run into errors that are easily fixed if they understand how the underlying technology works.

HTML's relationship with CSS and JavaScript is still kinda awkward so I understand why there are seemingly dozens of frameworks that abstract away from the whole thing.

> To me, using webpack is avoiding complexity. It's a set and forget exercise, sure it's a bummer upfront. But once it's running, it's pretty smooth.

I've used it and just didn't get the point of the thing. It helps that I avoid pretty much anything that gets transpiled (otherwise I could see it being more useful). If you don't do anything with transpiling I don't think it's very useful.
Reading the Wikipedia article, it sure sounds like it was worth trying out once as an experiment. At the very least, it established that 50kW was a good maximum.
"existentialism is concerned with the emptiness, horrors and anxieties of being alive"

You're mistaken to think so about existantialism. I suggest you read "Existentialism is a Humanism [1]", which is a document I've studied very recently and one that I'll study again, and one has been influential to me. Existantialism is an idea based on the hypothesis that man exists without a purpose, without a creator and without predefined values, i.e. he comes to exist before his essence, that which he is responsible of and confined to defining and creating by himself; and that he "in fashioning himself, fashions man", i.e. with his decisions, he demonstrates what he thinks is apt for all the humanity. The linked text explains it all better than my humble summary.

[1] https://www.marxists.org/reference/archive/sartre/works/exis...
promise and cb are poor design imo.

promises are unnecessarily complex, promises replace this paradigm:

data = foo()
bar(data)

both could be probably be replaced by a new keyword (if we make compilers a tad smarter)

foo = fn1()
bar = fn2()
await foo,bar
baz()

callbacks definitely have there place but should not be used for returned databases query et al, execpt for transforming the data like a middleware: db.query(..., datatransformfn)
Most people have never heard of him, but Michael Lewis' The New, New Thing immortalises Jim Clark, the most interesting billionaire on the planet.

Thanks to The Big Short I've been made aware of this book but is it worth a read in 2016? What does the HN crowd think?
For go version changing line 10 to
rc = make(chan int, 10)
make it 2x faster
Artificial Intelligence Could Leave Half the World Unemployed in Just 30 Years
200-character-long-lines don't fit in an eye's useful field of view. The problem is that websites have multiple columns of varying fixed width, so that a narrow window will give some websites a tiny actual line-width.
Here's what I think is the source website with ground level and LIDAR pictures of the road:
http://www.romanroads.org/gazetteer/rib-catt.htm
And Haskell, in the comments.
Does anyone know what the 2nd "processes" is referring to, in the 2nd paragraph here?

---------------------------

In a sane world, specification 30 words long, like the one above, would be implementable in 100 lines of C code. If it requires several thousand lines of code, there's clearly something broken with our programming model.

As I've argued in part I of this essay, to get a simple programming model you have to spawn a thread per TCP connection. But given that threads are expensive (and processes even more so) and that sharing state between threads is insane, bordering on suicidal, what you need are lightweight green threads and a simple communication mechanism to send messages between them. In UNIX of old they were called processes and pipes. In Go they are called goroutines and channels. In Erlang they are known as processes and mailboxes.

-----------------------------

I understand this:

"But given that threads are expensive (and processes even more so)"

but I am confused by this 2nd use of "processes":

"In UNIX of old they were called processes"

Was there an old version of UNIX that had lightweight threads? What were they? How were they implemented? How were they different from the processes we have now?

When I think of processes on Unix I think "threads are expensive (and processes even more so)". Was this different at some point in the past?

As to implementing new communication protocols, none of us should underestimate the complexities. Jon Postel was not stupid, but even he made mistakes. Recall that by 1973 they felt they had TCP 3 in a mostly final form, but then in August of 1977 Postel said they had made a terrible mistake by lumping too much together in TCP. He then spent a year pulling TCP and IP apart into the 2 separate protocols that we have now.

That example is well known, but if you read through the old RFCs, you realize there are some ideas that were explored and then abandoned. Among the really wild ideas:

"we are contemplating allowing sender and receiver to specify different byte sizes and consider bits as the basic unit "

This is from:

https://tools.ietf.org/html/rfc128

And if you try to create your own communication protocol, you will also go through a similar period of trial and error.
Fifa 14 Hack – FiFa Points and Coins Generator No Survey
actually Future.sequence() will run dispatched. it would just make no sense to run the single number concurrently, as the go version won't do this, too.
Future.sequence uses the global Executer.

sum := 0
for i := 0; i < div; i++ {
sub_num := num + i * (size / div)
go skynet(rc, sub_num, size / div, div)
}

This is the go version and only the inside will run on a thread so I made a fair comparsion P.S: The go version will actually run single threaded when you are having GOMAXPROCS=1.
Concurrency model will be a big focus for Swift 4.

(Swift is currently v2.2, the focus of v3 is to stabilize the ABI.)
That's somewhat encouraging, but if I understand it correctly, it would only be practical for static typed languages. Something like Lua, Python, etc, would be more desirable to me.
http://without-systemd.org/wiki/index.php/Main_Page
My god do I enjoy dynamic content. Having the reader choose one variable (age, in this case) massively improves how relevant the content is. There is another article where you choose your county or districts that massively rewrites after you pick where you born, but I can't find a link.

Any other examples of interesting dynamic content?
"In 2011, 18.1 percent of teenagers smoked. Now, 15.7 percent do. That’s a 13 percent decline." I don't know about that one slim. Them numbers seem funny to me.
Can you link me to some of these apps that let you write code on the phone itself? (Preferably Android, as that's what I have.) I haven't actually used any, and I'm curious.

But the important point is -- the phones don't come with them. The TI-82 literally had a button that you'd press to access programs, and the submenu within was "Run" or "Edit". That discoverability was very important. The kinds of people who would search for and use apps to write programs on the device are the kinds of people like us, who don't need it. (I do all my Android development in Android Studio on a workstation, for obvious reasons.)
Miller 3.4.0: JSON, reshape, regex-captures, and more
If you want to get more into Ansible and write roles that work on many different platforms, check out my test-framework:
https://github.com/rndmh3ro/ansible-test-framework
The next sentence:

> Of course, this isn’t the first time people have lusted after artificial human entities

Stop being overly pedantic. You'd be better off criticizing the first picture, which is actually two robots, not a human and a robot.
I thought it was 1913 BC Pygmalion. The play.
Wasn't there that guy convicted in NS recently convicted of facilitated PRs staying outside Canada? As a Bayesian, that makes me think it is pretty widespread.
New FD.io Open Source Project Offers IO Services Framework
> for the next billion smartphone users a smartphone will be their first computer.

Smartphones will be their first and last computer. Laptops, let alone desktops, are being permanently bypassed.
I'm not addressing your overall point, but one thing I learned about recently that could help in debugging those Ruby one-liners is the `tap` method. You can stick it in the chain and set a breakpoint.

http://ruby-doc.org/core-2.2.3/Object.html#method-i-tap
I think TerryADavis wanted to say:

"TempleOS compiles to x86_64 machine code all the time. It never interprets. It works both AOT and JIT.

In place of a AST, it has a stack machine code representation which gets converted to x86_64 machine code in the final pass."
There's a market for every toy. Robot feels weird, sounds funny, looks creepy? Sell to the weird funny creepy crowd.
You're on the right track here, but opiates and alcohol also create a lingering hell for the sufferer called PAWS. The longer a person abuses a substance, the longer PAWS lasts. It is not uncommon for PAWS to last a year or more.

To be successful, a person has to somehow manage & deal with PAWS, while also facing life, and the deeper causes of their addiction. This is why I am an advocate of recovery that includes bupenorphrine. It allows a person who has the right motivations the space to recover.

It is an unjust tragedy the way this country/world treats people who suffer from addiction.
Release of SLF4J version 1.7.15
Mastery by Robert Greene in 4 minutes flat
> I also tried spawn_opt/5 with reduced min_heap_size option - it doesn't help.

Yeah whether using spawn_opt or VM options (-hms and -hpds) it doesn't look possible to reduce the process heap (or process dict) below the initial size, only to increase it.
cf "It's time to embrace structured approaches to parallel, asynchronous,
and concurrent programming." ~~ http://jnthn.net/papers/2015-yapcasia-concurrency.pdf#p=76
(18.1-15.7)/18.1 = 0.1325

In other words, of those who smoked, 13 percent fewer do now.
> Further, smartphones are increasingly becoming production devices, too. They're becoming bigger, more powerful, and some can now be plugged in to monitors and bluetooth keyboards and create a reasonable windows production environment, others have interesting note-taking capabilities.

We're talking about multi-gigahertz quad-core devices with gigabytes or RAM, USB connectivity, Bluetooth, and a high-speed WiFi cards. The fact that they are designed in such a way that connecting them to a keyboard is seen as some kind of achievement is fucking ridiculous. That alone proves the author's point.
Ah, that's right. Everyone implements the compiler spec the same way every time, because we live in a perfect world.
I think a lot of people are overlooking something really important here. There are numerous comments about optimizing the code to perform better on this task. I might even go as far to say people are taking offense because their language of choice didn't perform as well they'd hoped. Many of these comments add complexity to the solution and make it harder to maintain. I like the fact that the author kept things simple. It's kind of like using the default settings for each language and then comparing the results. Both the simple version and optimized version are important data points, and they give you a better view of each languages limitations.
This is awesome. Easier said then done, but, yes. Coding is a craft, and always will be.
Sounds like a criticism that could be made of the Sorkin Steve Jobs movie.
Haskell version is naive too.

My laptop runs the original in about 3.07s and my improvements bring it down to 1.20s though I think there's room for improvement.

[EDIT] My improvements were actually not the same algorithm as the original's, with algorithm corrections my version is actually slower!
This seems to be a mechanical calculator. I've always found mechanical calculators fascinating and delightfully intuitive, because of how physical they are --- you can actually see components move around and perform calculation. Although in this case, I would've liked to see more details on how the sum is generated.

Related: Super Mario Maker is Turing-Complete: https://www.youtube.com/watch?v=HcLE1MuyodA
Has this author ever heard of 'minimum viable product?'

I doubt the lack of nanotech to create perfect artficial skin (or many of the other features mentioned) are going to hold this back.
I dunno, with years of experience in OO (ruby for the past 7 or so, Java before that), this still definitely hits home.

I don't agree with the commenter that suggests these suggestions are harmful on code written in OO style -- although they specifically say code written in "Java/.Net/C++" style; maybe? But not ruby/smalltalk/ObjC style.
Similarly the Haskell and Erlang are using lightweight threading.
Plenty of good (considering their costs) 3d-printers designed in OpenSCAD, which are a kind of CNC machine.
Overwriting Hard Drive Data: The Great Wiping Controversy (2008) [pdf]
When I teach teenagers I tell them, there's never time to do it right OR to do it again. Time is money; Engineers are paid to solve the problem and not make a beautiful thing. Get used to just-in-time solutions and just-good-enough implementations.

With that in mind, its important to have some discipline, to make your 'just good enough' not too crappy. That's the difference between an apprentice and an expert.
A Henry Miller quote: "Maybe all one can do is hope to end up with the right regrets" - I find that very therapeutic.
IMHO apps like Tasker are an interesting example. They (mostly) work in the app-ecosystem, but people use them to work around limitations in other apps. Especially Tasker is "strong" enough that other app authors offer hooks for Tasker to control the apps.

On the other end of the scale, I have a python interpreter on my android phone (although I don't use it very often)
Machine Learning – A gentle and structured introduction
From the description, almost 90% of created tasks in this benchmark are tiny "leaf" tasks, which are quite likely to be optimized away completely. So it looks like the benchmark compares how well these compilers optimize one particular case, and not general performance of goroutines/tasks/whatever...
I think this highlights a common issue when development is (or feels) rushed. You either end up with developers having only done the first part of each of these pairs (repeating themselves, ball of mudding, etc), without time to clean up as part of each iteration, or, you find developers immediately shooting for the latter half of each pair (DRY, modular, etc) without having done the former, and so you get abstractions that make no sense, overly complex interactions in a shared function as they attempt to be DRY, etc.

This latter is also, I feel, what informs a lot of the monolithic frameworks used for 'enterprise' development, Spring and the like, where a predetermined architecture and structure of the app is imposed by the framework, and which leads to, once you get down in the weeds of dealing with odd edge cases and things, hackery on the part of the developer, or framework bloat if the framework attempts to address the most frequent of those cases.
From Iterators to Ranges: The Upcoming Evolution of the STL
Consider that smart phones have only been around for a little more than a decade. It took several decades of development for general-purpose computers to become viable to the mainstream, so the smart-phone technology is just in its infancy.

While the battery consumption issues are definitely a problem, progress is being made to curb them:

http://news.mit.edu/2016/neural-chip-artificial-intelligence...

Really we need innovation in the hardware space in addition to less bloated and more refined APIs. Perhaps more efficient Virtual Machine layers that sit on top of the OS layer. Or even get rid of those entirely and force C++ only, but then the precious security sandbox is gone. In any case, it seems a lot of the OS changes being made are feature-driven more than anything. They are trying to compete on features instead of stabilizing and refining the core. Or, maybe we need a new mobile OS design and some open hardware to support it. Personally, I think BB10 had a lot going for it with QNX and C++ APIs, but because they don't have the precious "apps" consumers demanded it became even more bloated with the sluggish android runtime.

What's more, Device manufacturers push higher-resolution displays and faster CPUs and GPUs--all things that impact battery life. But why not improve upon these gradually while bolstering battery life instead? Consumers won't buy it that's the problem and hardware manufacturers just want to sell units to satisfy shareholders.

The problem is no different than the junk-food industry: consumers don't know what's best for themselves or what they need, yet they develop strong opinions about what they want and companies, hungry for market share meet those demands.
I understand your reluctance to give the email address. Did you check the video?