rzimmerman

Quick summary is Luigi dies (hit by a hammer) while a beanstalk is about to grow in 5-2. Mario then spawns back in 1-2 and the beanstalk is there.

VB6 won't die because it fills a large gap for people who just want to get something functional done without all the fuss of presentation layers, class hierarchies, and view abstractions that we're all somehow stuck with. If you want a button that does something, you literally click the button tool, draw it, then double click the button and write the code. No connecting outlets to action methods, no binding anything.

> If it takes more than 10 minutes it can't be done

is a little harsh, but sometimes you just want to get something done in 10 minutes.

It's interesting how closely these things are intertwined (Twitter -> Klout -> Bing -> back to Twitter). Buying fake followers seems like a silly ego boost but apparently it does increase exposure.

GPS is one of the coolest things mankind has ever put together. I'm always amazed that his stuff was even considered in the 70s/80s.

By far the biggest misconception about GPS is that the GPS satellites somehow know where you are, or that your device transmits something to the satellite. I don't think this article does a good job of making that clear. It's kind of pandering to the paranoid. Granted, if you have a phone with a GPS receiver, it's totally possible/probable that your location is being reported through some other means (like the cell network).

I use Sublime Text (and occasionally TextMate). It saves me time so I'm sure it's payed for itself already.

I also use AWS for some personal hosting.

I think the real problem is that Wordpress appeals to a lot of casual users who are understandably not security experts and the default settings are not secure. Getting a Wordpress server started and working isn't too hard but actually setting one up correctly is almost a full-time job.

In vi it's save (write) then quit vi. But if you're in the wrong mode it just thinks you're typing in the file.

NASA doesn't do manned launches at the moment. There are several other providers for unmanned launches (including for Mars payloads). SpaceX has never done anything beyond Earth orbit, so they'd be an unlikely choice for this.

This is a bit overly critical. The implicit parentheses are optional, so if it's confusing or ambiguous you should just use parentheses.

    func 5, {
       event: -> 45,
       val: 10}

Is reasonable but

    func 5, {
       event: (e) -> 
         if e.something
           36
         else
           45,
       val: 10}

Really ought to be split up for readability no matter what programming language you use. And besides, the only issue is the extra comma causes it not to compile.

To be fair, the `->` vs `=>` (which `this` is `this`?) for class members is confusing. I'd almost prefer class members didn't give you the option and defaulted to `=>`.

The "variable capture" section is overblown, though. You're a lot less likely to run into this issue than the classic JavaScript "I forgot `var` and now my variable is global.

My biggest complaint is actually the implicit returns. Sometimes I forget a return statement but it works anyway because of this feature. Then I come back later and modify the function slightly only to spend a bunch of time figuring out why it's returning `undefined`.

This reminds me of the Isaac Asimov spoof article "The Endochronic Properties of Resublimated Thiotimoline" which describes "experiments" on a substance that reacts so aggressively with water that it reacts before the water is added. Can't find the text unfortunately, but Wikipedia has a summary: http://en.wikipedia.org/wiki/Thiotimoline

His energy predictions are surprisingly good:

And experimental fusion-power plant or two will already exist in 2014. (Even today, a small but genuine fusion explosion is demonstrated at frequent intervals in the G.E. exhibit at the 1964 fair.) Large solar-power stations will also be in operation in a number of desert and semi-desert areas -- Arizona, the Negev, Kazakhstan. In the more crowded, but cloudy and smoggy areas, solar power will be less practical. An exhibit at the 2014 fair will show models of power stations in space, collecting sunlight by means of huge parabolic focusing devices and radiating the energy thus collected down to earth.

Especially considering how people always get a little overexcited about how close we are to nuclear fusion.

I believe that the software technically falls under certain US export restrictions which is probably one reason it isn't made public.

It's also cool that the update was sent partly through the MRO spacecraft, then forwarded down to the surface.

The first attempt at this upgrade did have some issues:

http://www.jpl.nasa.gov/news/news.php?release=2013-325

The software reset and booted back into the older version. There are some really good safeguards against bricking anything, but it's still scary. Especially with the data latencies involved - in this case the team had several hours between knowing "something's wrong" and getting more data.

There are probably valid use cases, but no programmer can be trusted with that kind of power.

Also, compile-time checks and the tendency of lower-level languages to fail catastrophically rather than subtly or silently plays a part. The author also has a lot of experience to draw on, which might just make his work more solid and error free in the first place.

