skysight-inc/HackerNews huggingface dataset:
Your building strawmen does not help your credibility much, nor your attempt to convince me of your view. "Revisions that never existed" do exist, and if you put a rebase of a branch on master without verifying the rebase, then you may end up in a mess, but it's your fault. Code review is a thing that is done for a reason.

Frankly, i find your style of argument through implication, and through trying to disregard something because it doesn't fit your definition of truth to be much more condescending than anything i wrote before.
>1. modularity (and now that they have added generative functors à la SML, you can have true abstraction)

Could you share some information regarding Haskell and it's 'modularity' problem (vs. the ML family of languages). I'm fond of the way SML projects can be structured. How are people solving this using Haskell? Are there any interesting solutions for creating modular Haskell application/system's I can see today?

Thanks for your comment.
Just out of curiosity, have you ever used a tool such as Gerrit or Atlassian Stash? There are different mindsets, and both have their advantages.
That is great, and i thank you for bringing that to my, and everyone else's attention! :)
Nope. The FDIC made sure they didn't do the crap they did with depositor money. It's the reason the FDIC insurance wasnt massively triggered during the crisis. The accounts that got screwed were investment accounts which were not insured by the FDIC.
> 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.*

There is definitely work that can be done to improve dead code elimination in the Go tool chain. The transition to Go will make this easier to achieve.

> What I suspect I see here is a kind of C++ vtable problem built deep into the language design somewhere.

Don't suspect. Dig into the problem and make some informed commentary. Idly speculating on HN is just spreading FUD, and benefits no-one.

You should read about Go's implementation of interfaces. It's not the same as C++'s vtable issue. http://research.swtch.com/interfaces
I'm sorry, but the Go Gopher's eyes[1] will always remind me of boobs.

[1]: https://talks.golang.org/2015/state-of-go.slide#21
GUI usability is one thing, GUI programming usability is another.
> That said, clang has lots of options to tame C's undefined behaviour. Guess what, you can enable these too for C code generated by Nim.

They aren't really designed for performance though. For example, `-fsanitize-undefined-trap-on-error -fsanitize=null` emits explicit comparisons against null for every pointer load instead of catching SEGV like (for example) Java or Go do.

From what you're saying it sounds like maximum performance plus memory safety isn't a design goal for Nim. That's totally reasonable. It does mean that Nim and Rust have very different aims, however, and comparisons between the two need to take this into account.
Start by learning about logic analyzers: https://en.wikipedia.org/wiki/Logic_analyzer

You can get cheap (but slow) analyzers as open hardware, such as the Bus Pirate ( https://en.wikipedia.org/wiki/Bus_Pirate ). Also check out the Saleae USB analyzers ( https://www.saleae.com/ ).
Fractional reserve systems mean that private banks can and actively do create money by lending.
There is closed ticket (github.com/joewalnes/websocket) where we were battling this out, you're always welcome to join with good ideas, that would be appreciated.
Yeah - I think it'd take some serious chops to construct this from scratch (note: it wasn't me! author: twitter.com/teachwithcode). But I've been having a blast deconstructing the equations.

Here's a fun intermediate step (circles instead of hearts), with a few of the numbers parametrized as sliders:

https://www.desmos.com/calculator/irg4qa2s4h

[disclaimer: I work at desmos]
>Keep in mind that writing something like this is not actually going to be perceived as helpful to most people who may have difficulty with Haskell

No, but hopefully it well help people who have yet to learn Haskell that not everyone thinks it's particularly difficult. I'm not interested in convincing the people who've tried and given up on it.

>That's great, but to people for whom they don't come so easily, this could easily be considered discouraging, or else bragging.

So what do you propose? That I pretend it's really hard for me, even though it's not? What effect do you think that's going to have?

>So unless you're SPJ or beyond, I wouldn't be quick to claim that Haskell isn't "unusually hard to learn."

You don't have to be SPJ to learn Haskell (or talk about how hard it is). Do I have to be Stroustrup to pass judgement on how hard it is to learn C++?

>In particular people who are older and have "work/life balance," ... and the life part of that work/life balance doesn't allow much time to do so.

I obviously don't mean that Haskell is easy for every single person in the world to learn; I mean that, as far as languages go, it's relatively easy enough to learn. If I didn't have enough time to learn Haskell, I also wouldn't have enough time to learn C++ or Python.

> but just maybe don't be so glib to claim it is not hard.

Again, what do you propose? Lie and tell people that it's super hard, so I don't hurt their feelings if they can't figure it out?
There is a weak form of modularity which can be achieved by using two parts of haskell:

1. hiding constructors in files
2. type classes

But it doesn't really begin to approach the kind of structuring that is possible in an ML-like system. Unfortunately, the issue is very (needlessly) controversial, and I don't think I want to get dragged into it here.

