jfager

I can't count the number of times I've had to re-kick a build because a timing-dependent test like that failed (busy build server, inopportunely timed gc, etc). One of my top programming annoyances.

The equivalent errors in dynamically typed languages don't lead to critical security vulnerabilities like they do in C. You get a nice exception and a clean crash, not a hook to grab root.

FB doesn't want real names and addresses so they can start sending out snailmail spam, they want them so that they can start user matching with advertising partners' CRM databases.

Using lambdas in Java 8 looks pretty much exactly like your example.

The line you quote from the article is about a proposed way of declaring lambda types, where instead of

    private Foo MyMethod(string str, Func<Bar, string, int> func) {
      //...
    }

you could write something like

    private Foo MyMethod(string str, (string,int)->Bar func) {
      //...
    }

Are you fucking serious? Goebbels used propaganda to further the cause of genocide. Don Stewart thinks Haskell is pretty cool and shares that with the world. The fact that you think the two are even slightly comparable...

"Goebbels of Haskell"? What the hell is wrong with you? Assholes like you are why this site is going down the toilet.

For me it's as simple as knowing a product I like is not going to be developed anymore, and having a complete lack of faith in Google to use them to turn out anything near as good.

The most common derivation of Black-Scholes absolutely does assume a standard normal distribution. There are other models that don't (i.e., Mandelbrot tried to get people to use Levy distributions, and a lot of newer models are built around martingale theory), and traders have adopted rules-of-thumb that pull prices out of line with what BS says they should be, but it's certainly not the case that anyone who speaks of BS assuming Gaussians is lying or speaking from ignorance.

If you ignore the absurdly stupid title, this is actually worth a quick read. It's excerpts from interviews with Myron Scholes and Ian Stewart woven into an oversimplified but not completely awful overview of Black-Scholes and its impact.

If the question interests you, I recommend An Engine, Not a Camera by Donald MacKenzie. It goes into great detail about the history of Black-Scholes, its application in options trading, and how it (or, rather, financial modeling in general) tied into the 1987 crash and the failure of LTCM. I have a small writeup about it at http://jasonfager.com/1080-an-engine-not-a-camera/

This is a great series so far, but I think some people are taking it too seriously. This is roughly the equivalent of giving you a good tutorial about how a short map-reduce implementation works and then asking you to agree that Hadoop is awesome. It may or may not be, but the toy example isn't sufficient to make the determination. It's just background information for the uninitiated.

Some relevant questions that are completely glossed over:

1. What compels an HFT to actually trade? Is there anything forcing them to keep supplying liquidity even if the market's moving against them? How is an HFT different than an actual market maker?

2. How does an HFT decide that it has a better-than-even shot at turning a profit on a trade? Most of the objections to HFTs revolve around the answers to this question (i.e. pseudo-front-running by trying to detect large buys/sells that get split over lots of orders) and their implications (i.e. 'real' investors leaving the exchanges).

3. The "market-maker strategy" HFTs you describe are indisputably compensated for providing liquidity and taking on risk, but is the return on HFTs actually equivalent to the return on other investments with equivalent risk? If not, and they earn a premium, why isn't that evidence that something's broken?

The whole point of this thread is that "better" isn't sufficient, either. If people are happy where they are, the only way "the same thing but better" wins is if it's so much better that it covers the perceived switching cost. There aren't a lot of markets where the current leader is so bad that that's something you can actually pursue as a strategy.

Okay, so make a better product. Just don't market it as 'the same thing but better', market it as 'different and better'. That's the point.

The entrenched winner in the late 90s right before Apple's resurgence was Wintel - cheap and everywhere. What does Apple do to compete? The name of the campaign was literally what the parent comment says a company needs to do - "Think Different" - backed by a line of products that were completely different than Windows: colorful vs beige, whole-stack vs licensed out to third-party manufacturers, premium vs commodity.

Now that Apple's winning, of course they want to try to convince you that different is bad, because different is the threat to their business. They don't want someone coming along and doing to them what they did to Microsoft and Dell.

Alternate title: Why I will stab my eye out with a fork instead of running a cheese grater over my knuckles.

I think you're missing the point of the question. I'm not asking how you scale in general, I'm asking whether your replication scheme is only for failover or if it contributes to your scaling story - i.e., if a given key goes hot, does everything have to run through the point leader, or can each replica take writes/serve requests? It sounds like the former, which is fine, just wanted to clarify.

