skysight-inc/HackerNews huggingface dataset:
> I'm not sure you understand what you're looking at.

Yes, I do. The issue is that their ideas of lambdas work exactly in those cases where using a lambda is just a nice replacement for existing AICs. With that reasoning they thought that they could get away without standard function types.

But then, they added their "bulk operations" to collections and started to realize they were in trouble, because there didn't exist any SAM types they could use _and_ coming up with names for anonymous function literals was kind of idiotic. But with function types already ruled out and time running short, they decided to make up ad-hoc function types.

A bit later, they also realized that all the boxing had a non-negligible impact on performance, so they started to add _some_ ad-hoc specializations to the already ad-hoc function types, but of course not _all_ of them. Not even mentioning that the naming is just completely out of whack.

At the same time, they started to ask people what use-cases they could think of for real Generics in Java 9. One could argue that it's a case of the left hand not knowing what the right hand does at Oracle ... but it was in fact the _same_ person who OK'ed the broken function type design in the first place who was now asking for feedback.

So in the best case, a considerable amount of types in java.util.function (did I already mention that the name is just FUBAR?) will be obsolete in the version right after Java 8 and in the worst case, those types will serve as ammunition against fixing Generics for good.

This is a good case of making every imaginable error in language design one can think of.

> most Java users specifically said, in this case and in others, that they prefer postponing a feature until its been done "right" after die consideration

Yeah. I think no one will ever argue against that. You are not making up straw men again, aren't you?

What people criticize is that what Oracle claims is not consistent with their actions. If you want to sell people the idea of delaying a feature to "get it right", for gods sake, please actually make sure you "got it right" when shipping it versions later.
He gave good reasons why they used millicents, one of the best reasons was that it prevents things like a customer owing $0.006 and therefore getting a "past due" bill for $0.00. Another was that it prevents real errors from hiding as possible round-off errors. I found the reasoning convincing myself, and yes, I have worked in the financial industry.
>> morbidly afraid of having members of the opposite sex approach them for their substantial wealth

That sounds a lot like counter-signalling. Do these people avoid buying Ferrari's or are they all wearing second-hand clothes?
Ugh, he mentions in the post that it was a write-up of the talk.
Find an actuary. This is what they do for a living.
Verizon’s LTE mMap is nearly complete, but all 4 major carriers...
I actually think that Clojure's relatively unique feature which differentiates it from most languages (other than, perhaps, Erlang and Haskell) is its emphasis on managing state, especially in the face of concurrency.
Ashland digs out from 31.5 inches of snow (VIDEO)
> The real use of money is to buy freedom

The real problem is: This additional freedom you can buy with money means less freedom for somebody else.

Inequality (wealth-based) means nothing else than domination. If you are richer, then you dominate the poorer people. And richer countries dominate poorer countries.

This is the most basic and fundamental injustice [0] we seem to accept in our Western culture. Because we are those who dominate.

[0] If you remember that we keep telling ourselves the nice little story how every life has the exact same value.
The Economist take on the (possible) tech bubble
Am I the only one getting an invalid SSl certificate from https://keepass.info/ ?
Essential Learning for Ruby and Rails
Arbitrary precision arithmetic is known to most people as "math".
Thank you, Edward Snowden. You're true hero.

It's a shame, that your leaders can see in technology only surveillance, war machinery and ways to humiliate and subjugate others.

It's a shame, that USA's participation in computing is still a "donkey work", as tortured (and probably killed) Alan Turing once said.
Would you say that you have tried coming up with ideas yourself really hard, have given it your all for months or years?

Because that's what Jack did and what all other oh-so-famous entrepreneurs did to become successful.

One doesn't have that idea and then it just works out "overnight". It's a long long process over several years of unpaid hard work.

So don't wonder why can't you just have that billion dollar idea. You've probably had 5 billion dollar ideas already, but then someone else actually did it. So you need to do them.
And where exactly did the money go?

$600k is a lot of money to implement an existing standard. That's 4-5 annual engineer salaries. I'm wondering exactly how much work was actually undertook for $600k and whether those doing it (/charging for it/taking the money) felt it was unusual size remuneration.
"Doing all that replacement work would boost GDP growth and employment, would it not?"