I'll mention, though, that Haskell does have one form of modularity which ML doesn't really, which is the fact that you can write algorithms separately, compose them together after the fact, and expect to get reasonable performance in most cases. This is because of two things: haskell is non-strict, and GHC has pretty good fusion. In ML, you often end up manually fusing things together in order to get good performance, so composition can be a bit more difficult.
This probably reveals more about you than anything else.
That's not a reasoned point then.
That's really nice of you to say. Thank you.
Alcazar – A Sudoku without numbers
I was hoping for more reasons, since the very first and simple one is usually the one that has the most and simplest workarounds. You could for example make a patch with git on your local machine and attach that to an issue.
Did you even read the article? They got with other manufacturers and agreed to put an age limit on the bulbs. Anyone that violates the pact was fined by the others? That is exactly what a conspiracy is and is one of the reasons we have anti trust laws now.
Chinese have their own Internet censorship song
If network-bound apps are rare, then you believe that mobile apps and web apps are rare. Both are, combined, likely to make most other app types seem rare.
Now, I can see wifi signals
Memory Barriers
Personal opinion here, but I much prefer merge commits as opposed to fast forwarded commits. With a merge commit, there's one commit to revoke if something breaks, and there's one commit per PR to step through with git bisect, and more importantly it maintains history, which to my eyes is more useful than a "pretty" repository.

Drafting comments... if you want to draft comments, can't you do that in a separate editor? Better than relying on the browser as an editor.

I agree, though, the public repository requirement for making a PR is a bit awkward.
Absolutely, I should have specified 'a single vm' in my response. I didn't understand that when I was first trying to understand boot2docker, and now I'm using imprecise language to help confuse others. Thanks for clarifying.
I must admit i have not, and to make clear: I am not taking offense to their implication that Github is worse at some things than other tools (it is). My post above is merely objecting to the opinions that were borne out of some lack of knowledge (which is acceptable), yet are posited as facts (which is not).
I wonder if "0 seconds" means it's disabled, which would make sense for a consumer build.
After the first few reconsideration requests, I questioned whether they were truly read by a human. The time between request and response was often the same, but not always. Whether I wrote a descriptive formal reasoning for reconsideration, or simply "You're idiots.", I still received the same exact template message:

> Reconsideration request for http://whocalled.us/: Site violates Google's quality guidelines
> February 14, 2015

> Google received a reconsideration request from a site owner for http://whocalled.us/.

> We've reviewed your site and we believe that http://whocalled.us/ still violates our quality guidelines. These guidelines outline illicit practices which may lead Google to take action on a site in order to keep webspam out of search results. In order to preserve the quality of our search engine, pages from http://whocalled.us/ may not appear or may not rank as highly in Google's search results, or may otherwise be considered to be less trustworthy than sites which follow the quality guidelines.

> Please correct or remove all content that is outside our quality guidelines. Keep in mind that simply deleting all of your site’s content and immediately requesting reconsideration will not lead to success. Instead we recommend that you spend considerable time and effort to make sure your site provides original, valuable content for users. In order to have a successful reconsideration request, you will need to show that your updated site contains content that does not violate our guidelines.

> For more specific information about the status of your site, visit the Manual Actions page in Webmaster Tools. From there, you may request reconsideration of your site again when you believe your site no longer violates the quality guidelines.
Not supported in any of IE versions... https://status.modern.ie/serversenteventseventsource?term=Ev...

And WebSockets is working since IE10
https://status.modern.ie/websocket?term=WebSocket
You don't need to install MinGW or MSYS in order to use GCC (I assume you are interested only in C99 here and not in POSIX programming). Here is an example of a standalone GCC (contains C, C++ and Fortran compilers):

http://www.equation.com/servlet/equation.cmd?fa=fortran
It sounds like you were just an alcoholic or at least hanging out with alcoholics. I have never had any issues with having to walk on eggshells or have friends have outbursts. We only have one or two drinks so what you described is a non issue.
MFW I read this:
http://makeitthentelleverybody.com/wp-content/uploads/2014/0...
Right now, the translation is very direct. My basic rule of thumb is - only perform those optimizations which the user opts into. Some things are standard though, like a few inlining rules and tail call elimination, but the plan is to provide a rewrite rules engine so that the developer can be as fine-grained as they like when it comes to optimizations.
Who said anything about needing to drink?
Yes! I've been wanting to do this and didn't know it was this easy.
I actually coded a predecessor to the system under development a few years ago and have used Erlang and more recently Elixir a lot, but in the end it just wasn't low-level enough, fast enough, or runtime-free-enough for our current project (for example we need to generate real-time processing kernels that can run on GPUs and FPGAs-- a realm not even really contemplated at the Erlang level).
One nice thing about Git is it lets you choose your workflow.

