はてなブックマーク

Great web applications boot up fast and stay silky smooth once they've started. In other contexts, applications can choose quick loading or responsiveness once they've loaded. Great games can get away with a long loading bar as long as they react instantly once the gamer gets going. In contrast, scripting languages like Ruby, Python or Bash optimize for instant boot, but run their programs more sl

(This post is about Yarn, a new JS package manager that was announced today.) I work with Node and npm packages almost every day, on Tilde's main app, Skylight, or on one of Ember's many packages. Many have remarked upon how fast the npm registry has grown, and it's hard to imagine working on any of my packages without the npm ecosystem. I've also worked on a couple of application-level package ma

Alex Russell posted some thoughts today about how he wishes the W3C would architect the next version of the Content Security Policy. I agree with Alex that designing CSP as a "library" that uses other browser primitives would increase its long-term utility and make it compose better with other platform features. Alex is advocating the use of extensible web principles in the design of this API, and

A few weeks ago, I started a kickstarter project to fund work on a project to make a long-term, sustainable binary build of Ruby. The outpouring of support was great, and I have far exceeded my original funding goal. First, I'd like to thank everyone in the community who contributed large and small donations. This kickstarter couldn't have been as successful as it has been without the hundreds (65

While reading Hacker News posts about JavaScript, I often come across the misconception that Ruby's blocks are essentially equivalent to JavaScript's "first class functions". Because the ability to pass functions around, especially when you can create them anonymously, is extremely powerful, the fact that both JavaScript and Ruby have a mechanism to do so makes it natural to assume equivalence. In

A little over a year ago, I got my first serious glimpse at SproutCore, the JavaScript framework Apple used to build MobileMe (now iCloud). At the time, I had worked extensively with jQuery and Rails on client-side projects, and I had never found the arguments for the "solutions for big apps" very compelling. At the time, most of the arguments (at least within the jQuery community) focused on brin

The primary reason I enjoy working with Rubinius is that it exposes, to Ruby, much of the internal machinery that controls the runtime semantics of the language. Further, it exposes that machinery primarily in order to enable user-facing semantics that are typically implemented in the host language (C for MRI, C and C++ for MacRuby, Java for JRuby) to be implemented in Ruby itself. There is, of co

Over the past few years, I have occasionally expressed frustration (in public and private) about the process for approving new features to the next edition of ECMAScript. In short, the process is extremely academic in nature, and is peppered with inside baseball terms that make it nearly impossible for lay developers to provide feedback about proposed new features. In general, this frustration was

For the purposes of this post, I will be talking about JavaScript objects using syntax defined in ECMAScript 5.1. The basic semantics existed in Edition 3, but they were not well exposed. A Whole New Object In JavaScript, objects are pairs of keys and values (in Ruby, this structure is called a Hash; in Python, it's called a dictionary). For example, if I wanted to describe my name, I could have a

Over the years, I've seen a lot of confusion about JavaScript function invocation. In particular, a lot of people have complained that the semantics of this in function invocations is confusing. In my opinion, a lot of this confusion is cleared up by understanding the core function invocation primitive, and then looking at all other ways of invoking a function as sugar on top of that primitive. In

Yesterday, there was a blog post entitled "What the Hell is Happening to Rails" that stayed at the number one spot on Hacker News for quite a while. The post and many (but not most) the comments on the post reflect deep-seated concern about the recent direction of Rails. Others have addressed the core question about change in the framework, but I'd like to address questions about specific changes

One of the goals of SproutCore 2.0 is to make it trivial to integrate the tools you're already using together with SproutCore. One way that we do that is to make it possible to drop a SproutCore app into a small part of your existing page. Greg Moeck did a great job demonstrating this functionality on the SproutCore Blog a couple of weeks ago, and I'd definitely recommend checking it out if you're

Recently, an upgrade to Rake (from version 0.8.7 to version 0.9.0) has re-raised the issue of dependencies and versioning in the Ruby community. I wanted to take the opportunity to reiterate some of the things I talked about back when working on Bundler 1.0. First, I'll lay out some basic rules for the road, and then go into some detail about the rationale. Basic Versioning Rules for Apps After bu

You probably know that Rubinius is a Ruby whose implementation is mostly written in Ruby. While that sounds nice in theory, you may not know what that means in practice. Over the past several years, I've contributed on and off to Rubinius, and feel that as Rubinius has matured since the 1.0 release, a lot of its promise has gelled. One of the great things about Rubinius is that it exposes, as firs

TL;DR Although apps and gems look like they share the concept of "dependency", there are some important differences between them. Gems depend on a name and version range, and intentionally don't care about where exactly the dependencies come from. Apps have more controlled deployments, and need a guarantee that the exact same code is used on all machines (dev, ci and production). When developing a

First Shugo announced them at RubyKaigi. Then Matz showed some improved syntax at RubyConf. But what are refinements all about, and what would they be used for? The first thing you need to understand is that the purpose of refinements in Ruby 2.0 is to make monkey-patching safer. Specifically, the goal is to make it possible to extend core classes, but to limit the effect of those extensions to a

One thing we hear a lot by people who start to use bundler is that the workflow is more complicated than it used to be when they first start. Here's one (anonymized) example: "Trying out Bundler to package my gems. Still of the opinion its over-complicating a relatively simple concept, I just want to install gems." Bundler has a lot of advanced features, and it's definitely possible to model fairl

I officially joined Engine Yard on January 1, 2008, about a week before we announced our Series A funding, becoming its twenty-second employee. I was Engine Yard's very first "Engineering" hire, and I would spend the next year working on Ezra's Merb project, finally releasing Merb 1.0 at MerbCamp that October. When I joined Engine Yard, I had already been working on the jQuery project for a couple

For a number of years, I've been about as active in client-side development (through jQuery) as I have been active in server-side development (through Merb and then Rails). Recently, I've released a couple of libraries (jQuery Offline and Rack::Offline), designed to make it easier to build applications that can withstand both flaky connections and a complete lack of connectivity. Of course, those

preamble: this post explains, in some detail, how we will implement a nice performance boost for Rails developers. Understanding the details might help gain the full benefits of the optimization, but you will gain some benefits even if you have no idea how it works. As you've probably seen, DHH announced that we'd be looking at flushing in Rails 3.1 to improve the client-side performance of typica

For a while now, the Ruby community has become enamored in the latest new hotness, evented programming and Node.js. It's gone so far that I've heard a number of prominent Rubyists saying that JavaScript and Node.js are the only sane way to handle a number of concurrent users. I should start by saying that I personally love writing evented JavaScript in the browser, and have been giving talks (for

A couple weeks ago, I took the plunge and switched to vim (MacVIM, to be precise). It wasn't the first time I tried to make the switch, and I had pretty much written it off entirely. Why? Because the past few times I tried switching to vim, I took the advice of a master vim user, and quickly sunk into the quicksand of trying to learn a new tool. In every prior attempt, I gave vim a few days before

Taking into consideration the huge amount of feedback we received during the Bundler 0.9 series, we streamlined Bundler 1.0 significantly, and made it fit user expectations better. Whether you have used bundler before or not, the easiest way to get up to speed is to read the following notes and go to http://gembundler.com/v1.0 for more in-depth information. (note that gembundler.com is still being

I wrote somewhat extensively about the problem of encodings in Ruby 1.9 in general last week. For those who didn't read that post, let me start with a quick refresher. What's an Encoding? An encoding specifies how to take a list of characters (such as "hello") and persist them onto disk as a sequence of bytes. You're probably familiar with the ASCII encoding, which specifies how to store English c