skysight-inc/HackerNews huggingface dataset:
I won't address all your points, but I think [1] deserves special attention: I think we can all agree that if you want to write software that will let you land a small vehicle on Mars, then you don't want/need the opinion of a theoretician, you just need $1B and a team of extremely disciplined programmers who will ADHERE TO PROCESS. Then you impose so much process that they either leave or prevail. What we're speculating about here (at least I think we are?) is if this is a sustainable model for general development and if we can do better. Even if we can't get better runtimes from FP languages, could we perhaps make programs which generate better C programs than those elite programmers that were chose for this particular mission? (I think we can. It has very little do with humans, but a lot to do with the fact that programs are very meta in that we can create programs that generate programs that generate programs ad-infinitum. If we can get our specifications right, the rest becomes trivial.)

A Mars lander program director explicitly said that he chose C because it was what he was familiar with. (I'll edit and post a link if I can find the video.) Just for context, his decision was also based solely on familiarity and experience. For him it wasn't quite so much about language, it was more about process (6 different industrial-strength linters, etc.)

> Just because something is elegant mathematically, does not mean it's good engineering practice. Haskell, for example, can be practical, but it struggles between the math and the reality of limited machines and human cognition[2]. Likewise, when you start talking about SML vs OCaml, you're talking engineering, not math -- and possibly a language tailored to engineering vs math.

That's the thing I would dispute, but it's hard to convince people who aren't already drinking the Kool-Aid, as it were. Compared to compiler-assisted reasoning about side-effects, the difference between SML and O'Caml is completely trivial.

Your [2] is just absurd :). Clearly, you don't have to understand the body/implementation of a function, just its type. :)

More seriously, I'd be interested if there's a particular experience that soured you on FP (or perhaps Haskell, in particular)...?
I haven't used websocketify. I'd be interested to have users try out both and write up their experiences.
Actually, the Gerrit workflow is pretty agnostic about whether you use one or many commits.

In general, it's poor form to send massive commits anyway. Those poor reviewers!
:) Thanks! And yes, I don't know about Anthony, but my intention has always been for Vinyl to be a proof-of-concept for what happens when you try to make a clean, minimal & well-factored HList experience; my motto is, “Now build your own Vinyl”.
Which makes no sense, anyway. The reason a Hello World program in Go is large is because it must include the baseline runtime support that is included in any Go program. A 10 line program won't be 13mb.
I'm going to be a little pedantic, but since this is an article about security (and your point is also about security, of a marginally different type):

> You already have trustworthy people, and people with the relevant skills and connections.

In security, there is a distinction between 'trustworthy' and 'trusted'. Organized crime definitely has trusted personnel, but, 'trustworthy'... maybe not.
What works for me: start them all and see which one sticks.
> if you are writing such systems (in either language) you are very likely to spend quite a lot of time in 'unsafe' land.

I don't think that's necessarily true. Go does a much better job than Java at letting you manage your allocations and re-use memory. You can write tight, performance-critical code in Go without resorting to 'unsafe'; it just requires care, as it does in any language.
Show HN: 3Derm, 3D pictures that detect skin cancer
So who would pay for a tool to make creating/handling/analyzing these links as easy as using UTM parameters?
They're probably using Gerrit.

Although I agree, I don't think merge commits are ugly. I think people coming from SVN/CVS where history is strictly linear have this obsession with keeping it that way.

In fact I find lots of developers just have an obsession with "clean" history, and fetishes for particular tools. It baffles me.
This kind of website does not have a URL for every piece of information: it has a public URL for every potential piece of information, and it expects those to show up in search results. This would be similar to having every combination of words show up in your search results as a blank page on Wikipedia that you can edit to add content. When I use Google to find content, I want to find actual content, not ten billion placeholders: if the site doesn't have information on a particular phone number it should return a 404, not a 200, and not be indexed; there should then be a way to submit information into the database (actual information, not something totally useless like "reported") that then creates that URL. From the home page (which hopefully at this point has high page rank for being a non-spammy resource) they then should link to a list of "updates", which will be seen to change often, and the links on the other end of those will also change often, so Google will pick up new content quickly and efficiently. Yes: I realize that these websites are trying to rely on the search query as their discovery tool to get people to add content, and so doing this "harms" them, but if every one of them does this it becomes a useless discovery tool anyway (as the page of results is just pages and pages of these placeholders); imagine if every wiki did this: chaos.
License Fees vs. Total Cost of Ownership
You should forward her this as well:

http://chronicle.com/article/Why-Privacy-Matters-Even-if/127...
Every modern authoritarian regime relies on mass surveillance as a cornerstone of its power.

Edit: for example, North Korea, Soviet bloc countries past and present, Fascist states...
This said trying to be completely free of condescension:

What you are feeling is inexperience. It gets better.
Safari appears to do the same. Version 8.0.3 (10600.3.18)
> I would almost go so far as to say browsers and search engines are killing the web. It's no longer a web.

How do you want people to find things on the web if not via search engine? Do you want to go back to the days of the "Web Ring?" Or are people supposed to crowd source their search via their social graph on Facebook?
Link is down =(
One of the previous slides says they are using Gerrit.
Because it has a good suite of tools that work out of the box. There's LDAP, webmail, webDav/calDav/cardDav, admin interface, antivirus, anti-spam, etc. It integrates well with OwnCloud too which is a nice plus.

When I was looking to move away from gmail, my requirements where security and privacy and Kolabsys was one of the first services that popped up as a viable alternative.

The thing is, I was also looking for a reason to try out AWS and get back to using linux after years of powerpoint and archimate _poisoning_ so everything came together like that.

I highly recommend it, even if it took me about 5 working days to get spamassassin, openDKIM, ciphermail and TLS working for all components. But hey, now I get a 94% grade on www.emailsecuritygrader.com and a A+ on SSL Labs's test so hurray for me.
This presentation looks horrible on the iPhone screen. I wonder if they couldn't spend a few minutes to point phone users to a working version or at least not lock the viewport size so mobile users could pinch-zoom out.
The Large Hadron Collider gears up for restart
Instead of ADTs there are object variants in Nim: http://nim-lang.org/manual.html#object-variants

With ADTs:

data Shape a =
Rectangle
{ x :: Float
, y :: Float
, width :: Float
, height :: Float
}
| Circle
{ x :: Float
, y :: Float
, radius :: Float
}

With Object Variants, note that we don't have to repeat x and y:

type
ShapeKind = enum Rectangle, Circle

Shape = object
x, y: float

case kind: ShapeKind
of Rectangle: width, height: float
of Circle: radius: float

The pattern matching in Nim is quite limited. Something like this works:

let (x, y) = getCoordinates()

But Nim doesn't have (x,y) = (y,x) for example, instead swap can be used.

You could implement your own pattern matching using metaprogramming: http://www.drdobbs.com/open-source/nimrod-a-new-systems-prog...
Is there a flagship project using Nim ? Rust has Servo. I've read here and there that this is the best way for a language to catch on.
Edit: This commit was written to the original submission: https://talks.golang.org/2015/state-of-go.slide#7

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

It seems like these people simply don't understand Github very well.

Can only view diffs on a single page (can be very slow).
Cannot compare differences between patch sets.
Accepting a patch creates a "merge commit" (ugly repo history).

Don't use the merge button, just add the requester's repo as a remote to yours and use your familiar tools. If possible and done, a fast-forward merge + push will also close the PR.

Comments are sent as they are written; you cannot "draft" comments.

How is that different from pull requests via emails? (Also, on the website itself the comments can be edited.)

To create a patch one must fork the repository publicly
(weird and unnecessary).

What exactly is weird about that? It makes it possible for the requestor to craft their changes with full control, without requiring upstream to give them write access. This point is just entirely nonsensical.

In general, pull request culture is not about code review.

A strong claim, but one without any justification, and which is, in my experience, as far from the truth as possible.

Edit:

In light of their complaints about the need to fork, i have to say that their current contribution process can in its entirety be described as weird, unnecessary and baroque:

https://golang.org/doc/contribute.html
The Voice of David Carr
Java works on Android Runtime (ART). Clojure barely works on dalvik, let alone ART.
Since you want to do the features with the highest impact per unit effort first, the units used for estimates don't matter. You could replace a time estimate with a number between 1 and 10, and that's equivalent for prioritization purposes.

As long as you don't let the difficulty numbers get translated back into dates, you get the best of both worlds. You don't waste time on projects that aren't worth doing, and there's no deadlines and estimates to cause friction.
I always thought it was the oppressive laws, poor economies, concentration camps and (in many cases) out right starvation of the populace that held the people in check. To me those things seem a lot more important that the gov't snooping on my email.
Which website? whocalled.us does not generate or list any URL that does not have information. Empty pages were never indexed by Google.

If you search Google for a random telephone number you will see a ton of empty sites who list every possible number. whocalled.us has never done that.
GitLab CEO here. Both GitHub and GitLab normally always create a merge commit when accepting a merge request in the web UI. GitLab EE has a rebase feature where you can accept merge requests by automatically rebasing them just before merging, for more information see https://about.gitlab.com/2014/12/22/gitlab-7-6-and-ci-5-3-re...
It's not that big of a deal to have these fields visible in the first place. The post is a nice trick, but I doubt it has a market for a startup.
> "In general, pull request culture is not about code review."
> I have no idea what this means.

Me either. To me, the entire point of pull requests is about triggering (code) reviews. If I don't want to bother with review, why not just grant direct push access and skip the rubber stamp ceremony?
I'm honestly not as well versed in what the latest alternative cryptocurrencies are as I used to be. However, I don't know of any that have solved the problem of blockchain bloat due to increased microtransactions.

I still think Bitcoin would be the best choice at the moment. It has a developer community that is actively working on solutions to the problems that keep it from being better suited to large numbers of microtransactions.
I generally prefer programming with immutability, but I certainly appreciate the ability to use "benign effects" in my programs. Besides the case for performance, I have applied a strange combination of benign effects, GADTs, and functors to generate a sort of "proof of type equality" between two values passed into a framework, each of which are not known to the framework because they're passed into the framework by two separate clients of the framework. At that point, I had the ability to reason about two values with arbitrary and potentially distinct types, as either being not the same (None), or the same Some(x, y) with x and y having the same type.

I have no clue if there's a more elegant way to do this (edit: there probably is), but even I (as a n00b) was able to figure out how to do this by using benign effects. There's only a single mutation in this library - but it was such a critical one that made everything else possible.

I'm curious about the reason for preferring generative functors over applicative functors. It seems like both could have valid use cases. Could you point me to a writeup that explains why you believe generative functors are superior?
> Besides, bickering over the size of hello world is pretty pointless; better to compare the size of programs that actually do something.

It is not about the size of hello world executable, that is just a symptom. A code smell if you like. There is something badly broken in the dead code (or dead data) elimination area. And I hope that code is in fact dead, because if it is not, add code generation to the list of smelly things.

What I suspect I see here is a kind of C++ vtable problem built deep into the language design somewhere. And the reaction is, let's talk about large executables so that it would kinda become not so visible. Or maybe let's take a look at glibc, because glibc is definitely a paragon of clear design befitting a new language.

> fmt.Print does use reflection

There are two problems with this. The lesser one is why does it need reflection to print a string. The bigger one is why do I see about 600 reflect.* entries in the resulting ELF instead of a single one for the string type.
Exactly! No architecture, no structure, no process, no documentation and with some luck, no money either.
That's like trying to predict the cost of a flight by cost per mile using a quote from SFO to SJC as a baseline.
I was generating 7-15Mb binaries out of Delphi in the late 90's (it had a similar kitchen sink approach) and it simply wasn't an issue then and it certainly isn't an issue now.

I'm actually racking my brain for a case where a 500kb vs 5Mb binary would be a deal breaker, outside of embedded stuff I can't think of much.
This is not my alt account. I'm just not that active. These are not outliers, you are simply incorrect. If you believe your assertions to be anything but assumptions and blase accusations of entire cultures, I'd be happy to read your published work on the matter.
I think it's a combination of playing around and math chops.

Without any mathematical knowledge, you probably couldn't come up with something like the s(i,k,o) function (which, as far as I can tell from just looking/playing around with them briefly, seems to be the function responsible for the tessellation offset), and you might not have thought to define a system like (x=X(N,t), y=Y(N,t), 0<t<1).

Without a nontrivial amount of playing around, you probably wouldn't have found the exact constants used, like (2pi(3^i)), .2/(2^i), etc.--but knowing how altering those affects the end result takes some mathematical knowledge, so it's more guided investigation than random guessing.
> where you often have many iterations or the diffs are large). But for many other projects the UI that GitHub provides is sufficient

