smanek

As a former professional Common Lisp dev, those two features strike me as the real difference between a macro and function call.

Yes, we all know that online Whitehouse petitions won't have as much effect as calling/writing your congressional representatives. But this is such a 'niche' issue that I could imagine something as small as a this having a real effect.

But call/write too, if you are so inclined!

Since they are going to go through most of the downside involved with an IPO anyways, they might as well get some cash too.

Plus, share/option holders (employees, investors, etc) are probably clamoring for liquidity. It's great if you own a hundred million dollars of FB stock on paper - but it's even better if you have the option to sell and diversify your holdings.

The full (buildable) source code - including the CsvParam and DateParam classes - are here: https://github.com/smanek/students

I tend to use 'mvn tomcat:run' to run my dev server, which I find even easier, fwiw.

But you're absolutely right on most of these points.

All the formatting tricks are here: http://news.ycombinator.com/formatdoc

And that is the reason I still write in Python or Lisp when I don't need something (Hadoop, Lucene, etc) from the JVM ;-)

If I returned a fake value - the client would get a 200 response on his attempt to delete a non-existent resource, which is clearly the incorrect behavior. I could return nothing - but then the client would see a 204. So, I choose to throw an exception with a response 'NOT_FOUND'

  throw new WebApplicationException(Response.Status.NOT_FOUND);

  @GET
  public Collection<Integer> listStudentIds() {
    return STUDENTS.keySet();
  }

  @DELETE
  @Path("{uid: [0-9]+}")
  public boolean deleteStudent(@PathParam("uid") int uid) {
    final Student deletedStudent = STUDENTS.remove(uid);

    if (deletedStudent == null) {
      throw new WebApplicationException(Response.Status.NOT_FOUND);
    } else {
      return true;
    }
  }

In the meantime, the fact that he is considered a terrorist by the Chinese Govt makes them look like idiots - rather than him look like a terrorist. In the exact same way the US calling Maher Arar makes us look like fools.

I could see him wanting to step down before any sort of formal investigation could occur ...

An FST allows you to accurately model 'outputs' on state transitions (where those outputs can be side-effects like 'make a call' or 'send an invoice.' This allows you to prove things about what sort of side-effects/outputs will necessarily have occurred by the time the FST is in a certain state.

I started with an FSM but, found in practice, I was using it like a poorly written FST.

Plus, it's managed horrifically. What sort of real company would have a union contract that categorically prohibits layoffs and mandates rich pensions for basically unskilled workers?

Making the pie bigger is good.

Of course $90M and a few hundred jobs won't shift equilibrium much on its own, but it's a step in the right direction.

Amazon probably has ~5hrs/year of complete failure of a region. Figure, conservatively, it would take 3 months of engineering time to protect against that, plus a 'continuing' cost of 1/2 a week per month to maintain that protection. You'd also have to (at least) double your provisioned capacity (which may include a larger ops team, etc). Assuming your servers cost $20k/month and devs cost $100/hr (both fully loaded), we're talking about ~$340,000 to prevent 5 hours of downtime (just for the first year).

If downtime costs you more than $50K/hr, then it might make sense to be that fault tolerant. Otherwise, there might be better places for a startup to spend its (limited) resources.

A closure is a function, combined with the set of variables declared outside its definition (a 'lexical scope').

A monad has absolutely nothing to do with functions/lambdas/closures. The 5-second explanation is that it's a "design pattern" that's useful for managing control flow (often chaining operations together). But Google around a bit if you're interested.

A function-pointer/function-object in C++ are functions that don't have access to external lexically scoped variables. They can only access their arguments, or dynamically scoped (roughly 'global') variables. They are 1/2 of a closure (the missing half is the definition's lexical environment).

source: http://travel.usatoday.com/destinations/dispatches/post/2011...

Either USAToday misinterpreted/misreported a quote, Airbnb lied to a reporter on the record, or Troy is making up his story. I can't see any other way to reconcile the evidence put forth.

To make matters worse, that 2% in interchange fees is an average across all credit card transactions. But most interchange agreements are "fixed fee + percent of transaction" and I suspect Square's average transaction is significantly smaller than the average credit card transaction. That would imply their cut is even smaller than the 0.75% that it would be otherwise.

On the plus side, at scale Square should be able to directly negotiate better interchange fees with issuing banks - but I'd be very surprised if they ever drop below 1% on average. It would be impressive (but possible, given Square's pull in the industry via Visa et al.), that they've already pulled off some agreement to that effect.

The short reason why is that bits have color ( http://ansuz.sooke.bc.ca/entry/23).

See http://en.wikipedia.org/wiki/Illegal_prime for a concrete example.

A big problem is that arbitrary DB writes after split brain (aka network partition) situations are much harder to 'unify' than bitcoin transactions. Check out the Dynamo paper (or Riak docs like: http://blog.basho.com/2010/01/29/why-vector-clocks-are-easy/) for details.

In some cases (e.g., shopping carts) conflict resolution is as easy as it is in bitcoin - but in most common applications it's far more difficult, if not impossible.

it's surprisingly tricky to get lazy init right.

The YC connection is a great way to get started (incidentally, the YC company I'm currently at (Greplin) has been using them for a few months, and I have no complaints).

The first IT says there within any system of logic that's powerful enough to express arithmetic (and consistent), there are always statements that are true that can't be proved true. A specific program, P, that doesn't halt, but can't be proved not to halt, is an example of this. (Or, more precisely, the statement 'The program P halts' is the example.)

The second IT says you can't prove the consistency of a system from within that system itself, but that's another story.

The subtext seems to be about as clear a reason as you can hope for from a giant corporation's PR dept.

The is no correlation between words people end up reaching your site by, and words that they are trying to find your site by.

Consider the world where 10M people are trying to find Ninite, but forget the name and unsuccessfully google "keep multiple programs up to date". Similarly, 1M people google for some variation of Ninite, and all find your site. Your referrer logs would show that all users reaching your site remembered your name, even though you're throwing away 90% of your potential user base.

That's like trying to disprove the hypothesis: "You don't network enough, so not enough people know you" with the evidence "99% of the calls I get are from people that know me, so clearly a lot of people know me".