skysight-inc/HackerNews huggingface dataset:
It says a lot about the scale of adoption the big language players have that despite the aforementioned inroads into the enterprise that Scala has made, it is still very much a niche language; Haskell at this point in time, even more so.

Am curious to see how Scala 3/Dotty backed Scala works out. Enabling better tooling and faster build times via a generally less kitchen sink-y/more regular language should bring Scala adoption to new levels. Dotty is under active development, even saw a Github issue talking about the migration tool[1]. It's going to happen, just a matter of when.

[1] https://github.com/lampepfl/dotty/issues/129
In my experience its always really telling that there are no incredibly simple is-a relationships to use in inheritance justifications (as opposed to tons of goto real world examples for just about every other feature under the sun). Its always either incredibly abstract (B is-a A), or incredibly contrived (Triangle is-a Shape). I've spent a lot of time in inheritance heavy code, and I've yet to find something that wouldn't be just as, if not more, elegant without inheritance. I've spent the most time in Cocoa (which I believe to be very well designed BTW), but the inheritance there is clearly not needed IMO. I usually find one of the following to be true:

1) Very shallow inheritance trees that could have very easily (and more logically) been replaced with interfaces. For example, NSResponder being everything's superclass even though just about all of its methods are empty implementations ("subclassers responsibility"), aka, it clearly should have been an interface.

2) Confused/strangely complex is-a relationships (mutable array is-a immutable array, what? so if I specifically specify NSArray, I may still get a mutable array and the type system will be happy???).

3) Strange rules around what methods are overridable, and more importantly, how specifically they can be overridden. Why can't I in a UIView subclass override -subviews to ensure that it always has the same subviews? Well, implementation detail, that's why. Normally this would be fine, but since anyone is allowed to muck around in a subclass, suddenly I need to know the way it was implemented. This of course conflicts other parts of the framework where you are definitely expected to override the method and not use a setter.

I have yet to be presented with one of these "killer" is-a relationships that must exist. If the sole excuse is "performance", then sure I'll conceded. I guess I don't work in environments where member access is the performance bottleneck so I guess I can't relate.
It's simply not a brogrammer joke. That's all there is to say about it.
Quote from the blog post:

> First, while many organizations have cheerfully ignored our “Do not run in production!” warnings, others have been waiting for a level of product maturity before deploying production workloads. This release’s “1.0” label signifies a level of quality, feature completeness, backward compatibility and API stability to meet enterprise IT standards. In addition, to provide a full solution for using Docker in production we’re also delivering complete documentation, training programs, professional services, and enterprise support.
The one question I wish this article answered is: what specific, quantifiable benefits could I get from using a real functional language RATHER THAN merely reactive extension libraries to an imperative language.

The point many programmers are at is far removed from diving into Haskell and hard math in functional languages. Many of us are still learning why to compose observables for multithreading. From a application programmer perspective, what could we gain by diving into FRP completely?

If Scala is the gateway drug, then the dealers need to do a better job explaining what the hard stuff actually does for us.
Has anyone stopped to ask if this is confirmed/true? TechCrunch/Gizmodo/etc... all picked up on this from Frederic's tweet but is a tweet really a definitive news source? Apple has been historically taciturn about documenting these things but does anyone have any more docs or sources for this issue?
I do but I have multiple small projects so I can just re-use the container and change some config files.

Its basically a build script that is less than 100 lines, generally, so it is really easy to use.
One can achieve commutativity and idempotency in a side effect based language as well...but one has to redo the programming model to achieve it:

http://research.microsoft.com/pubs/211297/managedtime.pdf
Looks good and feels much more responsive.

One feature I'd like to see would be interacting with issues instead of having to go to the website. Also, when writing a commit message, it'd be nice to have autocomlete on issue numbers too.
ahh. That's almost certainly what splike meant. Thanks.
Kentucky Restaurant Utilizes Interesting Alternative to Tipping
Github 2.0 for Windows
>I can understand some of the things FP gets you