Still not as bad as Voyager, where the ping time is an entire weekend.

This is very nice looking, but I have to nitpick about the "30 second" install. It takes 30 seconds, assuming you've already installed an operating system, a webserver, PHP, and set everything up securely. For a beginner that is really non-trivial. Still better than Wordpress, though.

It turned from "I'm not a laywer, but.." to something that was unexpectedly deep and thought provoking.

There's no evidence presented here that there's any significant (or even negative) performance impact from the way the CoffeeScript compiles these list comprehensions. Also, if your performance is constrained by a list comprehension, there's nothing in CoffeeScript preventing you from using "Array.filter" instead. By and large CoffeeScript compiles one-to-one with JavaScript and when it doesn't, the resulting code is at least reasonably performant.

I do agree that the default return behavior is probably a bad idea. It probably came from Ruby, and I can see the appeal, but I've often created bugs by accidentally using the implicit return, then adding something to the end of a function. It's not really that big of a deal - I just as a policy always use an explicit return.

If it's actually faster, the speed actually matters, and you wrap it with a well commented explanation and descriptive name, I'd consider it reasonable. Otherwise, just write out what you're doing. It's definitely clever, but fewer lines of code is not an optimization.

This would be the equivalent in Kal: http://goo.gl/TwsL2h

It's a different approach, but it doesn't require ES6 or any libraries (once compiled). Forgive the slight funkiness with the indentation.

  try
    wait for tweets from getTweetsFor "swannodette"
    url = parseUrls(tweets)[0]
    wait for responseBody from httpGet url
    print "Most recent link text: " + responseBody
  catch error
    console.error "Error with the twitterverse: " + error

I think for writing, sentence-based diffs would be the most useful.

This is such a great feature. I'm really looking forward to using RethinkDB as it matures.

It looks like for now you need to manually edit a config file to get this working with additional EBS volumes, but the wording implies better support is coming.

Wordpress is easy to install if you're already familiar with setting up a LAMP stack. A lot of people who just want to blog are not. It's easy to get running and install themes, but honestly it's almost a full-time job to keep it running right. You have to keep up with security updates and deal with confusing config options for custom domains. wp_config, Apache, and MySQL are not something you can use casually.

Also, performance is terrible unless you cache aggressively, which most people don't because it's a lot of work, even with W3. The nice thing about real hosted solutions is they can handle extra load if it happens.

I get why it's popular. The blogging interface is very good, but trying to setup/maintain a server makes me want to pull my hair out.

Yeah, that's kind of a shame. I'm not planning on changing it though. I figure most russian devs will have a sense of humor about it. I guess with a word that short, most languages are bound to have a meaning for it.

I chose it because in Hebrew it means simple/easy/BASIC.

"wait for" turns out to be somewhat analogous to the upcoming "yield" statement in ECMAScript 6 as well as .NET patterns for async code. "for parallel" must exist somewhere (it almost looks like functional programming). I actually added it as an afterthought when I decided "wait for" ought to work inside of loops. It uses the same mechanism as async.js's "map".

Thanks! I'm a big admirer of your work, so it means a lot to me to hear that. I wrote up a little bit about this if you are still interested: http://blog.rzimmerman.me/how-kal-compiles-itself/

if you do something like:

  wait for data from fs.readfile 'test.txt'
  print data.toString

and readFile calls back with an error (the first argument is non-null), the error will be thrown just before the print statement. So print will not execute and you'll get a stack trace. The cool thing is that you can do these async calls within try blocks:

  try
    wait for data from fs.readfile 'test.txt'
    print data.toString()
    if data.length > 0
      wait for data2 from fs.readfile 'test2.txt'
      print data2.toString()
    else
      print 'too short'
  catch e
    print 'there was an error'
  wait for resp from db.save()

Will do what you expect - abort after either wait for if it fails and run the catch clause. Think about how you'd do that in JS:

  var error = null;
  var data, data2, resp;
  fs.readFile('test.txt', function (err, data) {
    if (err) return handleErr(err);
    console.log(data.toString())
    if (data.length > 0) {
      return fs.readFile('test2.txt', function (err, data2) {
        if (err) return handleErr(err);
        console.log(data2.toString());
        return closeout();
      });
    } else {
      console.log('too short');
      return closeout();
    }
  });
  function handleErr(err) {
    console.log('there was an error');
    return closeout();
  }
  function closeout() {
    return db.save(function (err, r) {
      if (err) throw err;
      resp = r;
    });
  }