Design is how it works. Design is what it looks like. Design is it.

Design isn’t, however, a concrete component. Each thing isn’t the essence of 1/nth part design – there is no discreet measure for this essential element of a thing. Rather, design permeates the form, function, intent, and feeling of any made thing – the gestalt.

The nature of design is process: from an existing state – to a preferred one. This shift is design. Exemplary artifacts of this process are those whose form and function are equivalent.

(Source: leftyjenkins)

OAuth is good for you

I dislike making accounts. I dislike that Keychain sync will disappear when MobileMe goes. I also dislike 1Password’s UI and its kludgy integration. Finally, I dislike typing usernames and passwords.

OAuth allows users to forget about “logging in” an instead think about their identity in a more realistic way. When you sign-in to a website with Facebook, you’re providing your actual canonical identity to that site — not leaving a weak tie to katkid104@excite.com. Terrified? The fact is that the anonymity your feline flavored e-mail supposadly provided was just an illusion anyway. Unless you use an insane browser (like Iron) you’re leaving traceable traces. So unless you’ve consistently managed to use _why in place of your name and leave no personal information anywhere, you’re already exposed.

OAuth makes you more secure by drawing your attention to the act of sharing your personal data. Facebook does a great jub of illustrating the process with iconography and making it obvious what you’re doing. There have been numerous times I’ve opted out of sharing personal information with sites because they asked for too much, and reduced my trust in them. That’s not a bad thing — the OAuth process highlighted the suspicious nature of a site I might otherwise have trusted. Without oAuth, I’d have made a username and password, given them an e-mail, fullname, etc. Providing content, faked or not, is still less secure than providing no content. Plus, the best part, is that it elminates the need to create and manage that content in tandem with my real data, and to created and manage passwords.

For development, OAuth rocks. Maybe at first, sure, it was hard to implement and we hadn’t collectively aggreed on UI paradigms for it. But now Omniauth, Everyauth and whatever Python has, along with the libraries for Objective-C and Java, has made oAuth consumption easier than creating your own user/session management.

OAuth makes sense to me. And I like it. Apparently a lot of people don’t. If you use an app I build, you’re probably going to at least encounter it.

Twitter isn’t evil or anything, its gonna be ok.

Twitter is not a developer’s OS but that is alright.

Twitter has grown, in part due to its third party clients. But as they scale, they want to ensure that the Twitter experience will scale as well. Although we all might feel tremendous ownership over it after bringing it into our lives, it is still Twitter’s platform.

After this, the “simple twitter client” will no longer be an example for programmers to follow but their curated terms, layout, and functions will be available to everyone. Consistency is key to their larger growth. Beyond that, it’s what they want to do. You can’t boss them around, but you can go build something better.

The more twitter grows, the more opportunities we’ll have to work with tweets and tweeters. C’mon it’ll be fine, and it’s time for something new.

Event Delegation with Prototype and LowPro

Tumblr makes me put something here before a code block—

Event.addBehavior {
  "button:click": ->
    alert "A button was clicked."
    this.disable().update "Clicked"
}                                

LowPro makes it easy to delegate events. The advantage of event delegation is that you can add to your event pool without adding individual listeners to many elements, greatly simplifying your code and making it more performant.

This also means that if you create a module or class for a specific purpose, like showing a dialog window, you can easily add events that are specific to your code, without interfering with your previously designed behaviors:

class Euclid.Window
  initialize: (@element)->
    @element.addClassName "EuclidWindow"
    @addBehaviors()
  addBehaviors: ->
    Event.addBehavior {
      ".EuclidWindow button:click" ->
        alert "And that button is inside an EuclidWindow"
    }   
  show: ->
    @element.appear()
    Event.addBehavior.refresh()

Snap your pixels

Snap to pixels in Illustrator CS5

Unsnapped

Snapped

Snap it all

Accelerating 417east

Recently I’ve been experimenting with methods for decreasing load on 417east. Currently it hosts 38 virtual hosts running on nginx: a few Rack applications passed through mod_rack; half are passed through PHP-FPM; the rest being static HTML sites. The server also runs sshd and afpd (so Mac users smile), and tends to run low on memory if applications leak.

• First, I switched from Apache to Nginx.

  Nginx is much faster at serving static assets, and since there are so many simple sites running on the server, this immediately speeds up the environment for those users.

• PHP5-FPM

  Rather than use a more traditional fast-cgi solution for nginx, I went with PHP-FPM, which has the ability to spawn and scale back instances of PHP applications with greater flexibility. Typically performance is just below apache+mod_php, but that’s alright since the static assets those sites are working with become much faster.

• Varnish

  Just recently I decided to add an additional caching layer atop nginx. nginx now listens on 8000 and receives filtered requests from Varnish, so that often a website won’t hit the web server layer at all. Imeplementing this is literally as easy as installing Varnish and changing your web server’s ports. I found some help on StackOverflow with writing a basic VCL.

Pascal famously said, “I wrote you a long letter because I didn’t have time to make it shorter.” The longer the argument, the sloppier and less well-thought out it appears.

Found on ALA.

Consider this:

 if (@current_location == :nyc)
      @pizza_sux = true
 end

The internets are drastically mistaken about pizza quality. New York’s average slice is really awful. It’s wet, huge, greasy, and predictable. Chicago suffers from the same ailments.

From SPF10000