I'm reading through the paper, and I'm curious if I understand the implications of key subspacing and value dependent chaining correctly - do all reads and writes for a given key get forced to a single node? I understand how the replication that's described allows for failover when the point-leader fails, but does it also allow for scaling writes and key lookups?

You don't need a map, just a reduce (foldl, really). Using underscore, no double calculation:

    _.reduce(arr, function(p1, p2) {
        var len = p2.firstName.length + p2.lastName.length;
        return (len > p1[1]) ? [p2, len] : p1;  
    }, 
    [null, -1]);

For anyone else who hits this, this should get you going:

http://loopkid.net/articles/2011/09/20/ssl-certificate-error...

Basically, you need to get the right certs and then tell wget to use them.

Because the julia source file names end in .j, probably.

Not really, but it's not important either way.

Matlab, Octave, Mathematica, and other mathematical programming environments use 1-based indexing, it's a well-established norm for the domain.

Just spent the last hour reading through the docs and playing around with it. This is some damn sexy stuff. It's been a long time since I've been this excited by a language.

Even for financial reporting, this is an egregiously awful bit of journalism.

Once upon a time it was both an honor and a privilege to go public. A company worked tirelessly for years just to get to that point and it leapt at the opportunity to do so rather than playing it cool or blowing off bankers when they first came calling.

I'm sure we all remember the dot-com era internet companies who worked tirelessly for years to get a shot at the honor and privilege of an IPO. At least, I'm assuming that he's including these companies in his false-nostalgia, given that the two factors he blames for the loss of those halcyon days were the exchanges themselves going public (NASDAQ in 2002, NYSE in 2006) and the rise of HFT (which has really only grown to be a large part of the market since 2005).

And isn't it terrible that a company wouldn't blindly jump at going public the instant bankers came calling?

A comparison between Facebook today, pre-IPO, and almost any other company that is actually public on an exchange yields very little in the way of major differences

Where "major differences" would have been

1. Billions in capital, which of course private companies never had before the early 2000s.

2. Thousands of investors, where of course there's no major difference between a few thousand privileged wealthy investors and tens or hundreds of thousands of regular investors and qualification for inclusion in institutional portfolios, mutual funds, and indices.

3. A bump in analyst coverage, because the large armies of analysts that roved Wall Street in the good ol' days would for some reason only cover public companies. Oh, and also because there are already a ton of analysts covering Facebook, even though automated trading and exchanges going public killed all the analysts, or something.

The biggest problem with this rant is that it's attacking a strawman version of Khan Academy, pretending that it's only a website with some videos and exercises. It's not. KA is actively developing and testing an in-school curriculum that focuses class and teacher time on intensive small group and individual development of the concepts covered in the videos. The main insight is that one-size-fits-all lectures delivered at one pace represents a payment of a large opportunity cost that hurts both ends of the bell curve. If you offload that responsibility to videos that kids can watch outside of class and/or at their own pace, class time becomes an opportunity for kids to work together to understand the concepts and gives teachers the opportunity to figure out how to best reach each individual child. Khan Academy doesn't replace teachers; it frees them up to actually teach.

You can still assign these values to semantically-named variables where appropriate, with the bonus of not having to monkey-patch ints just to define a few dozen constants.

It's benign, boring utility code, I just don't get what's offensive about it.

Just by the mere fact that these are constants documented to be in seconds, it's clear that they shouldn't be used for sensitive or precise time calculations. If you're at the point where you don't realize this, you probably aren't going to be able to use a full-featured time library correctly, either.

"Difficult for novices to use incorrectly" is a good feature for code to have, but it's not the highest good, and its absence does not mean that the code is bad.

I see absolutely nothing wrong with this. It replaces a slow way to write human-readable intervals with a fast way. How is that a bad thing?

That's only true for people who don't follow the solar industry. They got their loan in March 2009 (http://cleantechnica.com/2009/03/21/fremonts-solyndra-wins-f...), filed for IPO in December (http://gigaom.com/cleantech/solar-tube-maker-solyndra-files-...) and cancelled it in June 2010 (http://www.greentechmedia.com/articles/read/solyndra-ipo-can...), and all three events were relatively well-covered.

Solyndra failed because its secret-sauce technology couldn't get cheap enough fast enough compared to the plummeting cost of photovoltaics. So it fits pretty well.

This looks great. One thing that's a little annoying is how the vertical axis automatically scales to the range of the data. It makes it hard to compare peaks that don't occur within the same view range.