That's known as the broken window fallacy: http://en.wikipedia.org/wiki/Parable_of_the_broken_window
This poster could use a timestamp. As other commenter mentioned, this map is from 2009 [0], but even not minding that, if I were ever to print it and put in on a wall, the date would be relevant to anyone who looked at it.

[0] - https://news.ycombinator.com/item?id=6957391
> But what has really changed?

Nothing. And that seems to be his point. He's done (more than) his part. Now, if we don't like 1984, then it's now up to us to start acting.
"My father rode a camel. I drive a car. My son flies a jet airplane. His son will ride a camel."
Anonymous Saudi Sheik – 1982
Clearly you still haven't read the link I provided, which provides numbers after adjusting for purchasing power.

I'd provide you with more statistics showing how wealthy poor Americans are (http://www.census.gov/prod/2008pubs/h150-07.pdf), but clearly you aren't going to read any numbers.

So instead, go watch about 4 minutes of Delhi Belly (good movie, BTW, vastly better than typical Bollywood crap) which always confuses first world types:

http://www.youtube.com/watch?v=IrJS6R-FT-o

(Sorry, couldn't find the whole scene in one video)

http://www.youtube.com/watch?v=L3dkCVXcAVg

That's life for middle class professionals. (Admittedly, a group of non-misfits would have filled the buckets.)
Security researcher cancels talk at RSA conference in protest
I agree that using regular floats for money is insanity. Aside from that I'm not convinced at all, because the situation never arises where you want to charge people 0.01 cents or 17c for that matter. Who in their right mind is going to generate an invoice for 17 cents?

If people have a small amount of credit just give them an extra day of service. If they have a small negative credit either ignore it or subtract one day the next time they renew.

If there is a case for using milicents I sure haven't seen it.
Android 4.3 (10.4.B.0.569 ) for Xperia Z/ZL/ZR/Tablet Z Released
"The operator subsequently managed to take back control of the infected computers and then used them to attack Defence Intelligence, a Canadian security firm helping the FBI.

However, in doing so Netkairo appeared to have revealed his identity by accidentally connecting to the botnet directly from his home computer rather than the VPN."

You only have to slip up once.
> But then, they added their "bulk operations" to collections and started to realize they were in trouble, because there didn't exist any SAM types they could use _and_ coming up with names for anonymous function literals was kind of idiotic. But with function types already ruled out and time running short, they decided to make up ad-hoc function types.

This is simply not true. Doug Lea, the author of java.util.concurrent, and of ForkJoin in particular, was one of the main driving forces behind lambdas; he requested them about 7 years ago precisely for those bulk operations. The same Doug Lea rejected function types way back then in favor of CICE.

Already back in 2007-2008 it became clear that function types are a bad fit for Java. Java's designers explicitly mentioned currying, general functional-style programming, and user-defined control structures as things they wanted to avoid. These things may very well have a place in other programming languages, but not in Java. If you don't want a blue-collar programming language then Java is simply not meant for you. Java, like Clojure or Haskell, has a very specific flavor. A feature can be right for one language but not for another.

> A bit later, they also realized that all the boxing had a non-negligible impact on performance, so they started to add _some_ ad-hoc specializations to the already ad-hoc function types, but of course not _all_ of them. Not even mentioning that the naming is just completely out of whack.

Again, not true. Java's designers are extremely focused on performance, and did not "realize" all of a sudden boxing has a non-negligible impact on performance. Also, those are not "ad hoc" specializations. All they did was pre-define some small subset of possible function types that they figured will be widely used. Again, the idea is always do the least "powerful" thing possible that will give you the most benefit.
So, it's a feature that has been available in every high-order language since forever, except with more line noise. Typical Perl!

http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec...
I define freedom as choice.

You can choose what you want to do rather than being bound to someone else's agenda.
Freedom has been my main goal for money. As my business has grown I'm happier, but I can see the monetary goalposts shifting as I go.

I started two years ago. My initial goal was to build recurring income. I wanted enough to cover expenses, as an initial goal.

Achieved that. But I saw I was vulnerable to sudden expenses, or a temporary decline in business. So I wanted an emergency fund.

Achieved that. But then I realized I had student loan debt that I would soon have to pay interest on, as I was earning more money and wouldn't qualify for debt relief in the near future.

Had a really good autumn and achieved that. Then I noticed that I might have to pay more taxes, because my previous tuition tax credits may run out in 2013.

Achieved that, which brings me to the present. I only achieved much of that savings through tutoring. I charge a high rate, but it's not scaleable. So now my current goal is increasingly recurring revenue so that I don't have to sell my time directly.

Why am I writing this? At each one of these stages, I had the feeling "If I just achieve this goal, I'll have enough". It was a silly belief in retrospect – it would have been obvious to an outsider that I still had challenges to overcome.

Yet presently, I have the feeling "if I double my recurring income, I'll have enough". But I'm certain that once I achieve this goal, I'll see another reason I ought to earn more. Probably the next goal will be "if I just achieve X, I can make work optional by age 33" or "if I just earn X, I won't have to worry about the cost of airfare for trips".

I can attest that life IS better now that I've met the goals I listed above. I remember having lots of worries about money that have mostly dissipated. I haven't increased my lifestyle, and have been trying to keep "freedom" as the main goal for earning more money.

But the whole process feels shockingly short-sighted. It's as though I'm incapable of imagining how I will feel if I am earning $X or have saved $X.
Right, if you wanted to have an ordering around, you would use an enum. The enum's values would print as Ace, 2, 3, 4, ..., Jack, Queen, King, and then when you wanted to implement a particular game the game could define the mapping from rank -> set of possible values. You wouldn't want to map each rank to a single value, since in commonly played games aces are worth both 1 and 11 or both 1 and 14.

If you didn't want the ordering (or the compiler warning when your blackjack implementation omits queens), you could use Scala's symbols, which are more or less the same as Clojure's keywords:

scala> 'king
res0: Symbol = 'king
I thing the problem here is you're comparing apples to oranges - the people writing code in the 70's are not the same type of people teaching students to code now.

In the 70's it would have been physicists, mathematicians or engineers writing code to solve a problem for them and their colleagues. Their code needed to be maintainable so they could share it in their academic community, and get things done with it.

Today, the people teaching computer science view code as the proof of concept. Much of the work is in the idea behind the code, and the code is just proof that it can be implemented in practice - and most importantly, isn't designed to be actually used.

The idea that the code is just the proof of concept then carries over to the students, and the mindset becomes not, "let's build this thing to do X', but "can we build a thing, in way Y to do X".
> Unfortunately it’s really hard to get traction for anything else, because the whole world already has JPEG decoders built into everything.

Patents don't help either.
Code ≠ Computer Science, surely? ;)
It's mostly because human beings feel more sympathy for a single victim who they know a lot about. I think the term is "Identifiable Victim Effect".
Java 9. Project Jigsaw. Here's a blog from 2008 that discusses it.