I really don't think you do understand, as an example in the last thread we ran into each other you completely missed the fact that Futures allow concurrency for free since you're already in a monadic context 90% of the time.

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

> The problem is that the kind of code it enables reuse of more than OO is very small, simple loops. This is never a big issue.

This is called a straw man argument. People aren't claiming that FP helps you write four line loops in one line. This article and others talk about orders of magnitude improvement in LOC on a large scale.

>"transactional" mutable state is simpler than the pure FP one, and just as safe.

You clearly don't know what these words mean. Mutable and purity are not mutually exclusive. Purity is a slang term for referential transparency. You can have mutable, referentially transparent functions. You can also have transactional memory in pure languages.

>Finally (and I've said this before on HN), a language like Haskell discounts the very useful choice of reasoning about your code after it runs, favoring, instead, all-upfront reasoning, often at the expense of facilitating the former.

Citation needed. You’re making things up.

The bottom line is you’ve created a product that solves many of the same problems functional programming solves. Your product looks very nice and advanced, but your unfamiliarity with functional programming makes you fear it, so you’ve decided to spread FUD across HN to the detriment of the community.
True, but tries do not automatically solve those problems, either, and most tries use lots of memory, especially on 64-bit systems (pointers, pointers everywhere!).
It is true that the use of male pronouns in gender-neutral context has historically been considered correct and is still considered correct by many. It is, however, generally discouraged because it only serves to reinforce the very real and problematic implication of male as the "default" sex.
State can be local, but you need an escape analysis to verify that it doesn't leak the context if your language supports aliases, which I believe Haskell doesn't (or to say, aliases don't make sense in Haskell).
I'm Intrigued - in for the beta.
To me, it feels like you're implementing too much of the OO behavior yourself. That is essentially the same as saying that the language isn't really object oriented.
I can still select text with mouse in ff 24.5 esr - but still very clever trick!
Yes. 100 times yes.

One of the greatest things about Docker is it lets you consolidate your setup environments. You can great a handful of 2k scripts, store them in Dropbox, and then if you current development machine bites it, a simple "docker add <script>" gets you up and running exactly as before.

Docker lets you stop treating your personal machine as a server. And that's a beautiful thing.
Probably not, since the name of the application is "GitHub for Windows".
I wrote and contributed important code in an area (Computer Systems Integration) after seeing it lacking for years (https://github.com/mqsiuser/Generic-ESQL-Utilities). I just saw that I could do it and I figured out how and thought intensly about everything (putting in a lot of effort) and... how to benefit from it. Now the software business is not so easy: The right thing: Open Source (Almost) Everything. The problem: How to create income.

Next http://www.use-the-tree.com

Same problem. It isn't easy to monetize in IT. There are paved ways though and I'll certainly be back on a freelance consulting project soon :)

I lost my last one because I was too occupied by my side project (nevermind, the project wasn't really worth it)
I don't have any experience with Docker either, but from the little I've read it's built on top of Linux Containers (http://en.wikipedia.org/wiki/Linux_Containers).

Windows has App-V (http://en.wikipedia.org/wiki/Microsoft_Application_Virtualiz...) which seems like a similar technology (I believe Office 365 uses this). Note that Office plug-ins are specifically called out as something that is problematic with this tech.
The default download from http://git-scm.com/downloads for Windows works if you select the right options in the installer.
I developed the first GitHub client on Android way back in 2009/2010 and called it Hubroid. At one point it was much more complete than the current official app, but the version currently in the Play Store is a rewrite that is less feature-filled than the official client.

I've been planning to pick back work up on it again, especially if there was interest in it.
It definitely suffers from the monolithic design that plagues nvd3 and other d3 chart libraries.
InstaNerd
The Internet, explained in under 2 minutes
What is being argued is that understanding the relationship (which is linear) is more important and more useful than understanding the improbability.
I love Redis, nginx, and Lua and wrote my own autocomplete implementation using Metaphone (e.g. https://github.com/threedaymonk/text) but after a while it became clear that what I really wanted was an instance of Solr.
I've been wanting to get that book for a while now, but keep forgetting to order a copy. Thanks for the reminder.

That said, I'm still interesting in playing around with ACT-R a bit.
The misspelling seems to come from a (automatically created somehow?) Google+ profile.
what is the united states?
Theory of Relativity – 100 Years After Albert Einsteins big Breakthrough
Showcase of work and skills in a creative way, reviews from happy customers and presenting themselves in a more personal way. In addition, who his/her customers are is important. Recognised organisations will give value to his/her portfolio.
Indeed.

A vulture's digestion is strong enough to kill anthrax and cholera -- an ecosystem service not provided by scavengers like dogs and rats.
I just posted this elsewhere, but thought it applies here too:

I've often wondered if the Turing Test has been decoupled from signifying its original goal due to an instance of Goodhart's Law; namely, "When a measure becomes a target, it ceases to be a good measure."

Surely the ability to trick a human into believing an AI is a human is a milestone, but it was with an AI specifically optimized for this task. The deeper question is if the passing of the Turing Test in this case means we should ascribe consciousness to the bot, and I think none of us are willing to affirm it yet. I would suggest that this discrepancy is caused by the “measure becoming a target” and losing its ability to be a “good measure.” I guess this is why there is such a critical distinction between Artificial Intelligence and Artificial General Intelligence, which is where the Turing Test would have more weight.
Just curious, did you take Modafinil continuously for 9 months straight as well?
Google has plenty of experience with containers already, since they heavily use cgroups and the concept of containers in their production environment for isolation and resource control, never mind the fact that two of their engineers had written much of the initial cgroups code. I talked about this in my "Introduction to Containers on Linux using LXC" screencast [1]. Briefly, Google is in the process of open sourcing their internal container code [2], there was a Wired article that talked about their container orchestration system [3], and finally, there was John Wilkes (Google Cluster Management), who talks about the container management system [4].

Docker adds very interesting filesystem ideas and software for the management of container images. Personally, I think we are on the cusp of a transition from VPS (xen/hvm) to VPS (containers). I also hope that Google throws some of their concepts at the Docker project. Interesting times for this space.

[1] http://sysadmincasts.com/episodes/24-introduction-to-contain...

[2] https://github.com/google/lmctfy

[3] http://www.wired.com/2013/03/google-borg-twitter-mesos/all/

[4] http://www.youtube.com/watch?v=0ZFMlO98Jkc
Reminds me of 'websockets over GIF' https://github.com/videlalvaro/gifsockets
I had the same reaction.

If they're going for a Big Brother reference, why not a name like BB or George[Orwell] or something from Newspeak?
Congrats! I would love to see user namespace support.
Nope... that reads as version 2 of Github available on windows, which this is clearly not. Github for Windows is the name of the product so its version 2.0 should be called Github for Windows 2.0
let's not forget Craig Leres.
That's such a genius statement...
I'm currently implementing my own trie (for learning) for my own autocomplete module ... and I don't see how a trie (prefix tree) can solve the issues you just wrote.
FYI there are some really cool ways that you can recycle and re-use dockerfiles with ONBUILD commands. We actually do that for some of our containers as well, such as when you have multiple python projects. https://github.com/deis/dockerfiles/blob/master/python-runti...

Just add "FROM deis/python-runtime" to the top of your project and declare a CMD or an ENTRYPOINT in your Dockerfile and suddenly you have a python project installed and ready to go.
Beginning OpenGL Development: Abstracting Shaders
The truth Ft. Ali
This little rap is from the soul, speaks some truth about life , friendship , and Frenemies.
nginx+lua can be exceptionally fast. It's the basis for OpenResty, which is a consistent top-performer in the Web Framework Benchmarks (http://www.techempower.com/benchmarks/)

Webdis is a neat project, but I'd be a bit wary of deploying a custom HTTP server written just for Redis interactions. Nginx is battle-hardened.
That is because fanbois are just customers of products you don't like. Who also cannot be bothered to shut up about said products.
Statistical shortcomings in standard math libraries (and how to fix them)
Yeah things fail now and then. But it's nothing you won't expect from a nascent technology.
The site is unique but I find it ironic everyone is complaining about the UX when they are advertising a big UX and design package.

For real feedback, what in terms of work does this get me? Does it get me well thought out wireframes, PSDs, or fully implemented solution? I feel like the latter is half the battle itself.
Ask HN: What makes a great freelance portfolio?
We're building a new kind of portfolio site specifically for freelance developers. A place where top freelancers can share, showcase, and find high quality freelance gigs. Here's a demo of what we've built. https://theworkmob.com/demo/
Huh. Thank you. I suppose I'll do that then.
Make your own - http://www.lulu.com/
Yes. Tableau, QlikView, and SpotFire all provide this functionality.
This looks suprisingly like Acme (http://plan9.bell-labs.com/sources/plan9/sys/doc/acme/acme.p...)
Mad Rush at Lending Club Loan Release Time: Part I
Because there is nothing wrong with the word "bro".
Couldn't you just connect to the master host? I'm not sure how namespacing is done inside the kernel, but I would assume that the host would have access to containers info.
Find Great Participants for Your User Study
Swift subscripts will change the way you visualize data
The simplest explanation is that the project was started and named far before the term "brogrammer" was coined.
No, you shouldn't give up mutability or in-place algorithms. As you said, performance concerns demand them at times.

Haskell has a nice approach to that problem. Data is immutable by default, but mutable primitives are available. The type system forces you to be explicit about when you're using mutability, so that mutable data can never accidentally creep into logic where you relied on immutability for correctness.

Broadly speaking, most mutable data types fall into two categories: Those that are some flavor of "IO," and those that are some flavor of "ST." In brief, the IO type is Haskell's way of dealing with operations that logically must be performed in the right order. (In-place operations require as much.) You can think of IO as one continuous chain of operations that begins and ends with the lifetime of the program. In other words, you can't just drop in and out of IO at will; the chain must be unbroken.

ST is an interesting variant on the same idea, except it does allow you to drop in and out at will. That is, I can enter ST at any point in my program, including the functionally pure parts. How is this possible? Because it imposes a restriction that's not present with IO: You must not touch the outside world from within ST. In any ST function, you get your own little mutable sandbox, but as with any pure function, you can only see that which is passed to you, and all you can do to the outside world is return a value. So you can, e.g., take an immutable list, create a copy that you sort in-place, then return the sorted list as an immutable value.

IO and ST are each flexible in their own ways. With IO, you can do almost anything, including mutating something that's passed in by reference. That can be important for some programs' performance. ST is flexible in a different way: You can sneak it into pure functions.
How Chinese Students Use Hi-Tech Methods To Cheat In Examinations
What is xiki? Why does it bring the power of the command line to everyone?

The kickstarter page seems to assume I know what xiki is and why it's different from say bash.
I think the more fundamental issue is that, to avoid creating ambiguity, software product names should not include, as their terminal component, the name of another software product.

Not that there is much significant risk of more than momentary confusion with Github for Windows 2.0 (but if it was Github for Windows 8.1, for instance, that would be a problem.)
> That said in some airports, changing MAC address is illegal.

Would you mind providing some links? I'm interested to see how it's laid out
It's a safe bet that any rule regarding English grammar that includes the word "always" is either a) mistaken, or b) so obvious that you probably wouldn't be questioning it in the first place.

Commas began life as indicators of pause, but in modern English they are indicators of clause -- that is, they indicate grammatical structure. The places where we don't normally use pauses to indicate structure in spoken English (but still use commas in written English) are where you're noticing the discrepancy. Specifically, it's a common practice that you should use a comma to separate an adverb (like "too") from the rest of the sentence when it's being used to modify the sentence as a whole. This isn't a struct rule, and some people prefer a style of omitting such commas.
I've been using posh-git[0] with powershell for some time now and it works pretty well after the initial setup (requires a git for windows download[1]).

[0]:https://github.com/dahlbyk/posh-git

[1]:http://git-scm.com/downloads
I've been considering moving an app off of Heroku and to Digital Ocean so I could learn the ropes of administrating a Linux server but I feel there's so much I don't know that I should know if I wanted to effectively manage my own server.

If I got hacked with m64.pl, I'd get as far as running top and killing the process. His immediate assumption was that someone got a file that file on to his server and so he went on to check the logs and found all the failed login attempts. I would have wondered what the file was, googled around and sat around confused.

Luckily deploying a new instance on Digital Ocean sounds simple enough so I would probably just do that but that approach would leave me with a sense that I don't know what I'm doing at all. There was a time when my solutions to problems on Windows machines was to restart and/or format but I don't do that anymore but still meet people who do. I'd rather not start from square 1 when I make the leap to Linux.

What are the things one should know to legitimately say they can manage their own Linux server? I could try to just wing it and solve every problem as I encounter them but for right now I'd just like to identify the gaps in my knowledge.
If you want to get into docker for a small project I suggest something like Dokku as a first-step/primer. Its a 100 lines of bash that you should read and uses Heroku BuildPacks to do the heavy lifting. Great way to get introduced to Docker and software driven sys admining with rock solid deployment architectures.

https://github.com/progrium/dokku
5 things we have forgotten about open source
Learning to love rejection (2013)
I'm not sure there is truly such a thing as a "one-off" in the sense you're using it. What happens when your server dies (e.g. catastrophic disk failure, etc)—how do you get your service set up again? If your answer is basically "I re-make it from scratch", then Docker will save you a lot of time, no matter what scale you're operating at. Every Dockerfile is effectively a reproducible build; you'll never need to wonder what dark magicks brought the current state of the system about, because they're all explicitly documented right there, starting from a known-to-its-very-SHA base-image.

If you ever heard some of Heroku's propaganda surrounding "eternal applications", it also applies here: the stack you're deploying on will never update out from under you, because it's pinned by your Dockerfile. You can confidently move your app to any old server and it'll run exactly the same. One good analogy I've heard is that a Docker image is the reductio ad absurdum of a static binary: it doesn't depend on your system, just on itself.
I hate to say it, but despite their prior claim to the name, today's reality means that the name will be a persistent distraction from the underlying product.

It's not remotely fair, but that doesn't make it untrue. Just ask the diet pill company from the early 1980s that used to advertise "Ayds helps you control your appetite so you lose weight!" Or the many Hindus today who are frustrated that their Swastika earrings get mistaken for an endorsement of Nazism.

Bro culture in tech is a poison, and one of the many crappy things about poison is its tendency to contaminate otherwise harmless things that happen to be nearby.
A release that seems somewhat rushed, and a Red Hat media event tomorrow. I wonder if the two are related.
Inheritance is usually a mess because people use it to model objects when they should instead be modeling types: a triangle is not a shape, but a Shape is a sum type of Circle, Square, Triangle, etc.
Our front-end development boilerplate
I watched the whole video, and I still have no idea how it would improve my life compared to using bash...
I don't understand how this is any better than SNORT http://www.snort.org/
wow really interesting conundrum, because immediately my eyes read "Windows 2.0" but you are totally right if the version number went after Github it would imply a Github version update was happening.
Are You Still Manually Pulling and Aggregating Data?
ClearView aggregates and correlates data systematically and in real-time, allowing these individuals the ability to quickly identify agent weak points and breakdowns and focus on addressing the issues.
subtype polymorphism
Except I like many others probably clicked on the link expecting to see a fun little hack of someone that had a github app that ran on Windows 2.0 I was curious how they got around the lack of built in networking.