skysight-inc/HackerNews huggingface dataset:
Adding my own two cents:

- I like that with OCaml you can choose if you want your code to be functional or imperative, and both are equally well-supported. I am writing a compiler in OCaml, and I am able to use the API described in Peyton-Jones & Lester for doing pretty printing while still using imperative algorithms from the Dragon Book. This sometimes feels like cheating, but not having to figure out how to transform imperative code into functional code while still maintaining the same complexity constraints is really nice.

- OCaml code is usually a lot more "boring" than Haskell code, which is nice when reading other people's code. Let me explain: I am T.A.'ing an intro to compiler class where some students use Haskell and some use OCaml. The Haskell styles of the students varies a lot: some prefer to use point-free style, some used Parsec others AttoParsec, some passed state around manually while other use a state monad, etc. The OCaml submissions on the other hand were a lot more homogeneous: ocamllex for the scanner, menhir for the parser, the AST definition was almost identical to mine, and the code generation was also very similar.

- This may just be me, but I have had less problems with opam than with cabal. Also, the merlin tool and its integration with Emacs are really good and give me the kind of minimal, out-of-my-way IDE experience that I am looking for.
The guys who made Go (Robert Griesemer, Rob Pike, and Ken Thompson) actually found that it was Python and Ruby devs that were adopting Go, rather than C++ devs like they expected [1].

[1]: http://commandcenter.blogspot.com/2012/06/less-is-exponentia...
The syntax is certainly very wonky but you get used to it. Installing merlin (vim / emacs plugin) helps a lot too.
Not sure why you were downvoted as opposed to OP but this thread is full of people who don't realize that Google is truly a place where employees are encouraged to speak up when things are bad. Frankly, organizations would never be able to fix their mistakes if their employees are censured when they speak up.
After numerous discussions with Bob Harper (and reading Derek Dreyer's work, who has been the biggest proponent for applicative functors), I have come to understand that there are only two compelling use-cases for applicative functors:

1. higher order functors.

2. modular type classes

Higher order functors are kind of cool, but IMO Standard ML does not seem to be suffering too much from the lack of them. I'm not too interested in it, since it gets super gnarly super fast, and this happens to be pretty much the main use-case for applicative functors. I suspect that most use-cases of higher order functors in OCaml could be reformulated to be first order, with a lot less monkeying around in the module system. There may be compelling use-cases though.

The other use-case is possibly a version of modular type classes that behaved a bit more like Haskell's. The idea is that if functors are going to be applied automatically during elaboration to provide something like type classes, you'll get MkWelp(S) called in multiple places, and you would prefer that any type members of the resulting structure be compatible. Applicative functors would do this.

I am not too convinced by this use-case, though I could see that people would find it useful.

In all other cases, generative functors have the correct semantics. Pretty much the whole use-case of putting abstract types in a functor is that you can then reason intensionally about them (i.e. distinguish them based on their access path). This is super useful, for instance, if you have a notion of "index" or something and you want to prevent yourself from using indexes from one table in another one, or something along those lines.

This is what the Scala people mystifyingly call "path dependent types". It's just generative abstraction.

So maybe it is an interesting feature to have applicative functors, but these should be added post facto, and generative functors should be the default. OCaml now supports generative functors if you add an extra () parameter; it's strange syntax, but it's good enough for me! :)
As far as I can tell from this, the authors worked really hard to implement in Haskell something that is trivial and well-understood in Python and other languages.

Maybe the article could talk more about their specific needs, but this looks like a crud app made very complicated by the choice of unusual software for the task. Maybe it did something awesome, but this doesn't tell us what that was. (They had to write their own ZeroMQ broker, after all. That was certainly costly.)

I don't understand the claim in this article that concurrency in Python is hard. There are many reasonable ways to do it for the web, from multiprocessing using something like uwsgi or the excellent gevent. There are certain things that are hard, but for common patterns like web services, there are many awesome solutions to choose from.

And I don't understand why memory footprint is seriously a factor here. Server runtimes may use all the memory available to go fast. As long as it fits, footprint seems a lot less important than other factors. The cost of buying an extra stick of ram is miniscule compared to the cost of having to implement libraries to support a language choice.

The choice of a pure functional language like Haskell to do lots of IO seems like a strange choice given that Haskell makes side effects like IO more difficult than other languages. I'm curious to know how that affected the implementation. I'd like to use more functional languages, but since my job is primarily IO of some sort, watching people struggle with writing to sockets leaves me more than a little hesitant.

Basically, this article is missing a lot of details to support the argument they have made.

"The satisfaction we feel after a good day of Haskell is unparalleled, and at the end of the day, that's what it's really all about isn't it."