https://blogs.oracle.com/mr/entry/jigsaw
Depends on the course.

I studied a bachelors in molecular biology, took a few years out (realised I didn't like the subject much) and studied a one years masters in IT a few years later. It was taught by the Computer Science department (Glasgow University in Scotland), but the focus was on writing good quality software - readable, maintainable, usable code.

There was an optional data structures and algorithms course which I assume is more geared towards traditional comp science. I took it, but in ten years of work, I rarely use this stuff (though its good to have a background so you know which library is a better choice).

One thing they didn't teach us was networkinq, which I am completely self taught. I can get stuff working, but I think having a formal education in things (like I do in OOP) can teach you where to focus to get things done in a professional manner.
Maybe artists should be paid like teachers and teachers should be paid like rock stars.
In a two player game, the monsters keep fighting until one dies. In a more than two player game, the monster can attack any of his opponents, so he might alternate between opponents or team up with another to take out a monster.

We played last night, and a couple alliances were formed. There were two adults playing (me, Wai-ka) and two kids (Axel and Troy). So Troy would attack me, then Wai-Kai, killing my card. I would attack Troy, then Axel would attack Troy, killing Troy's card. The alliances made during the game are not stable though, and there is a tendency to shift sides if one player is too strong.

It reminds me of the reality show Survivor, where people are teams until the end; then it becomes every man for himself.

We initially played with a piece of paper to track scores, but found that since it was subtraction only that we could keep the scores in our head and play faster. If you forget your score, your opponent will happily remind you.
I have not yet had the chance to try it out but the acrylamid static blog generator written in Python ships with its own JS search [0] using compressed suffix trees. It's probably inspired by Sphinx, the Python doc generator, which has a similar feature [1].

For static blogs, I think this could be used as a first level of search, instead of directly going to Google first.

[0] http://posativ.org/acrylamid/static-search.html

[1] http://stackoverflow.com/questions/605888/whats-the-search-e...
Variable length underlining to help see data in a glance
How Minto's Pyramid Principle Can Grow Your Business
Not that I know of - but there was an odd iframe on top of the page that stopped scrolling from working. When I got rid of it, it started working again. odd...
In my case making money correlated only with my willingness to be a capitalist drone for a few years. The attributes you mention surely correlate with success at most things. Admittedly money is quite popular, so assuming that its pursuit is a primary goal for everybody is probably not a terrible approximation of reality.
It's the same thing as in middle ages, when jesuits were burning books.

First, it's child pornography. Then it's porn. That means, we now have info on anyone and their masturbation preferences. Then we have enough info to extort 90% of male population, with realtime location capabilities and unlimited history.

Forever.

Than what? We all know how imaginative those folks can be. I'm sleeping feeling perfectly safe, knowing that highly competent, intelligent and sensible persons are guarding our little planet.
He didn't say anything to that. He was talking about explaining the principles.
I think the parent is saying basically:
Greenspun's eleventh rule

Any sufficiently complex Lisp implementation contains
an ad hoc, informally-specified, bug-ridden, slow
implementation of half of Haskell's type system.
Anecdotally, I find the best image compression using ImageOptim for PNGs and JPEGmini for JPGs. However, ImageOptim can also compress JPGs.
So the Scala solution for this is: http://ideone.com/Vussjh

object Cards {
sealed trait Suit
case object Spades extends Suit
case object Clubs extends Suit
case object Hearts extends Suit
case object Diamonds extends Suit

sealed trait Rank
trait FaceCard extends Rank

case object Jack extends FaceCard
case object Queen extends FaceCard
case object King extends FaceCard
case object Ace extends FaceCard

case class ValueCard(n: Int) extends Rank

case class Card(rank: Rank, suit: Suit)

type Deck = IndexedSeq[Card]

def numberToRank(n: Int): Rank = n match {
case 1 => Ace
case x if x <= 10 => ValueCard(x)
case 11 => Jack
case 12 => Queen
case 13 => King
case 14 => Ace
case _ => throw new IllegalArgumentException
}

def numberToSuit(n: Int): Suit = n match {
case 0 => Spades
case 1 => Clubs
case 2 => Hearts
case 3 => Diamonds
}

def apply(): Deck = for(rank <- 1 to 13; suit <- 0 to 3) yield Card(numberToRank(rank), numberToSuit(suit))
}

Now I have: normal operations bound to Deck (head, take, drop etc) and the ability to pattern match on cards. Also strongly typed. This took about 5 minutes top to write.

edit: I'd say the 'numberToRank' parts are probably code smells, but given that its Christmas Eve, I really can't be bothered to think of a better solution right now. Implementing ordering etc can be done on the traits very easily too, but that is game specific (for example are aces high or low, is a King ranked higher than a Jack etc).
I think you've missed the point. The point is there is some amount of money that affords you the ability to do what you want.

Possessions have the effect of tying you down. Buying a house, assuming you get a mortgage, is a huge expense requiring you to work to pay for it. It ties you to one geographical area and puts stress from having to make the payments. You could spend the downpayment on a house as a down payment of yourself. Find somewhere or something you'd rather do.
You are conflating possessions with a predictable stream of income, and you shouldn't really be doing this.
Ad impressions are priced at e.g. 0.40 USD per thousand impressions - that is, 40 millicent. Personally, I prefer to think of that as 400 microdollars, but to each their own.
Ah, interesting. Of course, you can do the same thing in one for loop in C like so:

for(i=0,j=0;i<10;j=(j+1)%5, j==0?i++:){
}

Not that you ever would of course, but it does demonstrate the power of for loops in C.
The scala collections library is the most powerful/flexible I've ever seen in a strongly typed language; it combines the safety of Haskell with the flexibility of Clojure. Given the amount of ongoing complaints I see around cabal I don't think it's fair to say it "actually works" (fwiw I'm very happily using maven to build my Scala projects, so I never really know what the sbt fuss is about). And the rate of features and other progress in recent scala releases clearly demonstrates there are plenty of people who understand the implementation well enough to modify it.
Compiling GCC on OS X
NASA's Squishable 'Super Ball Bot' Could Explore Titan
Your definition of engineering may have been appropriate around the time of the industrial revolution when an engineer was literally one who built steam engines, but modern engineering in the academic sense under discussion here is absolutely a science.
> This situation has barely improved in the 25+ years I've been in IT.