GitHub is painful for non-trivial reviews. Biggest WTFs:

- No comment threading (or at least collapsing). On a PR with 100 comments[1] it is unlikely that those revisiting the thread need to see (and download, and render...) the first bazillion comments.

- Source "annotations" are lost after a force-push (why not keep around a read-only view of old comments? We have lost some valuable discussions on GH pull requests)

Yes, we try to keep PRs small. But they also need to be meaningful, and sometimes they require (many) more reworks than expected.

[1] https://github.com/neovim/neovim/pull/1820
You have to like your tools and stick to them, that means your text editor for notes and immediate todo lists and access in the cloud, also that list of inspirational themes, quotes and links you'd like to research, eventually; but also includes that programming language, framework and patterns you have to adopt and stick to, just to give yourself enough time to master it, and only then it will make sense to take next steps to a higher level or to test that other new/cool technology. Love your tools and knowledge and stick to them until you really need something else.
Elementary OS switches to a .io domain
Thank you, I'm going to read through those carefully.
GitLab CEO here, I completely agree with your observation that people coming from SVN have a hard time adjusting to non-linear history. At GitLab we recommend embracing it https://about.gitlab.com/2014/09/29/gitlab-flow/ But we also believe in the freedom to do what you want, see there is a version of GitLab with automatic rebasing to allow a clean linear history without having to rebase by hand https://about.gitlab.com/2014/12/22/gitlab-7-6-and-ci-5-3-re...
Could you elaborate a little about why you rejected Erlang?
Note here, elementaryos.org now redirects to elementary.io - the .org is nothing more than a redirect
Gerrit still produces merge commits unless they have it configured to cherry-pick onto master, which is insane because you are changing the commit sha at that point.
Named arguments may be just "syntax sugar" but its one of the biggest things I miss from Haskell. They make library functions more consistent and they also make it much easier to write point free code because you don't need to resort to combinators like "flip" or "." as much.
"not a dynamic executable"