Actually, since they appear to be working on a startup, I would think that a functioning business and time to market would be more important.
The Personal Software Quality Questionnaire
I agree with this advice. I just got out of b-school and my background is in computer information systems, but I am attempting to learn a lot more of the nitty-gritty aspects of computer science I was not exposed to in my university education. This includes topics like algorithms, data structures, operating systems and compilers. I do not know where to start and I've been using Hacker News to follow the tech scene as much as possible. Unfortunately I still feel that I am missing out because I chose business over engineering (which I continue to regret).

I'm just 1.5 years away from being 30 so I realize that I have quite a long time left in my software development career to catch-up to all you CS people. I don't think I've been undirected (the opposite of conscientiousness) but I've been misdirected and distracted. I've studied other things including web design and music production. I've also enjoyed life a lot (and slacked off by watching too much Adult Swim and Comedy Central, as well!).

It's hard being productive and studious all the time. While some people work 80 hour weeks continuously, most people don't out of need for sleep, exercise and relaxation. There is certainly an ebb-and-flow to this so I am embracing the idea that it will take me many more years of continuous growth and effort to get where I want to be. I also know that I need to eliminate as many distractions as possible, including turning off the TV and avoiding going out to concerts, clubs and bars. I have picked up some meditation techniques as well (including spending 10 minutes a day, at least once a day, focusing on deep breathing in order to unwind my frontal cortex). Sacrifice sucks but it is necessary to become the person you want to be!
Report says over 100 banks hit by cyberattack
> What exactly is weird about that?

I have no idea what they specifically mean, but I can tell you, that the github requirement of pr to come from public repositories on github is something that bothers me occasionally. There are lots of reasons why I may not want my github fork to be public or I don't want to have a github fork at all but do want to contribute to a repo hosted there. This is a distributed version control system we are talking about after all.

As for their claim about pull request culture, again I'm not sure what they specifically mean, but I find the github code review tools to be very rudimentary and suspect that lots of other people with experience with more sophisticated code review workflows feel the same way. Github is a great service for some things but it certainly is not centrally about code review.
If you're mmaping a file and processing the majority of it, you really are typically doing that in C today if you care about performance. You can get acceptable performance in Java with ByteBuffers, but because of the lack of value types it doesn't feel like Java any more. Go should be able to get much closer to C's performance, while still being closer to idiomatic Go code. And Go can plug in small pieces of C code / assembler for the really performance critical stuff.

All this can be done with JNI, but JNI is so un-fun that I can see Go making big inroads here.
So which one causes which?
It's essentially rewriting history. As a contributor it's nice to know a commit went in exactly as you wrote it, which is not the case when the commit hash changes.

Git is powerful because it was written with the ability to merge trees. The cherry pick workflow is throwing all of that in the trash. Why not use SVN at that point?

Because of cherry picking in Gerrit, dependent patches are a nightmare to maintain. Say patch c depends on b, which depends on a. Now say that patch c requires a change that merged into master. Because you can't merge into your development branch, you have to rebase c AND b AND a. This really pissed of the owners of b and a because it shows up as a new changset and wipes out votes. God forbid you depend on two different patches that each have separate dependencies.

You can use the merge commit to add the review information if you want. Then you don't have to molest the code change commit.
The problem is that it doesn't scale linearly. There's some O(n4) algorithm being used in netstat or some kernel syscalls or something. Once you go over 250k, things get _really_ weird.
What it comes down to is that you can't rely on Google for that, any more than Wikipedia could spam Google with a bunch of blank pages as a strategy to get passers-by to fill them in. People who already know about whocalled.us and use it regularly will have to seed it.

(Disclaimer: personal opinion; no actual knowledge.)
That's fair. But I don't think it's reasonable to lump learning about lenses (or other abstractions that aren't part of the prelude) into learning Haskell.
Private banks can't "create money". Are you maybe confusing them with central banks?
I chose not to list any page without at least 1 reported phonecall or comment. Competitors instead listed empty pages, and that is why they beat whocalled.us to the top results in Google, and gained much more traffic.

I thought it was spammy to list empty pages, and could not bring myself to do it. But the sites that do that are still indexed, and whocalled.us is not.

mysql whocalled -e 'select count(*) as empty
from sitemap s
left join comment c using(phonenumber)
left join phonecall p using(phonenumber)
where c.id is null and p.id is null'

+-------+
| empty |
+-------+
| 0 |
+-------+
As others said, their contract with Google is over - now they use Yahoo (and some others) which you can easily switch to DuckDuckGo if you want. And also you can switch off new tab ads trivially.
> The lesser one is why does it need reflection to print a string.

It doesn't print just strings. It can print anything. http://golang.org/src/fmt/print.go?s=6420:6467#L221