Improved? 25+ years ago this would have been written in COBOL using decimal arithmetic as a matter of course — because 55 years ago the designers of COBOL knew better than to put floating point in a business language.

(This is not a defense of COBOL, which is terrible in so many ways, because they didn't know much about programming in 1955 — but they knew they had to understand the problem domain.)
If you mean the D language was designed by a compiler expert, then it is as irrelevant as a house designed by a plumber. I don't know, I heard talks by James Gosling and he is much of an expert as anybody.
Steve Jobs: Enterprise vs. Consumer markets
Laurie Simon Hodrick on Apple's Cash Holdings
Kickstarter project for AngularJS with Bootstrap integration
> Imagine a program which begins by asking, "Which game do you want to play?" and includes a card guessing game, blackjack, Uno!, go fish, and crazy eights. We want the values of the cards to lie in their use within each game, not where we shuffle and deal and discard from hands.

I maintain that you gain nothing (except the possibility of errors) by representing the cards as int-or-string here. Think about how you'd actually use the cards in implementing those games. With my enum-like scala representation you could do anything you could do with the clojure version, and you'd get the advantage of e.g. compiler warnings if you defined incomplete match/case statements.
Scala macros are different. We deeply respect the Lisp tradition, in which we are rooted, but we also accommodate and empower our language's values - static types and rich syntax [1]. The end result is admittedly less flexible, but it also opens a number of interesting possibilities beyond those available in Lisp [2]. Our design is also not set in stone, and we're experimenting with different macro flavors [3], but it's too early to say something definitive about those.

[1] http://scalamacros.org/paperstalks/2013-09-19-PhilosophyOfSc...

[2] http://scalamacros.org/paperstalks/2013-12-02-WhatAreMacrosG...

[3] http://docs.scala-lang.org/overviews/macros/annotations.html
Looks like a slow news day.

A dynamically typed language is obviously easier to begin coding in, especially with a trivial example. The problems that statically typed language solve are usually found in larger code bases and in performance critical applications.
Indeed, I came to love Iron Maiden via means of a typical [broke] teenager. Once I had a revenue stream, I collected almost their entire discography on vinyl and had the pleasure of seeing them live in concert twice, one Dream Theater opened (dream concert). It was very exciting to see more and more pedestrians in Iron Maiden T-Shirts as we drew nearer to concert.

I invite less familiar readers to watch their Flight 666 documentary on how they've toured all across the world, including countries where the Catholic Church has previously stepped in and banned them (over a song titled Number of the Beast, which is in fact, about doing battle _against_ the devil). Anyways, their music is a treat, and while Bruce can't belt out the same high notes he used to be able to, the sheer musicianship of the band is incredible; virtuosos the whole lot.

Up the irons, earth dogs!