In case you wonder, that's dietlibc which is typically built with no dynamic linking capabilities whatsover.
That's exactly what we do, and we need to change the commit hash because we want to include the review information in the commit message.

Not sure why this is "insane."
Stanford NLP is pretty good, if you are on java - http://nlp.stanford.edu/software/corenlp.shtml

You might also want to look at word2vec (implemented in most of the popular languages) - https://code.google.com/p/word2vec/
> I think people coming from SVN/CVS where history is strictly linear have this obsession with keeping it that way.

This has absolutely nothing to do with those, especially since they didn't even allow cleaning up histories. There is one very simple reason for why some developers prefer a linear history of master:

It makes debugging very easy.

With branch merges, especially when the branch lines cross, or the merge is an octopus merge, the complexity of the code necessitating inspection to find the root cause of a bug straight-up explodes. Meanwhile with a linear history it's not only easy, but automatable to find a commit that breaks a thing.

I do realize that you may not have had the displeasure yet to be in the situation to learn these things. Please feel free to consider yourself fortunate, but please also do try to understand that the things i just wrote are in fact simple observation of realities.
Multicore:
https://github.com/stedolan/ocaml

Modular implicits:
https://github.com/ocamllabs/ocaml-modular-implicits
OPAM still doesn't run natively on Windows though :(
No they don't. Network-bound apps are rare, unless your app is e.g. file transfer or media streaming.

The overwhelming majority of apps is disk I/O bound.
This is interesting to follow; I basically agree with your take, but I also know precisely the kind of libertarian "anarcho-capitalist" type that Rayiner is effectively responding to, folks who follow in the footsteps of Murray Rothbard and company. They elevate "coercion" to the highest possible crime: you cannot have a state that isn't invested with the power to coerce its citizens' behavior, ergo a benevolent state is impossible. So they fashion themselves anarchists, either unaware of or choosing to downplay the very anti-capitalist roots of anarchism. (And Rayiner's observation about the frequent criticism of "a state monopoly on violence" from that crowd is one I've also had; as opposed to what, exactly, a free market for violence? Or a natural monopoly on it, perhaps? I understand their criticism to be valid concerns about what the failure conditions of that monopoly lead to, but many of the alternatives are horrifying in their success conditions.)

Turning this back on the actual topic, though, what do you think the libertarian response to the problems in your last paragraph should really be? I can't think of any reforms which don't still depend on the state following its own rules for both what it's allowed to collect and what it can do with the data it does collect. Granted, merely having those rules--which we largely don't--would be an improvement, but it feels like it's in the "necessary but not sufficient" category.
How do security issues happen in programms?
That's a nice approach for debugging! If the mapping is close enough, I don't mind reading the JS output. I'm curious about the general approach to compilation, though. It seems like a statically typed language could take advantage of the knowledge of types to generate an even more efficient version of the program that uses typed arrays and views (though, yes, it would require implementing a garbage collector unless relying on some kind of WeakMap in the JS engine).
I've heard of garbage collected languages compiling to LLVM which would allow Emscripten to assist you, but I've also heard that LLVM has a really hard time with GC languages.
Yes, at least in the media, there is a lot
of confusion about how e-mail and 'open'
work. E.g., for

https://news.ycombinator.com/item?id=9050436

about

http://www.nytimes.com/2015/02/15/world/bank-hackers-steal-m...

in that NYT piece on hacking banks in
Russia there is:

"In many ways, this hack began like any
other. The cybercriminals sent their
victims infected emails — a news clip or
message that appeared to come from a
colleague — as bait. When the bank
employees clicked on the email, they
inadvertently downloaded malicious code.
That allowed the hackers to crawl across a
bank’s network until they found employees
who administered the cash transfer systems
or remotely connected A.T.M.s."

So, to get infected all they had to do
was just click "on the email"? Not even
click on an attachment! That must be some
strange, dangerous e-mail software!
I use tmux and either tmuxinator or teamocil to accomplish this. I use vim as my editor so it just works within the shell.

Each project can have its own tmuxinator config and load up tmux with a number of shells. There is even native tmux support built into iTerm2 but I haven't used it.
Why the Tech Industry Fails at Awards Shows
If you look at this from an "expression problem" point of view, this version with the records-of-functions is very similar to OO programming. But without inheritance, classes and so on.
Oh, this is going to be so fun for doing terrible things.