Our general workflow for the Go project is to review single commits, and sometimes do major new work in feature branches. When we submit a single change we cherry-pick. When we merge trees, we create a merge commit.

We don't write commits that depend on other pending work. That's overly complicated (IMO) even if you always use merge commits.
I wish I had explored more artsy endeavours in high school and college, instead of being such a nerd focused on only science. Litterature, drama, creative writing, music.
Right. Being able to trouble shoot models with some level of certainty is better than nothing. Tuning neural nets is still more of an art than a science in some respects, I'm not aiming for anything magical here. My first step with neural nets is to make them usable.
Nope, you're describing a mistake grade school children have made for many years. It used to be corrected by high school, but failing education systems have led to confusion between discrete sets and continuous sets. Let's not try to defend ignorance.
Wait. Force pushes? That's a terrible habit to get into; force pushes have decimated more than a few a open source project's repository.

https://news.ycombinator.com/item?id=6713742
And then I have to follow a completely different work flow and inconvenience the maintainers.
It's not complicated at all if you use merge commits. That's exactly what you are doing with a feature branch. Failing to realize merge commits are useful is what makes them complicated.
I've been happy to see (and participate in) a recent discussion on software update transparency, which I think could change this situation someday -- assuming software users and publishers have enough interest in reducing the publishers' power.

Some publishers understand that a reason to try to do this is to be less vulnerable to coercion, and also to be seen to be less vulnerable to coercion -- like when distributing software to foreigners who think that your local government might try to force you to backdoor it. A recent example I heard along these lines was a Chinese vendor who was interested in pursuing a means to help customers confirm that the software updates they got hadn't been backdoored at the behest of the Chinese government. Technology distributors who are based in other countries might face similar concerns.
Microsoft researchers say the newest deep learning system beat humans and Google
Zane Lowe to join Apple
Does anyone actually do #27, "27. Over-provisioning is useful for wear leveling and performance" It's been my experience mucking with the innards of flash devices that they already have ~10% more NAND in them than their labeled capacity exactly for this purpose. Seems like over provisioning is bad advice unless you have a very special situation.
You're right - it will be significantly larger. But then again, it doesn't depend on your system having all of the necessary libraries of the correct version and the overhead of dynamic linking.

It's a tradeoff, and worth it in my opinion.
This text summarizer will be open sourced soon: http://genopharmix.com/TuataraSum
Oh my! I have been waiting for this, trying to write my own websocket server implementation in multiple esoteric languages! Fantastic!
Just as a minor point -

One of the major blockers to clojure in android is that the lack of treeshaking/deadcode elimination makes for 10 second+ startup times in most environments.
A mistake? All I see is pure malice. The guy threatened the developers with bad press, and then he followed through with it. I don't see how that is a 'simple mistake', it was plain extortion.
Talking about reputation, what about SPI's reputation?

Did you read the links in the linked article?
We may be reading the same thing and getting a different impression, and that's ok too.
There are possible structures of problems and solutions in which this search strategy would get stuck in a local optimum -- if you agree that some solutions preclude others or make other problems worse.
I knew about scala.js when writing the post (although it was still experimental at the time) but I didn't mention it because I don't like Scala. It looked promising when I first saw it, but then I had to write some production code in it.

My opinion now is that if you're forced to use the JVM then Scala is one of the best options. But that's a low bar, given the choice I would pick something else.
I think most people who wanted a cross-platform, VM-based, corporate-ecosystem-integrated ML derivative with good concurrency support have already found Scala :P.
I think I disagree with this. Your functors should generally be pure, and for pure functors applicative is a nicer semantics.

Consider the case of a set implemented as a binary tree. The type of such a set should be parametrised by the type of the elements and the ordering used. With applicative functors this is the case as your set type will be `Set(O).t` where `O` is a structure containing the type and the ordering. With generative functors each individual set type is abstract -- so the type itself is not parameterised by the ordering.

You could consider this to be just an example of what you are calling "Modular Type Classes", but there doesn't need to be a system of implicit module parameters for it to be useful.
The title of the article is "THE DARK SCIENCE OF INTERROGATION", not "Dark Side".
Untold rule is not to run "sudo websocketd --devconsole bash" :)
Software Applications Should Work Like Restaurants
Code running in the browser also has a UI thread that it needs to run on. Just that until recently the UI thread was the only thread you had access to.
Actually, it's the other way around: the single thread in a browser is an UI thread, and what's seriously broken is using it for anything else!

If you ever want to do non-UI work, you should use Web Workers, which were invented specifically because doing non-UI complex tasks in the UI thread got really common when HTML unexpectedly became an application platform.
350 years of publishing from the world's oldest science journal in pictures
As of 2014 it was closer to a 50-50 split:

http://www.huffingtonpost.com/2013/10/30/edward-snowden-poll...
The trip treatment
Android does AOT compiling with ART, it became the default in Lollipop.
> GitHub is painful for non-trivial reviews.

That may very well be the case. But note how you said for non-tivial reviews, whereas in the presentation about go they said in general (see the line I quoted in my original comment). And argue that the vast majority of pull requests on GitHub are simple ones which don't need much discussion, so in general the GitHub UI works just fine. I don't have any hard numbers to back up my claim.
JIT has potential to be faster than compiled native code. Better runtime information. Compiled code needs to cover all potential options and this means more instructions to execute.

Say a variable value is set through a command line option to be a certain value. Compiled native code has to assume the value to be dynamic, but a JIT can optimize it away, effectively hardcoding it for that particular invocation. Same applies to more complicated type of software. Some configuration and invocation parameters tend to be effectively static during that particular invocation. JITs can capitalize on this fact.

JITs have also better chance to adapt to exact hardware it's running on. Compiled code is forced to make one or a limited number of assumptions of available CPU hardware configuration.

In the end, both options are running compiled native code. JIT just does it a bit before running.

Of course current reality is the opposite, but the key word here is potential.
On Kickstarter, Everyone Is Peter Molyneux
The Obamization of Uber
I guess it's more difficult than shifting the focus towards industrial use cases. Industrial use cases are a great thing, but it is something that the industry has to provide :-) (we tried to do something like that for F# here: http://manning.com/petricek2 (sorry for a shameless plug!)).

But many people contributing to functional programming (in one way or another) are in academia. They are not the best people to contribute industrial case studies - but I think there is still a lot to be done there too! The nice thing about the FRP paper is that it is really just a fun (and very simple and somewhat impractical) example, but it is nice inspiration showing (what was back then) a novel use of functional programming. Some of the more recent academic work around FP lacks this kind of creativity...
As far as I can tell Elm is more of a GUI focused language, when I was evaluating AltJS languages I was looking for something a bit more low level. The JS and DOM bindings of js_of_ocaml were what really sold me although I didn't mention this in the post.
Each slide was okay when viewed horizontally, but then advancing then shows the damn address bar. I had to annoyingly advance, rotate, rotate back, and then read. After a while I just gave up on the titles...
I liked Ansible a lot; during our evaluation I had a single Ansible file provisioning a sample dev setup in around 50 lines. We need to support windows servers primarily, much to my objection, so the 'blessing' of the machine to automate Ansible on windows required a manual step at the time, which wasn't acceptable for our use case. We ended up picking chef, both for it's more agnostic approach to OS's, but also it's much more developer friendly, regardless of it's overly verbose generators, git repository litter, and quirks that still have me scratching my head.
Even widespread two factor auth would mitigate a lot of this. Banks are often quite backward because there are few software suppliers, and it is an industry that took to computing early so there is a lot of legacy. But they vary a lot - the implication of the story is that these were perhaps banks in smaller countries - the banks that got defrauded recently in another large case with cashpoint withdrawals from fake cards were middle eastern. You have a lot of choice of banks, choose the weakest...
> And argue that the vast majority of pull requests on GitHub are simple ones which don't need much discussion, so in general the GitHub UI works just fine.

Right. And what you say validates my exact point: "pull request culture is not about code review." If all you want to do is cast your eye over it and click "merge", it works great. That's not how we work, though.
>> 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.)

With github PRs, notifications are sent as soon as you write your first comment; in systems like gerrit and rietveld (and email) they are not sent until the reviewer chooses to send them. This leads to either awkward interactions if you start replying to comments while the reviewer is still reviewing, or unresponsiveness if everyone introduces hysteresis to avoid this situation.

This is IMHO the biggest problem with Github PRs; I don't necessarily agree with the Go team's decision to abandon the PR system but on smaller projects I have pushed for rietveld over PRs for this reason.
I have been receiving spam calls recently despite being on the national do not call register. Thanks to google, I wasn aware of this resource until today.

There is no defense against Google's actions here other than to acknowledge that they make mistakes and need to take more responsibility given the power they hold.

If they don't become more transparent about appealing these mistakes, eventually we as a society should develop a legal recourse. There simply isn't enough competition in search to enable these kinds of errors to be corrected through market mechanisms.
What? Pull requests should be on their own branches, if you want to keep one commit per PR but need to edit it you must rebase it and thus force push. It’s a terrible habit if you’re sharing your branch with others, it’s completely normal if not.
Not sure, double entry bookkeeping is apparently not baked in everywhere, if you can increase an account balance it might not be picked up. If this is creating money, well thats another question.