After doing your research, you're welcome to submit a magical CL and PR that brings down the binary sizes, then you won't need to argue anymore.
git bisect is a great tool for automating this sort of debugging in non-linear histories. That said I agree in general linear histories are much easier to deal with.
Show HN: I made this to stay in better touch with my mom during Y Combinator
Doesn't Go have the potential to be faster than Java since it's compiled to native code (rather than compiled to byte code)?
I am also a commercial developer; I work full-time during the summer to pay for college. My expectations don't really change much. Of course, everyone has different expectations.
Honest curiosity here. Given that there's nothing stopping you from deleting your fork after the PR is done, what reasons can you name for this:

There are lots of reasons why I may not want my github
fork to be public or I don't want to have a github fork
at all
Ask HN: Which stick computers are the most hackable?
I've recently grown interested in stick computers, those devices, usually based on ARM processors, that have roughly the dimensions of a USB stick and run a general-purpose OS. Which of these computers are most amenable to hacking, by either replacing the image in internal flash storage or booting an alternate image from a microSD card? Bonus points if one can rebuild the Android image from source. Extra bonus points for my current intended use if the stick has a headphone jack.
The thing with WebSockets is that they are message oriented. WebSockets endpoints are presented with a series of distinct messages, whereas stdin/stdout are stream based and you have to build messaging on top, if that's what you want. I guess the idea here is that you are just using '\n' as the message delimiter?
Unless you need to handle a very small number of concurrent connections, using 1 process per connection seems to be a huge overhead, although I can think of some use cases.

However, I can imagine a similar tool doing multi/demultiplexing, eg the handler process would take input text lines prepended with a connection identifier (eg. "$socketID $message") and output using a similar formatting. Pretty much like websocketd but with multiplexing and unixy/pipe-friendly (eg. you can apply grep/awk/etc before and after).

How would this fit compared to websocketd?
Blog post decrying bullying tactics blissfully unaware of its own hypocrisy:

"I seriously don't get why this guy has not been fired from the SPI organization immediately, this sort of bullying behaviour should not be allowed and, at least in my book, an apology means nothing. Someone like that does not belong to an organization that is supposed to help free software thrive and protect its communities."

People make mistakes and their lives and reputation do not need to be ruined for them.
I am refuted!
Every phrase you wrote has an implicit conditional in it:

> Children may take care of their parents, families may take care of each other, friends might offer housing and food to their friends.

At least one theoretical advantage to the state system that rarely gets talked about is that while its assistance also has the same conditionals, at least in principle, the conditionals are dependent on objective criteria. The state of your relationship to friends and family is immaterial; you don't have to accept terms imposed by religious charities or other organizations that will attach moralistic strings.
OmNomNomify It Cookie Monster Bookmarklet
For simple one-directional communication (Server to client(s)) as shown in the example, it may for many people be simpler to use EventSource [1]

I've used this for UI's where the server continuously sends/pushes updates to the clients. Really handy, and multiple implementations and libraries available in most languages.

Of interest is perhaps also the spec [2]

[1]: https://developer.mozilla.org/en-US/docs/Web/API/EventSource

[2]: https://html.spec.whatwg.org/multipage/comms.html#the-events...
I don't know if I completely agree with this. To write truly performance-critical Go, you end up throwing away many of the language's qualities. Channels are slow, defers add overhead, interfaces add overhead (e.g. I2T), etc.

Don't get me wrong, I like Go, but in my (and others I work with) experience, it's not the right choice for performance-critical systems.
Java is also compiled to native code, but only after it runs for a bit.
I'll be reading more into unikernels because it does seem like an interesting topic.

However, I strongly advise you to read up on how production environments are done in security conscious enterprises (banks, payment providers, etc) as you seem to make some assumptions in your comment. To give you some idea of the environments I've designed in the past:

A WAF worth it's name won't pass any request back to a webserver if it matches a known signature, method, payload, etc. This is a functionality commonly called virtual patching. SSH is usually only allowed on internal vlans and often requires some sort of external authentication mechanism like a centralised jumpserver or ldap.

Also, if using Solaris with OVM for SPARC you wouldn't boot up a new server but a non-global zone (think Docker but 2 years from now) which can be started in ~1 second and offer full isolation from the host system. AIX also does something similar and I've seen several different approaches used on Linux from LXC to VMware + F5 irule based auto-scaling groups.
Linearized histories are much harder to find bugs in. You end up looking through revisions that never existed; in SVN you merge the remote history into your local history without it ever showing up as a merge. The explicit git approach tells you something much closer to the truth.

Your condescension is only hurting yourself.
Also websocketd is multiplatform and does not require python. Neither good or bad, just another difference :)

Also, not sure if websocketify can but websocketd also has --dir argument and can supervise and route many sockets to many different programs.
Apps that make requests to other services are network bound.
Exactly, but this word is used to address specific recipe: http://www.japanesecooking101.com/tamagoyaki-recipe/
1. The pages actually gives you geographical information even if there are no comments.

2. Knowing that you are the first person to complain about a number is also informative.

If I google a number that no one has complained about, is it better to return 0 results, or at least some of these phone number websites without any comments? I would argue the latter is better.

3. Is it really appropriate for Google to ban an entire domain like this? They can arbitrarily decide that you can't have pages organized in a particular manner and have your whole domain banned?
A Gentle Intro to Unit Testing in Clojure
That bit is about Chrome OS (ie, a chromebook), not Chrome itself. The bit about it being "non-unique" means it's not a GUID - other people's devices will send the same tag. It does not identify you.

> To clarify, my point was that Google has a GUID (your Google account, and likely other forms of ID) that identify you pretty clearly across devices/Chrome instances.

I think the privacy policy is quite clear that Chrome does nothing here that other browsers don't do. Obviously if you have a Google cookie from signing in to the website then that's going to identify you pretty clearly, but that's just how cookies work, and would be exactly the same in any other browser. I'd like to specifically direct your attention to the first three paragraphs of the policy, and in particular:

"If you use Chrome to access other Google services, such as using the search engine on the Google homepage or checking Gmail, the fact that you are using Chrome does not mean that Google will receive any special or additional personally identifiable information about you."

> I saw nothing in the policy you linked that said Google AdSense and other Google ad services (DoubleClick tags, GA, etc.) do not use that information to link identities across devices for purposes of tracking.

I wouldn't expect to find any information about how AdSense works in the Chrome policy. The privacy policy for ads is over here and discusses this topic: http://www.google.co.uk/policies/technologies/ads/
The simplest reason is if what I was contributing was done on my employers time and they have strict IP restrictions. It is much, much easier to vet a single changeset than it is to a) verify a whole repo history and b) coordinate around my public/private github identities.
Pretty much. Good example is Joe's vmstats https://github.com/joewalnes/web-vmstats
Seems to only work on HTTP pages. Make sure to inspect the code of bookmarklets like this. It could be slurping cookies and sending it to a remote server.
I believe they are slightly beyond "syntax sugar". If I'm mistaken, I'd love to see the equivalent of what they desugar to. Some of the nuances that I believe OCaml's named arguments get right (and what greatly distinguishes them from passing a record) may require additional work in the type system beyond simple desugaring to something like records. Someone please correct me if I'm wrong.

- Partially applying arguments. You can apply one named argument, and get a function that expects the remaining named arguments. This is pretty great though confusing when you see it for the first time.

- Defaults for omitted arguments. If the caller doesn't specify an argument, you can define what should be used instead. This is kind of like the opposite of subtyping on record arguments. With structurally subtyped record arguments, you can pass a record that has more information than a certain minimum set of labeled fields. But with named optional arguments with defaults, you can pass less than a certain maximum number of labeled fields.
Well, there is this line in the output:

Delaying boot for 0 seconds. Hit enter to break into the command prompt...

...which gives at least the impression of there being a command prompt. As to how it would register a hit on that enter key remains to be seen, of course.
Exactly. But if you search a telephone number you should be given new information, not an empty page for you to fill out. Otherwise we end up with the situation we have now, where there's endless empty pages in the search results.
I disagree with "channels are slow". They may be faster than you think. Defers needn't add as much overhead as they do today; this can be fixed.

I think it really depends on your definition of "performance-critical". I agree Go isn't suitable for all performance-critical tasks, but it covers a vast swathe of them quite comfortably.
I'm also in the medical device industry, though we don't farm our V&V work out. The bugs are supposed to be caught in the verification phase; validation is all about making sure that the software is functioning correctly from a user perspective? Are you just conflating the terms here for the sake of simplicity?
Pebble Firmware 2.9 was released
> Don't use the merge button, just add the requester's repo as a remote to yours

Actually, you don't need to do that. GitHub provides a special pulls remote "namespace" on the upstream repo, so you can add it as a fetch pattern to your .git/config like so:

[remote "upstream"]
url = https://github.com/neovim/neovim.git
fetch = +refs/heads/*:refs/remotes/upstream/*
fetch = +refs/pull/*/head:refs/pull/upstream/*

Then when you `git fetch --all`, you will have ALL pull requests available in your local repo in the local pull/ namespace. To check out PR #42:

git checkout -b foo refs/pull/upstream/42
I'm the author, and to be honest I agree. I was still fairly new to OCaml (and ML in general) at the time, so I tried to focus on what I knew rather than rattle off a list of things I had heard were better but didn't really understand.