"PNN" via Noreply in Google Reader

Notesdeck is a simple text editor for iOS and OS X that aims to...

2012-11-26T18:00:22Z

Notesdeck is a simple text editor for iOS and OS X that aims to bridge the gap between storage and synchronisation services.

Both apps can corral your notes from iCloud, Dropbox, Evernote and Simplenote, with global search across all services and Textexpander support. The OS X version offers a live Markdown preview, and lets you share notes on Squarespace, Tumblr and Twitter.

App Store / Mac App Store

Expansionwire: Multiplying burrito chain Chipotle has plans...

2012-05-16T19:00:00Z

Multiplying burrito chain Chipotle has plans to add another SoMa location at 109 4th Street soon. This will be their fourth burrito outpost downtown, and Chipotle people say there are even more undisclosed locations on the way in San Francisco. Hey look! There's still time to apply to be a "team member" too. [Eaterwire]

Shifting to the client again

2012-03-15T23:33:00Z

This is my take on the current shift to rich, in-browser JavaScript apps.

Looking back over a few decades, this is the progression of how applications have been built:

mainframes and dumb terminals
minicomputers and smart terminals
networked workstations
workstations and shared code/data repositories
web apps and static HTML
web services and rich browser apps

Translation: The main body of the application code lives on the:

server
server + client
client
server + client
server
server + client

The server/client pendulum swings back and forth. The next logical step is apps that run on the client using standard services. Just give it a few more years...

Grace Hopper to Programmers: Mind Your Nanoseconds!

2012-03-01T17:21:33Z

Computing pioneer Grace Hopper, inventor of the compiler, searched for a concrete way to create an intuitive understanding of just how fast is a nanosecond, a billionth of a second, which was the speed of their new computer circuits. As an illustration she settled on the length of wire that is as long as light can travel in one nanosecond. The length is a very portable 11.8 inches. A microseconds worth of wire is a still portable, but a much bulkier 984 feet. In one millisecond light travels 186 miles, which only Hercules could carry. In today's terms, at a 3.06 GHz clock speed, there's .33 nanoseconds between ticks, or 3.73 inches of light travel.

Understanding the profligate ways of programmers, she suggests that every programmer wear a necklace of a microseconds worth of wire so they know what they are wasting when they throw away microseconds. And if a General is busting your chops about satellite messages taking too long to send, you can bust out your piece of wire and explain there's a lot of nanoseconds between here and there.

Here's a short, witty, and wise video of her famous nanosecond demonstration. An amazing lady, great innovator, an engaging speaker, and an inspiring teacher.

@DreeStewart Pivotal Tracker, mais c'est de la crotte ! les hipsters utilisent sprint.ly ! :D

2012-02-13T19:06:29Z

@DreeStewart Pivotal Tracker, mais c'est de la crotte ! les hipsters utilisent sprint.ly ! :D

An ode to running a database on bare metal

2012-01-24T17:03:00Z

No, my muse is not quite as strong as to inspire me to write an ode, but I still want to emphasize a few points about the goodness of running a database on bare metal.

At Evite, we use sharded MySQL for our production database. We designed the current architecture in 2009, when NoSQL was still very much in its infancy, so MySQL seemed a solid choice, a technology that we could at least understand. As I explained elsewhere, we do use MySQL in an almost non-relational way, and we sharded from the get-go, with the idea that it's better to scale horizontally than vertically.

We initially launched with the database hosted at a data center on a few Dell PE2970 servers, each with 16 GB of RAM and 2 quad-core CPUs. Each server was running 2 MySQL instances. We didn't get a chance to dark launch, but the initial load testing we did showed that we should be OK. However, there is nothing like production traffic to really stress test your infrastructure, and we soon realized that we have an insufficient number of servers for the peak traffic we were expecting towards the end of the year.

We decided to scale horizontally in EC2, with one MySQL instance per m1.xlarge EC2 instance. At the time we also engaged Percona and they helped us fine-tune our Percona XtraDB MySQL configuration so we could get the most out of the m1.xlarge horsepower. We managed to scale sufficiently enough for our high season in 2010, although we had plenty of pain points. We chose to use EBS volumes for our database files, because at the time EBS still gave people the illusion of stability and durability. We were very soon confronted with severe performance issues, manifested as very high CPU I/O wait times, which were sometimes so high as to make the instance useless.

I described in a previous post how proficient we became at failing over from a master that went AWOL to a slave. Our issues with EBS volumes were compounded by the fact that our database access pattern is very write-intensive, and a shared medium such as EBS was far from ideal. Our devops team was constantly on the alert, and it seemed like we were always rebuilding instances and recovering from EC2 instance failures, although the end-user experience was not affected.

Long story short, we decided to bring the database back in-house, at the data center, on 'real' bare-metal servers. No virtualization, thanks. The whole process went relatively smoothly. One important point I want to make here is that we already had a year's worth of hard numbers at that point regarding the access patterns to our database, iops/sec, MySQL query types, etc, etc. So it made it easy to do proper capacity planning this time, in the presence of production traffic.

We started by buying 2 Dell C2100 servers, monster machines, with dual Intel Xeon X5650 processors (for a total of 24 cores), 144 GB RAM, and 12 x 1 TB hard disks out of which we prepared a 6 TB RAID 10 volume which we further divided in LVM logical volumes for specific types of MySQL files.

We put 2 MySQL instances on each server, and we engaged Percona again to help us fine-tune the configuration, this time including not only MySQL, but also the hardware and the OS. They were super helpful to us, as usual. Here are only some of the things they recommended, which we implemented:

set vm.swappiness kernel setting to 0 in /etc/sysctl.conf
set InnoDB flush method to O_DIRECT because we can rely on the RAID controller to do the caching (we also mounted XFS with the nobarrier option in conjunction with this change)
disable MySQL query cache, which uses a global mutex that can cause performance issues when used on a multi-core server
various other optimizations which were dependent on our setup, things like tweaking MySQL configuration options such as key_buffer_size and innodb_io_capacity

One important MySQL configuration option that we had to tweak was innodb_buffer_pool_size. If we set it too high, the server could start swapping. If we set it too low, the disk I/O on the server could become too problematic. Since we had 144 GB of RAM and we were running 2 MySQL instances per server, we decided to give each instance 60 GB of RAM. This proved to strike a good balance.

Once the fine-tuning was done, we directed production traffic away from 4 EC2 m1.xlarge instances to 2 x 2 MySQL instances, with each pair running on a C2100. We then sat back and wallowed for a while in the goodness of the I/O numbers we were observing. Basically, the servers were barely working. This is how life should be.

We soon migrated all of our MySQL masters back into the data center. We left the slaves running in EC2 (still one m1.xlarge slave per MySQL master instance), but we changed them from being EBS-backed to using the local ephemeral disk in RAID 0 with LVM. We look at EC2 in this case as a secondary data center, used only in emergency situations.

One thing that bit us in our bare-metal setup was....a bare-metal issue around the LSI MegaRAID controllers. I already blogged about the problems we had with the battery relearning cycle, and with decreased performance in the presence of bad drives. But these things were easy to fix (again thanks to our friends at Percona for diagnosing these issues correctly in the first place...)

I am happy to report that we went through our high season for 2011 without a glitch in this setup. Our devops team slept much better at night too! One nice thing about having EC2 as a 'secondary data center' is that if need be, we can scale out horizontally by launching more EC2 instances. In fact, we doubled the number of MySQL slave instances for the duration of our high season, with the thought that if we need to, we can double the number of shards at the application layer, and thus scale horizontally that way. We didn't have to do any tweaking fortunately, but we were able to -- a strategy which would otherwise be hard to pull off if we didn't have any cloud presence, unless we bought a lot of extra capacity at the data center.

This brings me to one of the points I want to make in this post: it is a very valuable strategy to be able to use the cloud to roll out a new architecture (which you designed from the get-go however to be horizontally scalable) and to gauge its performance in the presence of real production traffic. You will get less than optimal performance per instance (because of virtualization vs. real hardware) , but since you can scale horizontally, you should be able to sustain the desired level of traffic for your application. You will get hard numbers that will help you do capacity planning and you will be able to bring the database infrastructure back to real hardware if you so wish, like we did. Note that Zynga has a similar strategy -- they roll out new games in EC2 and once they get a handle on how much traffic a game has, they bring it back into the data center (although it looks like they still use a private cloud and not bare metal).

Another point I want to make is that the cloud is not ready yet for write-intensive transactional databases, mainly because of the very poor I/O performance that you get on virtual instances in the cloud (compounded by shared network storage such as EBS). Adrian Cockcroft will reply that Netflix is doing just fine and they're exclusively in EC2. I hope they are doing just fine, and I hope his devops team is getting some good sleep at night, but I'm not sure. I need to perhaps qualify my point and say that the cloud is not ready for traditional transactional databases such as MySQL and PostgreSQL, which require manual sharding to be horizontally scalable. If I had to look at redesigning our database architecture today, I'd definitely try out HBase, Riak and maybe Cassandra. The promise there at least is that adding a new node to the cluster in these technologies is much less painful than in the manual sharding and scaling scenario. This still doesn't guarantee that you won't end up paying for a lot of instances to compensate for poor individual I/O per instance. Maybe a cloud vendor like Joyent with their SmartMachines will make a difference in this area (in fact, it is on our TODO list to test out their Percona SmartMachine).

Note however that there's something to be said about using good ol' RDBMS technologies. Ryan Mack says this in a Facebook Engineering post:

"After a few discussions we decided to build on four of our core technologies: MySQL/InnoDB for storage and replication, Multifeed (the technology that powers News Feed) for ranking, Thrift for communications, and memcached for caching. We chose well-understood technologies so we could better predict capacity needs and rely on our existing monitoring and operational tool kits."

The emphasis on the last sentence is mine. It's the operational aspect of a new architecture that will kill you first. With a well understood architecture, at least you have a chance to tame it.

Yet another point I'd like to make is: do not base your disaster recovery strategy in EC2 around EBS volumes, especially if you have a write-intensive database. It's not worth the performance loss, and most of all it's not worth the severe and unpredictable fluctuation in performance. It works much better in our experience to turn the ephemeral disks of an m1.xlarge EC2 instance into a RAID 0 array and put LVM on top of that, and use it for storing the various MySQL file types. We are then able to do LVM snapshots of that volume, and upload the snapshots to S3. To build a new slave, we can restore the snapshot from S3, then catch up the replication with the master. Works fine.

There you have it. An ode in prose to running your database on bare metal. Try it, you may sleep better at night!

Modularized Association Methods in Rails 3.2

2012-01-20T19:03:07Z

Happy Friday! It's Rails 3.2 day! The official release announcement mentions a few of the big changes, but I'd like to take a moment to highlight a relatively small change I was responsible for, one that I hope may make your life a little easier.

From the ActiveRecord CHANGELOG:

Generated association methods are created within a separate module to allow overriding and
composition using `super`. For a class named `MyModel`, the module is named
`MyModel::GeneratedFeatureMethods`. It is included into the model class immediately after
the `generated_attributes_methods` module defined in ActiveModel, so association methods
override attribute methods of the same name. *Josh Susser*

The point of this change is to allow more flexibility in working with associations in your model classes. When you define an association, ActiveRecord automagically generates some methods for you to work with the association. For example, a has_many :patches association generates the methods patches and patches= (and a few others).

Previously, those association methods were inserted directly into your model class. This change moves those methods into their own module which is then included in your model class. Your model gets the same methods through inheritance, but also gets to override those methods and still call them using super. Let's take a look at two ways this makes things easier for you.

Sometimes you want to replace the standard generated association methods. That's always been easy to do simply by defining new methods in your model class. The only wrinkle was that you had to make sure you defined your method after you set up the association, or calling has_many would overwrite your method, since last writer wins. That was usually not a problem, but sometimes plugins or other monkey patching extensions could add an association after your model's class was defined, which wouldn't give you a chance to add your method afterwards. With this change, you don't have to worry about those order dependencies anymore. Since those methods are generated in their own module, the order doesn't matter. This is a pretty small issue all told and I doubt it affected many people, but it's still worth mentioning.

The real reason for this change is being able to compose your own methods with the standard generated methods. Before this change, you'd have to use alias_method_chain or some other fancy footwork to layer your own logic on top of the standard association functionality. Either that or you'd have to somehow duplicate the standard behavior in your own method. Ick. Now you can compose methods using inheritance and super, the way Alan Kay intended you to. Here's the example from the docs:

class Car < ActiveRecord::Base
  belongs_to :owner
  belongs_to :old_owner

  def owner=(new_owner)
    self.old_owner = self.owner
    super
  end
end

If you're familiar with ActiveRecord it's probably fairly obvious what's going on there, but I'll spell it out for the new kids. When you define the belongs_to :owner association, that generates a standard owner= method, and puts it in the module named Car::GeneratedFeatureMethods, which is the closest ancestor of class Car. If you're curious what this looks like, fire up the rails console and type Car.ancestors to see the class's inheritance chain. (Or use your own app and model, since that will be much easier than making up a new app just to see that one thing.)

In this Car class, you can see that changing owners keeps track of the old owner, so the new owner knows who to call when he can't figure out how to open the trunk. The generated owner= method does a fair amount of stuff including managing counter caches, running callbacks, setting inverse associations, etc. Skipping that could break a number of things, so after saving the old owner, you also want to run the generated method. Since it's in a module that Car inherits from, you only have to call super to get that to run. No muss, no fuss!

One more step towards simpler OOP in Rails! Thanks to my fellow Ruby Rogues Avdi Grimm and James Edward Gray II for complaining about the old state of things enough to motivate me to finally go fix this.

The Onion on Facebook

2012-01-19T19:02:09Z

Funny news video on Facebook and the CIA.

Using False Alarms to Disable Security

2012-01-19T12:36:38Z

I wrote about this technique in Beyond Fear:

Beginning Sunday evening, the robbers intentionally set off the gallery's alarm system several times without entering the building, according to police.
The security staffers on duty, who investigated and found no disturbances, subsequently disabled at least one alarm. The burglars then entered through a balcony door.

CloudFlare Builds ‘Stop Censorship’ App, Lets Sites Easily “Black Out” Against SOPA

2012-01-17T00:08:41Z

Whatever position you may take on SOPA, or on whether or not sites should black out against SOPA (Yes it has come to this), the issue has reached a boiling point today with sites like Wikipedia and Reddit pledging to blackout on Wednesday in order to further raise awareness of the measure’s pitfalls.

Because SOPA and PIPA threaten the existence of sites that link to copyright infringing content (like Twitter, Wikipedia, Facebook and every other site on the Internet) the bills — which are currently stalled in Congress — have sparked a massive online backlash.

In addition to Reddit, Wikipedia and Icanhazcheezburger, Web security startup CloudFlare has thrown its large hat into the anti-SOPA ring, with the “CloudFlare Stop Censorship” app — which essentially solves investor Fred Wilson’s problem of not knowing exactly how to black out. As of 4pm PST, anyone who uses CloudFlare can download the app with one click from the CloudFlare App Marketplace (and those who don’t can grab the code from Github here).

“We thought it was an effective way to reach a mass audience and raise awareness about the dangers of a law like SOPA/PIPA,” CloudFlare founder Matthew Prince told me, “We see more than 25 billion page views per month for more than 400 million unique visitors. To give you some sense, that’s more page views than Amazon.com, Twitter, Wikipedia, Zynga, and AOL — combined. 400 million uniques is about 25% of the Internet’s entire population.”

Prince spent most of the weekend making sure that everything was in working order and that use of the app wouldn’t affect site search ranking.

Prince plans to keep the app available for the next month or so until the threat of SOPA has passed, he tells me, “I’m a recovering lawyer and still teach Internet & Technology law, so this is a subject I’ve been following closely and understand the real risks of. I’m pretty excited we’re helping make it easy for sites that want to participate in Wednesday’s blackout to do so.”

Splunk and Chef

2012-01-04T19:31:11Z

For those of you that run Chef in your Splunk environment, or are thinking of doing it, I have some great news. There is now an open source code base on github. Big thanks to Bryan Brandau and Aaron Peterson for working on this! Here is the official tweet and link:

https://twitter.com/#!/agent462/status/154640900566433792

https://github.com/bestbuycom/splunk_cookbook

Yak Shaving

2012-01-04T16:23:22Z

As coders, most of us are not only familiar with the term yak shaving, but spend many of our days doing nothing but. I often struggle to explain to non-technical folks what I actually spend my time doing when I'm working and what it feels like. This is the most accessible explanation I can come up with.

Say you want to go see a movie with your friend Joe. You can't get away with leaving the house when the kitchen is such a mess, so you have to load and run the dishwasher before you go. Unfortunately you're out of detergent, which means you have to run to the store to pick some up. You want to ride your bike or it will take too long to get to the store. But your bike's front tire is kind of low, so you have to pump it up first. However, your roommate borrowed your tire pump and you don't know where it is, so you have to go find your roommate and ask him about it. He's over at a neighbor's place having band practice, but it's just a short walk. When you get there they are in the middle of practice so you have to wait for a few minutes. The only place to sit is on that ratty old sofa, right next to the drummer's sister, Monica, who will only let you sit there on the condition you smoke a joint with her. But before you can do that you have to dig around in the seat cushions to find the lighter she just realized she lost. You manage to find the lighter, and before too long you are smoking out with Monica. The band finishes the number and your roommate comes over to see what's up. You take another hit off the joint and say "Hey, we should order a pizza."

I heard you liked files

2011-12-02T05:35:41Z

I was going to try and be clever and do a funny riff on this whole subject, but I just can't manage it. Here's the thing. Makefile was a dumb name for a file when Stuart Feldman wrote the make utility in 1977, but you have to forgive him because file systems were quite limited back then and filenames could only be a few characters long. The pattern was <filename.ext> - 8 chars for the name, 3 for the extension. I guess config.make wouldn't fit, config.mak looked weird, so Makefile it was.

Now we have no excuse. At all.

I respect and adore Jim Weirich, but I hope he feels at least a little shame for inflicting "Rakefile" on us all. That name choice seems to have set the stage for a proliferation of copycats. Now we have an ever-growing assortment of files that helpfully tell us they are files right there in the file name. Because something siting in a directory in the file system might be something else, like maybe a turnip or a bad hair day. Capfile, Gemfile, Assetfile, Vagrantfile, Guardfile...

You may ask: What's the problem? Why should anyone care about a cute little naming convention that continues a tradition going back over 30 years?

It may not be a huge deal, but there are a couple issues with this. All of these file formats are actually a variation on a well-accepted language: Ruby. But with a name that omits the standard .rb extension, language-aware tools have no chance to help us out. Syntax highlighting? Nope. Will awk search those files for you? No way. Will RubyMine figure out the structure of the code in those files? Forget it. OK, you can add those files to all your tools' configurations, then you're good to go. Until someone creates a new Crapfile and you have to go through and update all those configurations again.

Just because your configuration file's contents are written in a DSL does not mean you should pretend it's not Ruby anymore.

I urge every maintainer of a project that uses a name like Crapfile for the configuration file to move toward using a name that is compatible with language-aware tools. If you can't think of a name yourself, allow me to suggest this:

filename.sub(/file$/, '_config.rb').downcase

UPDATE: It has been pointed out to me that RubyMine actually does a pretty good job of dealing with these file names. Not perfect, but pretty good. Anyway, I don't want to come off as bashing RubyMine (I'm spending more time with it now and it's starting to grow on me), so substitute vim or emacs or TextMate or your most-hated editor instead.

Taking a new device API for a spin

2011-11-15T18:50:05Z

Taking a new device API for a spin:

James Pearce finds a sweet new API for the iPhone’s compass, and takes it for a test drive, in iOS5.

Wisdom of the Ancients

2011-11-18T05:00:00Z

Meanwhile, 6th and Mission

2011-11-04T16:20:33Z

Amazing artist Wendy MacNaughton illustrates the worlds of 6th and Mission, as well as 5th and Mission (but mostly 6th), in San Francisco, CA. …more

No related posts…

Velocity is Killing Agility!

2011-11-02T13:53:11Z

As I talk with companies around the world it’s clear that a significant number of them are still mired in the productivity, efficiency, and optimization mud. It’s easy to spot them because they are often maniacal about measuring velocity—team velocity, velocity across teams, rolling up velocity to an organizational level or even velocity per developer (yuck). Velocity is thereby killing agility. It’s the ultimate in applying a reasonable tool for the wrong reasons:

Velocity is increasingly being used as a productivity measure (not the capacity calibration measure that it was intended to be) that focuses too much attention on the volume of story points delivered.
Focusing on volume detracts from the quality of the customer experience delivered and investing enough in the delivery engine (technical quality).
Giving the product owner/manager complete priority control makes the problem worse—we have gone from customer focus to customer control that further skews the balance of investing in new features versus the delivery engine.
Particularly for those parts of the business for which high responsiveness (a deployment cycle time of days or weeks) is critical, investment in the delivery engine is as critical as investing in new features.
Management needs to allocate resources between features and engine work and then create a product ownership team consisting of the product owner and technical leader to do feature prioritization.
Value (value points) and cycle time metrics will help balance the detrimental effects of velocity measures.

Over emphasis on velocity causes problems because of its wide used as a productivity measure. The proper use of velocity is as a calibration tool, a way to help do capacity-based planning, as Kent Beck describes in Extreme Programming: Embrace Change. Productivity measures in general make little sense in knowledge work—but that’s fodder for another blog. Velocity is also a seductive measure because it’s easy to calculate. Even though story-points per iteration are calculated on the basis of releasable features, velocity at its core is about effort.

While Agile teams try to focus on delivering high value features, they get side-tracked by reporting on productivity. Time after time I hear about comments from managers or product owners, “Your velocity fell from 24 last iteration to 21 this time, what’s wrong? Let’s get it back up, or go even higher.” In this scenario velocity has moved from a useful calibration tool (what is our capacity for the next iteration?) to a performance (productivity) measurement tool. This means that two things are short-changed: the quality of the customer experience (quantity of features over customer experience) and improving the delivery engine (technical quality).

Agility is the ability to both create and respond to change in order to prosper in a turbulent business environment. It means we have to build and sustain a continuous value delivery engine, not one that bangs out many features the first release and then rapidly declines in ability thereafter. The ultimate expression of agility from a software perspective is continuous delivery and deployment. Our goal should not be productivity, but to “Design and deploy a great customer experience quickly—again and again over time.” In order to respond to business, technology, and competitor turbulence in the market we have to focus on delivering a superior customer experience, building new features, and improving the delivery engine that allows us to deliver quickly each and every release cycle.

Compounding the problem, the Agile movement has focused on high levels of customer involvement—basically a good thing—but we’ve gone too far. A large number of Agilists decry that they can’t get organizations to focus on technical practices—but why should that be a surprise when we encourage product managers/owners to make all the priority decisions and then measure performance using velocity? We have overcompensated for the lack of customer focus in traditional methodologies—by giving control of prioritization to the product owner/manager. The tendency has been to lump all work under the heading of “customer-facing” stories and assume we can convince product owners to agree to all the technical engine work that needs to be done. This is an over-correction from traditional projects in which months of technical work preceded any customer facing work (which was an even worse problem).

Product managers/owners understand prioritizing customer experience work, but they are generally not incented nor understand the technical engine work to be done. We need to create a product ownership team consisting of the product owner and a technical leader (which may include a quality assurance lead). Product owners are the customers of today while technical and quality leaders are the customers of tomorrow.

Imagine our software delivery engine as a high-powered jet engine in a fighter aircraft. What if we fail to perform adequate maintenance on that engine—it gets gunked up. What if we don’t periodically re-build parts of the engine? In software delivery we gum up the engine by: ignoring technical debt, delaying refactorings, disregarding automated testing, under-investing in continuous integration tools and processes, and in accepting long deployment cycles. These things are often considered “technical niceties” rather than keeping the engine running at optimum capacity.

In Don Reinertsen’s book, The Principles of Product Development Flow, he suggests the formula: Cycle time / Value added time = 1 / (1 – Utilization). Therefore, when teams optimize their process for velocity, they increase the amount of waste in the delivery process, and increase cycle time. Conversely, when teams optimize for cycle time, utilization (and thus velocity) goes down. There has to be a balance.

Business has moved from a world of periodic change to one of continuous change. In parallel to this, software development is evolving from project work (deliver software in a big batch and then maintain it) to one that is product oriented (deliver software in continuous releases). In order to drive behavior in the right direction we need to incorporate measures like value, delivery cycle time and technical quality metrics into our performance criteria. We need to calculate feature “value” points as well as feature “effort” points (story points). Cycle time can be an excellent measure because it depends on the software delivery engine working well, and, it’s a measure business customers understand. When we say, “Do we want new features or quality (or technical debt reduction, etc.)” it’s easy for product owners/customers to say, “of course new features.” Instead we need to say, “How do we need to balance new feature delivery with cycle time reduction?” [Note: Cost of Delay, per Don Reinertsen’s book, can also be a useful metric.]

This blog should not be interpreted as anti-velocity; it still has a place for capacity planning. The problem is the weight given to velocity and turning it into a productivity measure. Because it is easy to measure, we measure it. But even more important is measuring things like feature value, feature delivery cycle time, and quality measures (defects, technical debt, etc.). Delivering high-value features to customers should be paramount, but the focus should not be one-time delivery, but continuous delivery. The debate is not features or quality; it’s balancing delivering features quickly today with increasing our ability to delivery features quickly tomorrow—over and over again. Business responsiveness is a capability, not a one-time event. Supporting that ongoing need for business responsiveness requires a high-powered, well-oiled software responsiveness engine.

Note: Thanks to Martin Fowler, Jez Humble, and Ken Collier for their comments and ideas on this article.

'Free' Games Dominate Top-Grossing Game List On App Store

2011-11-02T07:33:00Z

An anonymous reader writes "Why are there so many free games listed in the top 10 grossing games over in Apple's App Store? Because some feature exorbitant in-app purchase fees for virtual items. Quoting ZDNet: 'Developing "free" games aimed specifically at children, and then bundling ridiculously priced in-app purchases inside those "free" games feels scammy to me. Sure, it's not illegal, and it's not against Apple's developer terms and conditions, but Apple is a company that prides itself in protecting users from harm. Most of the game developers do make an attempt to warn users that the game "changes real money for additional in-app content" but it's a lame attempt. It's easily missed, and kids aren't going to read it anyway.'"

Using functional style in a Ruby webapp

2011-10-31T06:54:45Z

Motivation

Consider a Ruby backend that communicates with its frontend via JSON. It sends (and perhaps receives) strings like this:

Let’s suppose it also communicates with a relational database. A simple translation of query results into Ruby looks like this:

(I’m using the Sequel gem to talk to Postgres.)

On the face of it, it seems odd for our code to receive dumb hashes and arrays, laboriously turn them into model objects with rich behavior, fling some messages at them to transform their state, and then convert the resulting object graph back into dumb hashes and arrays. There are strong historical reasons for that choice—see Fowler’s Patterns of Enterprise Application Architecture—but I’m starting to wonder if it’s as clear a default choice as it used to be. Perhaps a functional approach could work well:

Functional programs focus on the flow of data through code, rather than on objects with changing state. The former seems more of a match for a typical webapp.
It’s common in functional languages to lean toward a few core datatypes—like hashes and arrays—that are operated on by a wealth of functions. We could skip the conversion step into objects. Rather than having to deal with the leaky abstraction of an object-relational mapping layer, we’d embrace the nature of our data.

Seems plausible, I’ve been thinking. However, I’ve never been wildly good at understanding the problems of an approach just by thinking about it. It’s more efficient for me to learn by doing. So I’ve decided to strangle an application whose communication with its database is, um, labored.

I’m going to concentrate on two things:

Structuring the code. More than a year of work on Midje has left me still unhappy about the organization of its code, despite my using Kevin Lawrence’s guideline: if you have trouble finding a piece of code, move it to where you first looked. I have some hope that Ruby’s structuring tools (classes, modules, include, etc.) will be useful.
Dependencies. As you’ll see, I’ll be writing code with a lot of temporal coupling. Is that and other kinds of coupling dooming me to a deeply intertwingled mess that I can’t change safely or quickly?

This blog post is about where I stand so far, after adding just one new feature.

A path through the app

Critter4us is an app that’s used to reserve teaching animals at the University of Illinois vet school. Reserving animals is like reserving meeting rooms, but with some different business rules. For example, Boombird the horse doesn’t care if students practice bandaging on him every day. However, it would be inhumane to practice giving him injections every day, so that can be done at most twice a week.

The story I’ve been working on is one that makes a copy of an existing reservation but with a new “timeslice” (something like “January 1st through 3d, in the mornings”). Ideally, the same animals will be assigned to the copy, but that’s not always possible. If someone else has already reserved the animal for an overlapping timeslice, a new animal has to be found. Or if a procedure (like giving injections) would be within an animal’s “blackout period”, a new animal has to be found for it. For historical reasons, the reservation is made without the unusable animals and the user is alerted to edit it to add new ones.

Here’s the heart of the code for the feature:

The rest of this post will explain how that works and how it’s in a functional style. When I mention classes, I’ll link to the source.

FullReservation

The object model for the old program starts with a reservation, which contains information like “Who made the reservation?” and “For when?”. It also contains zero or more groups, each of which contains zero or more uses. A use links an animal to a procedure to be performed on it. I defined the class structure first, then mapped it onto a database schema, deliberately deferring any worries about efficiency:

The object-to-relational mapping library (Sequel) let me work with the data in a way that hid (”unflattened”) the table structure:

The existence of three tables is made somewhat implicit.

I’m replacing that old Reservation object with a new FullReservation. In FullReservation, I chose instead to make them explicit:

That notation is awkward to type and it doesn’t lend itself to the Symbol#to_proc hack, so I follow Javascript by allowing dot notation as a pun for key lookup:

Namespacing

I’m supposedly doing this in a functional style, and the very first thing I’ve done is make a class? What’s up with that?

I have two reasons. First, I think having the order of function application flow left to right fits the (Western-language-speaker) perception that time flows from left to right and from top to bottom. That makes this:

… easier to read than this:

The second reason is namespacing. You’ll shortly see that everything is built on top of an immutable, lazy FunctionalHash object. A FullReservation just collects those methods that wouldn’t make sense for anything but a FunctionalHash being treated as a reservation. It’s about avoiding name collisions more than about modeling the world.

Inheritance gives me nested namespaces, something I dearly wish I had in Clojure. For example, there are a variety of functions that apply to FunctionalHashes that represent database tables, but are irrelevant to other ones. That code is contained in FullReservation’s superclass, DBHash.

Actually: not quite. The text of the code is found in three different modules that are included into DBHash. I expect to do a lot of mixing-and-matching to create namespaces for particular DBHash classes and even particular objects (via extend).

Extracting a FunctionalTimeslice from a FullReservation

In the reservations table, there are three columns devoted to “when is the reservation for?” They are :first_date, :last_date, and :time_bits. (The first two are Date objects; the last represents the set {morning, afternoon, evening}. In a proper object-oriented design, you’d expect a FullReservation to contain a Timeslice that in turn contains those three values and some timeslice-specific methods as well. I chose to handle such sub-objects differently. Instead of asking a reservation for its timeslice, you make a timeslice from a reservation using setlike operations.

FunctionalHash has an only method that produces a smaller FunctionalHash containing only the named key-value pairs. So this is a timeslice:

I give the timeslice access to a timeslice-specific namespace by wrapping it in a class:

Adding a new Timeslice to Full Reservation

It’s often said that code without mutable state is easier to reason about. I don’t personally find that as big a deal as other people do, but I’ve gotten used to immutability from my Clojure programming. So FunctionalHash disallows messages like this:

The equivalent of assigning a value to a key is done by merging it and creating a new FunctionalHash. The equivalent of deleting a key is done by making a copy of FunctionalHash without the given key. At the moment, this implementation is grossly space-inefficient. Eventually, I’ll port it over to Simon Harris’s Hamster, which implements structure sharing and other optimization techniques. I’m even thinking I might port his code to C.

Here’s the way to change a reservation’s date:

A few notes:

change_within is a way of “merging” into a nested hash. It’s the equivalent of this:
Remember that, here, timeslice is a three-key hash, not an object.
I’m also removing the id to remind myself that the reservation produced here no longer corresponds to one in the database.

Working with disallowed animals

Any time a reservation is made, it disallows some animals (because they’re now in use) and may disallow some animal/procedure pairs (because of rules about how frequently a procedure can be performed). That information is calculated once and stored in Postgres tables named excluded_because_in_use and excluded_because_of_blackout_period.

The code to look up which animals are in use during a timeslice is factored into three pieces. Inlined, it would look like this:

(Fall turns an array of hashes into an array of FunctionalHashes.)

Because that code doesn’t refer to a reservation at all, it seems reasonable to put it in the FunctionalTimeslice namespace.

The FullReservation can use the list of animal ids to prune out its uses:

That’s all easy enough, but the contract with the user is that she’ll see a list of names of animals that couldn’t be included in the reservation. Getting that list is easy enough, given that we have ready access to the rejected uses. Here’s the code, with changes to the previous version highlighted:

That’s fine, but what do we do with the value named by ___animals_already_in_use___? I’d hate to return it along with the new version of the reservation because its caller would have to look like this:

I’d rather avoid names for intermediate steps in the creation of the reservation copy. I want the various versions to flow anonymously through a chain of functions so that I need only name the original and the final copy. (original and copy would be better names than reservation and new_reservation, it occurs to me, but I’m not going to go back now and change all these gists.)

That suggests slamming the animal list into the next version of the reservation, like this:

That kind of creeps me out, and it exacerbates temporal coupling. Nevertheless, it lets the caller look nice, which might mean something. (If mathematicians can go on about elegance, why can’t I?) I hope my tests will loudly tell me when coupling causes a change to function X to break function Y.

as_saved

The last step of creating the copied reservation is oddly named:

as_saved? This is a stylistic affectation that I’m not sure is a good idea. What I’m trying to imply is that the main thing this function does is create a new FullReservation with a bit of extra data, namely data.id, merged in. (The id needs to be sent off to the front end.) The fact that the id is created by changing persistent state somewhere is just an implementation detail. It could just as well be that every possible reservation always already exists somewhere as a big immutable pool, so as_saved just does a lookup to find the matching id.

(Which, it again occurs to me too late, perhaps makes as_saved a name that, strictly, reveals too much about the implementation.)

(Interestingly, I understand that the human immune system works roughly like the silly implementation above: you’re born with some 10 billion different antibodies and the response to infection (mostly) involves finding the useful ones, not creating new ones that match the foreign agent.)

only and the nature of classes

After the as-it-appears-in-the-database FullReservation is created, the pieces that the frontend code care about are extracted and returned to the controller code, which turns them into JSON:

But something creepy is going on here. What’s the type of the result of only?

How can anyone possibly believe that the two-element hash, containing nothing about the reservation in question (but only about the difference between it and its original) is a FullReservation?

For a time, I considered changing only to produce a FunctionalHash, rather than (as it does) an object of the same class as the receiver of the method. Then I smacked myself and reminded myself that I’m using classes to identify namespaces, not natural kinds. Saying that the result of only “is a” FullReservation would be absurd. But it’s less absurd to say that (1) we started with a hash, (2) the functions in the namespace FullReservation applied to it, (3) we derived a second hash from the first, so (4) it’s probably a good guess that the same namespace will be also useful for the second hash.

That is, it’s all about conservation of work. If I stripped every result of only down to a bare FunctionalHash, I’d sometimes have to add a namespace back. By not stripping it, sure, I may get irrelevant functions in the easily-accessible namespace, but I can just ignore them.

Laziness

I chose the name FullReservation not just because Reservation was already taken. It’s because a FullReservation contains all the values that can possibly be relevant to a reservation. But some HTTP requests only care about the reservation’s id. Some only care about some of the data (like the timeslice). Only a few care about the uses and the groups.

Laziness of the sort implemented in Clojure and Haskell seems a nice match for this. When a FunctionalHash key is assigned a block/lambda, it doesn’t treat that as a value. Rather, the FunctionalHash runs that block to calculate the value when the key is dereferenced. After that, the value is cached (and is immutable, just like any other value).

So consider these two steps from our controller:

We create a new reservation by saving a modified reservation to disk. That gives us a new row in the reservations table, some new rows in the groups table, and some new rows in the uses table. But nothing of the groups or uses is used from then on, so it would be a waste to populate the new_reservation with them. How is that avoided? By creating a FullReservation like this:

The uses and groups and even the row in the :reservations table are only loaded when they’re needed, so it costs little to use a FullReservation for everything. With this structure, I’m trying to gain more control than an object-to-relational mapping library gives me, while still freeing myself from the micromanagement of loading. Time will tell if that works.

(Note: I stash the original id that led to the FullReservation in :starting_id. Part of the motivation was to allow a completely fresh FullReservation to return its id without going to the database at all, and another part was to retain the original id even after later changes made it no longer an index into the reservation contents. This dual purpose makes the code confused, I think.)

(Note: Postgres supports the SQL RETURNING extension. So it’d be relatively easy to fully populate a saved FullReservation. I’ve used RETURNING several times, but always later discarded it for one reason or another.)

The grand conclusion

I’ve always hated end-of-talk or end-of-post summations. So I don’t really have one here, except that this approach feels promising, I want to continue trying it, I’d like to hear your comments (sorry about the antiquated blog software), and I’d especially like to hear what happens if you try out this approach.

On Programming Deadlines

2011-06-23T23:47:00Z

There are a lot of differences between programming, and programming professionally. The most notorious of which, is deadlines.

Deadlines

When you're writing code for yourself, you can spend as much (or as little time) on it as you please--but when you're writing code for other people, you've got only a limited amount of time and resources to get the job done. In my experience, this typically leads to one of two situations:

You've got to extend the deadline to finish the job properly.
You've got to write some dirty hacks to finish the job.

If you've ever done professional programming, you know what I mean. Very few projects are agile enough to allow for both sufficient time and resources to get the job done. This leads to tough decisions for programmers.

No self-respecting programmer wants to deliver sub-par code; but it's difficult to consistently deliver high-quality code when dealing with time obligations, especially in professional environments where you're dealing with non-engineers who don't necessarily understand the concept of technical debt.

Luckily, there are some guidelines you can follow to help minimize the amount of hackery you have to do when writing code on a deadline. They aren't necessarily quick-fixes, but can certainly be helpful to anyone who needs to consistently push out top-notch code, day after day.

Rule 1: Setup Continuous Deployment Before Writing ANY Code

This is a tip I picked up from The Pragmatic Programmer book (definitely required reading for any programmer). Always, and I mean always, setup your continuous deployment system before writing code.

What do I mean by continuous deployment? Well, before you start coding your project, you should have a system set up that lets you deploy your project code into production (and preferably staging and development environments as well). This way, as you write your code, you'll have the peace of mind that comes with knowing your project can be deployed at any moment.

In a lot of programming workflows, this can save tons of development time. Instead of scp'ing your project to some testing environment (or worse, coding directly on a live server), you can just push your code to your preferred source control system, and let your continuous deployment system take care of the rest. It may not seem like much of a time saver--but if you consider the amount of time it takes, day after day, to copy your code over and do testing manually, it can quickly add up and save hours of time each month.

Rule 2: Write Tests First

If you've never heard of test-driven development (TDD), please read the wikipedia article on it immediately. If someone is paying you to write software, and you've got a deadline, then you need to be practicing TDD at all times.

The basic concept of test-driven development is that before writing project code, you write a simple piece of code that tests your hypothetical project code for desired behavior. For example, let's say your project requires you to write a function that adds two numbers, and returns the sum of these numbers. Before writing that piece of code, you should write a test function, test_add_two_numbers, that calls your add_two_numbers function with various inputs, and verifies through assertions that the results you get back are proper.

This may seem like a bit of a hassle, but it has numerous benefits:

Writing tests first help you clarify your application architecture.
You have the peace of mind that comes with knowing your code is operational.
You're able to easily refactor parts of your project without worrying about breaking code.
You can avoid releasing low-quality code, and tarnishing your reputation.

Writing tests certainly takes time and effort, but can save time in the long run by avoiding emergency bug-fixes, system crashes, etc. Especially when you're on tight deadlines, you don't want the added stress and worry of buggy code.

Rule 3: Be Transparent

Transparency can be difficult to achieve (depending on your work environment), but can be greatly beneficial.

In order to be transparent, you need to make sure that you have a clear line of communication with the clients receiving your code. You need to keep them updated reguarly as to what is being worked on, and how far along progress is. Bonus points if you can continuously deploy your code to a staging system where clients can view the unfinished project and see how it is changing day after day.

If you're able to maintain transparency with your boss(es), they're much more likely to be understanding if deadlines need to be pushed back. Non-engineers often don't understand software development, and view it as a black-box art. By maintaing clear communication and transparency with your clients, and getting them involved in the process, they'll be more understanding of your work, and they'll feel happier about the product they're getting developed.

Rule 4: Maintain Daily TODO Lists

Time management is definitely out of the scope of this article, but I will mention that maintaining a daily TODO list is one of the best things you can do as a programmer to ensure things are progressing forward at all times.

Software development is an immensely complex task. It requires years of practice, patience, and discipline to become a good programmer, and you are never finished learning. When writing software on a deadline, more often than not, you're writing a complex system. In order to keep your head clear, and allow you the maximum amount of programming power, you should maintain a daily TODO list consisting of each individual task that needs to be accomplished (code-wise) in the day.

Don't make overly vague TODO items such as "debug sound problem", really think it through, and write out the full task in numerous steps. For example:

Write a unit test for the load_soundfile function that checks to see if mp3s are playable.
Write a unit test for the load_soundfile function that checks to see if wav files crash when loading.
Create new feature branch, design_update, to hold the new web design templates.
Update style.css using the new web design templates.

Having a clear list of actionable items gives you the power to focus on a single task at a time, without having to balance 100 or so next-steps in your head. Writing software is complex enough already, don't make your life more difficult!

Rule 5: Do the Right Thing

There will undoubtedly be circumstances that arise which make you nervous and uncomfortable. Did you procrastinate yesterday and skip writing the unit tests for your new features? When these situations arise, don't go with your instinct. Instead--do the right thing.

Whether you need to double back and revisit some old code, write some more test cases, or even delay a deadline--do it. As a professional engineer, it's your job to deliver working code consistently, even if that means you've got to make tough choices.

Conclusion

Being a software developer is no easy task. Our world is filled with constant challenge and hardship, and only our discipline and preparedness can help us push through the hard times, and prosper in the good times. Always use your best judgement, and beat the deadlines by using steadfast engineering practices, and never giving in to anything less.

You can do it.

Permalink | Leave a comment »

Scala: Option.isDefined as the new null check

2011-11-01T00:58:45Z

One cool thing about using Scala on my current project is that we don’t have nulls anywhere in our code, instead when something may or may not be there we make use of the Option type.

Unfortunately what we’ve (heavily contributed by me) ended up with in our code base is repeated use of the isDefined method whenever we want to make a decision depending on whether or not the option is populated.

For example the following is quite common:

case class Foo(val bar:String)
val foo : Option[Foo] = Some(Foo("mark"))

> val bar = if(foo.isDefined) Some(foo.get.bar) else None
bar: Option[String] = Some(mark)

We can actually get rid of the if statement by making use of collect instead:

> val bar = foo.collect { case f => f.bar } 
bar: Option[String] = Some(mark)

And if foo is None:

> val foo : Option[Foo] = None
> val bar = foo.collect { case f => f.bar } 
bar: Option[String] = None

The code is now simpler and as long as you understand collect then it’s easier to understand as well.

Another quite common example would be something like this:

case class Foo(val bar:Option[String])

> val foos = List(Foo(Some("mark")), Foo(None), Foo(Some("needham")))
foos: List[Foo] = List(Foo(Some(mark)), Foo(None), Foo(Some(needham)))

> foos.filter(_.bar.isDefined).map(_.bar.get + " awesome")
res23: List[java.lang.String] = List(mark awesome, needham awesome)

Which we can simplify down to:

foos.collect { case Foo(Some(bar)) => bar + " awesome" }

When I was playing around with F# a couple of years ago I learnt that wherever possible I should try and keep chaining functions together rather than breaking the code up into conditionals and I think the same applies here.

There are loads of methods available on TraversableLike to help us achieve this.

Starting in the Middle

2011-10-24T06:00:00Z

When I start on a personal project, I'm bright-eyed and optimistic. I've got an idea in my head, and all I need to do is implement it. Wait, before I can begin working on the good stuff there are some foundational underpinnings that don't yet exist. I work on those for a while, then I get back to main task...until I again realize that there are other, lower-level libraries that I need to write first.

Now I'm worried, because I'm building all this stuff, but I'm no closer to seeing results. I charge ahead and write one-off routines and do whatever it takes to get a working version one-point-oh. Then I hear the creaks and groans of impending code collapse. I shift my focus to architecture and move things to separate modules, refactor, sweep out dark corners, and eventually I'm back to thinking about the real problem. It's only a short respite. As the code gets larger and more complex, I find myself having to wear my software engineering hat more and more of the time, and that's no fun.

That's the story sometimes, anyway. When using functional programming languages I take a different approach: I pick an interesting little bit that's right in the middle of the problem and start working on it. I don't build up a foundation needed to support the solution. I don't think about how it integrates into the whole. There's a huge win here that should be the selling point of functional programming: you can build large programs without worrying about architecture.

Okay, sure, that architecture dodge isn't entirely true, but it's dramatic enough that I'm surprised functional programming isn't the obvious choice for anyone writing "So you want to learn to program?" tutorials. Or at least that it isn't the focus of "Why Functional Programming is Great" essays. If nothing else, it's a more compelling hook than currying or type systems.

How can starting a project in the middle possibly work? By writing symbolic code that lets me put off as many design decisions as possible. If I'm writing the "move entity" function for a video game, the standard approach is to directly modify a structure or object representing that entity. It's much easier to return a description of the change, like {new_ypos, 76} or {new_color, red}. (Those are both Erlang tuples.) That avoids the whole issue of how to rebuild what may be a complex, nested data structure with a couple of new values.

If I want to multiply the matrices M and N, the result is {'*', M, N}. (This is another Erlang tuple. The single quotes around the asterisk mean that it's an atom--a symbol in Lisp or Scheme. Those quotes are only necessary if the atom isn't alphanumeric.) The function to transpose a matrix returns {transpose, M}.

It looks like the essential work is being dodged, but it depends what you're after. I can write code and see at a glance that it gives the right result. I can use those functions to create more interesting situations and learn about the problem. If I find my understanding of the problem is wrong, and I need to back up, that's okay. It's more than okay: it's great! Maybe it turns out that I don't need to multiply matrices after all, so I didn't waste time writing a multiply routine. Maybe the transpose function is always called with a parameter of {transpose, Something}, so the two transpositions cancel out and there's no need to do anything.

At some point I have to stop living this fantasy and do something useful with these abstract descriptions. Hopefully by that time my experiments in symbolic programming have better defined both the problem and the solution, and I won't need to spend as much time thinking about boring things like architecture.

(If you liked this, you might enjoy Living Inside Your Own Black Box.)

Things That Turbo Pascal is Smaller Than

2011-10-30T06:00:00Z

Turbo Pascal 3 for MS-DOS was released in September 1986. Being version 3, there were lesser releases prior to it and flashier ones after, but 3 was a solid representation of the Turbo Pascal experience: a full Pascal compiler, including extensions that it made it practical for commercial use, tightly integrated with an editor. And the whole thing was lightning fast, orders of magnitude faster at building projects than Microsoft's compilers.

The entire Turbo Pascal 3.02 executable--the compiler and IDE--was 39,731 bytes. How does that stack up in 2011 terms? Here are some things that Turbo Pascal is smaller than, as of October 30, 2011:

The minified version of jquery 1.6 (90,518 bytes).

The yahoo.com home page (219,583 bytes).

The image of the white iPhone 4S at apple.com (190,157 bytes).

zlib.h in the Mac OS X Lion SDK (80,504 bytes).

The touch command under OS X Lion (44,016 bytes).

Various vim quick reference cards as PDFs. (This one is 47,508 bytes.)

The compiled code for the Erlang R14B02 parser (erl_parse.beam, 286,324 bytes).

The Wikipedia page for C++ (214,251 bytes).

(If you liked this, you might like A Personal History of Compilation Speed.)

The Internet Archive

2011-10-31T02:54:52Z

Shared by sconover
" they are also constructing a terracotta army of avatars of their long-term employees"

Earlier this week, Jason Scott was kind enough to give me a tour of The Internet Archive. They do amazing, important work, and I've been a huge fan for many years, but I hadn't visited before.

Their San Francisco presence is housed in a former Christian Science church, lending it a certain gravitas. Their enormous conference room not only has racks of drives sitting at the back, but also has a working pipe organ! (Make your own series of tubes joke here.)

Inexplicably, they are also constructing a terracotta army of avatars of their long-term employees. I assume these are to protect Brewster in the afterlife.

The racks of drives are just kind of scattered all over the place, climate control provided opening windows. Each blinkenlight is a 2TB drive. They have mirrors all over the world, so I gather it's a "use the cheapest thing possible and have a zillion backups" kind of scenario.

The book-scanning operation is pretty sweet. There's an angled backplate with a correspondingly-angled piece of glass that hinges down over it to hold the pages flat, and a pair of Canon 5D Mk 2 cameras pointing at each page. Apparently once you get into the rhythm of it, you can scan an entire book in 8 minutes. Volunteers and interns: cheaper than robots!

Random libraries (and individuals) around the world ship them crates of books, they scan them, and ship them back.

Previously, previously, previously, previously, previously.

Links for October 30th

2011-10-30T22:00:15Z

Programming With Nothing // Speaker Deck

The highlight of Ruby Manor: Tom Stuart's completely brilliant explanations of programming with nothing but Procs: making them, calling them, and nothing else. He made it fun, informative, and the right amount of mental.

(tags: programming procs tomstuart rubymanor brilliant )

Metagames: Games About Games

2011-10-30T22:08:55Z

Shared by sconover
Andy Baio's collection of Metagames is brilliant, don't miss it.

Over the last few years, I've been collecting examples of metagames — not the strategy of metagaming, but playable games about videogames. Most of these, like Desert Bus or Quest for the Crown, are one-joke games for a quick laugh. Others, like Cow Clicker and Upgrade Complete, are playable critiques of game mechanics. Some are even (gasp!) fun.

Since I couldn't find an exhaustive list (this TV Tropes guide to "Deconstruction Games" is the closest), I thought I'd try to pull one together along with some gameplay videos.

This is just a starting point, please post your additions in the comments or email me and I'll add them in. Note: I've tried to stay away from specific game parodies (like Pong Kombat or Pyst), and stick to games that comment on game design, mechanics, or culture.

Program Or Be Programmed

2011-10-30T12:22:51Z

On Thursday night I gave a talk at NYU Poly and in the Q&A a young man asked me for advice for "those who aren't technical". I said he should try to get technical. The next morning I met with a bunch of Sloan Business School students doing a trek through NYC. A young woman asked me the same question. I gave her the same answer.

I don't mean that everyone should become a software engineer. I do mean that everyone should understand software engineering (or whatever technical subject/industry you want to work in). I don't speak French fluently. But when I go to France, I know enough French to speak it badly until the person on the receiving end changes the language to English.

Dennis Crowley claims to be a terrible programmer. And yet he and Naveen built the first version of Foursquare together. Their third team member was Harry and Harry's first job was to rewrite all of Dennis' code. Dennis is the kind of technical I'm talking about. Learn how to hack something together so that you can get people interested in your idea, your project, your startup. If you can do that, then you have a better chance of success.

Another great reason to "get technical" is so that you can work better with technical people. If you understand at least some of what they are doing, if you can look at their work product (the code) and understand what it is doing, if you can pick up a ticket and contribute when time is tight, then you will be seen as part of the team. And that is critical.

All of this is a big reason for our most recent investment, in Codecademy. Codecademy wants to be the online resource for people who want to learn to code. What you see there now is basically a prototype. And yet somewhere between 500,000 and 1mm people have started learning javascript using the prototype. They are clearly on to something.

I haven't written code professionally in twenty-five years. The last application I built was a custom app for my mother in law's company. She ran her business on it for twenty years. I wrote simulation software for a company building ships for the US Navy. And I wrote software that ran data acquisition for a lab at MIT. I was never a great programmer. I was a hacker. But I do understand the basic concepts, I can build something. I think most everyone can get to the place I got to and I'd encourage everyone to try.

Our partner Andy wrote a great post on the USV blog announcing our investment in Codecademy. He wrapped up his post with a quote from Douglas Rushkoff. It's where I got the title of this post from and it says it well.

When human beings acquired language, we learned not just how to listen but how to speak. When we gained literacy, we learned not just how to read but how to write. And as we move into an increasingly digital reality, we must learn not just how to use programs but how to make them. In the emerging, highly programmed landscape ahead, you will either create the software or you will be the software. It's really that simple: Program, or be programmed.

"As a service grows in popularity, alpha users outlive their usefulness. The core users that helped..."

2011-10-29T17:14:20Z

“

As a service grows in popularity, alpha users outlive their usefulness. The core users that helped build a service by word-of-mouth often find themselves dwarfed in numbers by people with very different needs.

Take the recently-announced changes to Google Reader, for instance. Reader is the most widely-used and deeply-loved feed reader ever made, steamrolling over several startups in the mid-2000s in the process. Any startup would be thrilled to have their devoted audience; within Google, Reader seems like a distraction.

Last week, the Reader team announced the removal of all of its social features, used by a relatively small but rabid fanbase.

Courtney Stanton, a Boston-based product manager, called Google Reader “the best social network created so far” in a passionate rant on her blog. “For me, this is the destruction of the only online space I truly give a shit about.”

There’s no easy solution. Should a company be expected to maintain features indefinitely because a tiny fraction of their base loves them? There are tangible costs to maintaining old code, and fringe features can clutter an interface, making user experience worse for those that don’t use them.

For those people, removing features is more than an inconvenience. It shatters an entire community. But, ultimately, their usage is a rounding error in the overall product activity.

”

- Google Kills Its Other Plus, and How to Bring It Back - Waxy.org

Photo

2011-10-27T17:29:43Z

Photo

2011-10-27T21:37:42Z

E-PARASITE Bill: 'The End Of The Internet As We Know It'

2011-10-27T15:32:00Z

We already wrote about the ridiculously bad E-PARASITE bill (the Enforcing and Protecting American Rights Against Sites Intent on Theft and Exploitation Act), but having now had a chance go to through the full bill a few more times, there are even more bad things in there that I missed on the first read-through. Now I understand why Rep. Zoe Lofgren's first reaction to this bill was to say that "this would mean the end of the Internet as we know it."

She's right. The more you look at the details, the more you realize how this bill is an astounding wishlist of everything that the legacy entertainment gatekeepers have wanted in the law for decades and were unable to get. It effectively dismantles the DMCA's safe harbors, what's left of the Sony Betamax decision, puts massive liability on tons of US-based websites, and will lead to widespread blocking of websites and services based solely on accusations of some infringement. It's hard to overstate just how bad this bill is.

And, while its mechanisms are similar to the way China's Great Firewall works (by putting liability on service providers if they fail to block sites), it's even worse than that. At least the Chinese Great Firewall is determined by government talking points. The E-PARASITE bill allows for a massive private right of action that effectively lets any copyright holder take action against sites they don't like. (Oh, and the bill is being called both the Stop Online Piracy Act (SOPA) and E-PARASITE (which covers the PROTECT IP-like parts of the bill, SOPA refers to the larger bill that also includes the felony streaming part).

Some of the key problems with the bill, beyond what we discussed yesterday:

While supporters of the bill still continue to insist that this bill is only targeted at foreign infringers, that's false. Part of the bill focuses on foreign infringers -- the part that allows the Attorney General to kill websites. But the private right of action section has no such restriction. Instead, it allows copyright holders to effectively kill any site they'd like. You have to dig down into the details to see this, but let's pull out the key sections to see. The act, in section 104, defines sites that are "dedicated to the theft of US property" as including any "US-directed site" that:
is taking, or has taken deliberate actions to avoid confirming a high probability of the use of the U.S.-directed site to carry out acts that constitute a violation of section 501 or 1201 of title 17, United States Code;
If that sounds massively confusing, you're right. But what it's saying, in the most twisted language possible, is that if it's probable that a site used in the US (note no restriction to just foreign sites here) can be used to infringe, and that site fails to take some sort of action against the "high probability" that the site can be used to infringe, then it can be declared dedicated to the theft of US property. This turns both the DMCA safe harbors and the Supreme Court's Sony Betamax ruling completely on their heads. In effect, it appears to be saying that if you choose not to self-police your site for infringement -- i.e., putting up filters, or proactively monitoring content for infringement -- you can be declared in violation of the law... at which point a court can order all ad networks and payment processors to automatically stop doing business with you.

Think of all the sites this could effect. Twitter, Facebook, YouTube, Tumblr, SoundCloud, Ebay, Flickr, Wikipedia, Craigslist, Wordpress -- basically any site that has any user-generated content. If they don't proactively filter or monitor their content, they could be at risk of a claim that they took "deliberate actions to avoid confirming a high probability" that their sites could be used to infringe... and thus they could be subject to an action by a private party that strips them of both ad revenue and the ability to process any payments.

Remember how Monster Cable -- massive supporters of this bill -- declared both Craigslist and eBay as being dedicated to infringement? Under this bill, a company like Monster could take action against those sites, putting a tremendous burden on them.

The definitional problems don't stop there. Separate from the ridiculous definition above, this act would also declare a site "dedicated to theft of U.S. property," if it is "primarily designed" in a way that "engages in, enables, or facilitates" a violation of copyright law. Those last two points are ridiculously broad. "Enables" infringement? "Facilitates"? That's practically the entire internet. The primary design of YouTube, Twitter, Facebook, etc. all "enable" or "facilitate" infringement.

While some reporters claimed that the "private right of action" was taken out of this bill, or even "softened," nothing could be further from the truth. The details show that the private right of action is significantly worse in this bill. What changed is that in PROTECT IP, private copyright holders could go to court to force payment processors and ad networks to stop dealing with sites they accuse. Under E-PARASITE, before they go to court, they first have to send a notification, very similar to a DMCA takedown notice. But, of course, as we've seen with the DMCA, while it's "voluntary" to comply, if you don't comply you lose safe harbors -- so nearly everyone complies. That means this private right of action almost certainly will lead to ad networks and payment processors cutting off any site they receive a notification on -- no matter how legitimate. And, while the bill does allow for a counternotification process, unlike the DMCA, there is no requirement that the payment processors and ad networks restore service to anyone who files a counternotice, after a given period of time (absent a lawsuit). In other words: a copyright holder could issue a bogus claim that a site is dedicated to infringement, and the payment processor and ad network could pull the plug on the site... and even if a counternotice is filed, those services have no obligation to bring back service.

Again, using our Monster Cable example, it could force all payment processors to no longer allow payments on Craigslist or eBay, and even if those sites filed counternotices, the service providers would be under no obligation to turn those things back on. And just think of the massive, irreparable harm if legitimate sites lose both the ability to accept payments and to have ads for just a few days? And while there is liability for those who file false notices, as we've seen with the DMCA, such provisions are rarely, if ever, enforced -- and generally are interpreted to only apply in cases of extreme misrepresentation.

As noted above, the private right of action establishes an astoundingly broad new standard for what's considered infringing. Beyond user-generated content sites, pretty much any cloud computing service can be deemed "dedicated to the theft of US property," if they choose not to filter and monitor the content being sent through the cloud. Any of the online locker services are in serious trouble if this bill becomes law. Amazon's and Google's music services would have to monitor your uploads and try to stop infringement to avoid liability. Box.net and Dropbox would likely have to monitor what files you're storing to avoid liability. It's honestly that insane.

Supporters of the bill, beyond falsely claiming that it's just focused on foreign sites, are also claiming that this bill does not target such sites. An aide to the House Judiciary Committee, who supports the bill, claimed, "Sites that host user content -- like YouTube, Facebook and Twitter -- have nothing to be concerned about under this bill." But that's demonstrably false. Perhaps this aide is unaware that Viacom is still in the middle of a $1 billion lawsuit claiming that YouTube was dedicated to infringement. Under the definitions in this bill, YouTube would absolutely have been liable, and likely would have been shut down years ago. In fact, Viacom never would have had to sue. It would have just made use of the notification process, and kept any and all advertising and payment processing from the site... and voila, dead YouTube, without the benefit of a judge reviewing the case (and, need we remind the House Judiciary Committee, that so far the judge has sided with YouTube?).

The bill would be red meat to any foreign government that censors its internet. China, Iran, Saudi Arabia are going to love this. The mechanisms for censorship are quite similar. Under E-PARASITE, service providers have to proactively block to prevent liability. China's Great Firewall works the exact same way: by threatening ISPs with liability if they don't block content harmful to Chinese citizens. Replace harmful to Chinese citizens with "a high probability" of being used for infringement... and you've got E-PARASITE.

Another change between this bill and the Senate's PROTECT IP is that this bill calls out "search engines" more directly, rather than "information location tools," as in the Senate bill. While that may seem to be narrower, the definition of a search engine is ridiculously broad (of course).
The term ‘‘Internet search engine’’ means a service made available via the Internet that searches, crawls, categorizes, or indexes information or Web sites available elsewhere on the Internet and on the basis of a user query or selection that consists of terms, concepts, categories, questions, or other data returns to the user a means, such as a hyperlinked list of Uniform Resource Locators, of locating, viewing, or downloading such information or data available on the Internet relating to such query or selection.
Under this definition, Techdirt could be declared a search engine under this law. After all, we take "questions" and queries from readers, and often return stories that link elsewhere on the internet. Yikes!

As highlighted above, there are all sorts of definitional problems with the bill. And you can tell how insane things get with definitions when the authors of this bill even go so far as to define the word "including." I'm not joking:
INCLUDING.--The term "including" means including, but not limited to.
This is the kind of mess we're dealing with.

About the only good thing is that the insanity and out-and-out censorship and hindering of the internet that this bill provides appears to have scared off co-sponsors of the bill. Despite a massive lobbying effort from the US Chamber of Commerce and the MPAA (among some others), Rep. Lamar Smith was only able to wrangle up eleven co-sponsors. For a bill of this nature, this is woefully low. Even more surprising is that they couldn't even get Rep. Mel Watt to co-sponsor the bill, despite being the ranking Democrat on the IP subcommittee of the House Judiciary Committee. Instead, they had to settle for Howard Berman, the Representative from Disney. In other words, it appears that many Congressional reps have heard the massive concerns of the public, technologists, entrepreneurs, investors, artists, human rights activists, and many others who are quite afraid of how this bill will break the internet. And that means that it can only help to continue to speak out and reach out to your representatives about how awful this bill is, and how much harm it would do.

Permalink | Comments | Email This Story

Richard Stallman's list of requests when speaking

2011-10-27T00:09:43Z

includes preferences for room temperature, egg yolks, folk dances, and why not to buy him a parrot; I find this man fascinating

PROTECT IP Renamed E-PARASITES Act; Would Create The Great Firewall Of America

2011-10-26T19:35:17Z

As was unfortunately expected, the House version of PROTECT IP has been released (embedded below) and it's ridiculously bad. Despite promises from Rep. Goodlatte, there has been no serious effort to fix the problems of the Senate bill, and it's clear that absolutely no attention was paid to the significant concerns of the tech industry, legal professionals, investors and entrepreneurs. There are no two ways around this simple fact: this is an attempt to build the Great Firewall of America. The bill would require service providers to block access to certain websites, very much contrary to US official positions on censorship and internet freedom, and almost certainly in violation of the First Amendment.

Oh, and because PROTECT IP wasn't enough of a misleading and idiotic name, the House has upped the ante. The new bill is called: "the Enforcing and Protecting American Rights Against Sites Intent on Theft and Exploitation Act" or the E-PARASITE Act (though, they also say you can call it the "Stopping Online Piracy Act").

The bill is big, and has a bunch of problems. First off, it massively expands the sites that will be covered by the law. The Senate version at least tried to limit the targets of the law (but not the impact of the law) on sites that were "dedicated to infringing activities" with no other significant purposes (already ridiculously broad), the new one just targets "foreign infringing sites" and "has only limited purpose or use other than" infringement. They're also including an "inducement" claim not found elsewhere in US regulations -- and which greatly expands what is meant by inducement. The bill effectively takes what the entertainment industry wanted the Supreme Court to say in Grokster (which it did not say) and puts it into US law. In other words, any foreign site declared by the Attorney General to be "inducing" infringement, with a very broad definition of inducing, can now be censored by the US. With no adversarial hearing. Hello, Great Firewall of America.

And while defenders of this bill will insist it's only designed to target truly infringing sites, let's just recall a small list of sites and technologies the industry has insisted were all about infringement in the past: the player piano, the radio, the television, the photocopier, the phonograph, cable tv, the vcr, the mp3 player, the DVR, online video hosting sites like YouTube and more. All of these things turned out to be huge boons for the industry. And yet, with a law like this in place, the old industry gets to kill off technologies they don't understand. Scary stuff.

And it's not just foreign sites impacted by this law (despite what supporters would have you believe). It appears to expand who would have to take on the entire burdens of enforcing this blacklist -- broadly naming "service providers" as defined in the DMCA. That's significant, because a big part of this bill is to undermine and strip away the safe harbors of the DMCA. The DMCA set up an important balance that gave online service providers freedom from liability if they pulled down content upon notification. This new bill provides a massive and ridiculous burden: allowing the Attorney General to create an internet blacklist that all service providers will need to block access to:

A service provider shall take technically feasible and reasonable measures designed to prevent access by its subscribers located within the United States to the foreign infringing site (or portion thereof) that is subject to the order, including measures designed to prevent the domain name of the foreign infringing site (or portion thereof) from resolving to that domain name’s Internet Protocol address. Such actions shall be taken as expeditiously as possible, but in any case within 5 days after being served with a copy of the order, or within such time as the court may order.

On top of that, the bill says any attempt to get around such blocks can lead to liability. Would this put liability on things like MAFIAAfire? It sure sounds like it:

To ensure compliance with orders issued pursuant to this section, the Attorney General may bring an action for injunctive relief....

against any entity that knowingly and willfully provides or offers to provide a product or service designed or marketed for the circumvention or bypassing of measures described in paragraph (2) and taken in response to a court order issued pursuant to this subsection, to enjoin such entity from interfering with the order by continuing to provide or offer to provide such product or service.

While the text of the bill insists that nothing in it takes away the DMCA's safe harbors, once again this is a claim without the facts to back it up. A large part of the bill is an effective attempt to strip away the DMCA's safe harbors.

The only extraordinarily minor change against the interests of the entertainment industry is that the bill ever so slightly changes the "private right to action," which allows individual copyright holders to take action under this bill. This was a big problem in the old bill, and the only requirement here is that prior to making use of this private right to action, copyright holders have to provide "notice" to payment processors and ad providers. But then those service providers are expected to take action anyway, or face liability. So all this really does is take the court out of the process, and make it even easier for copyright holders to effectively kill off sites they don't like.

Think about this for a second: think how many bogus DMCA takedown notices are sent by copyright holders to take down content they don't like. With this new bill, should it become law, those same copyright holders will be able to cut off advertising and payment processing to such sites. Without court review.

And... because this bill wasn't already ridiculously bad enough, it also lumps in a House version of the felony streaming bill that will make huge swaths of Americans felons for streaming content online.

This bill is an abomination and an insult to the Constitution. It's unfortunate that Rep. Lamar Smith thinks this is worth introducing in its current state, and anyone who signs on to co-sponsor is effectively supporting mass censorship of the internet in the US, as well as the criminalization of huge numbers of Americans -- while putting a huge burden on the one part of the economy that actually is creating jobs. All because a few legacy companies in the entertainment industry refuse to adapt.

Permalink | Comments | Email This Story

Rounded Corners 298 – Venn piagram

2011-10-25T16:00:20Z

Callbacks $.Callbacks is a new feature coming in jQuery 1.7 that will make it easier to chain and manage callbacks. Not to mention, dead easy to do pub/sub on the client side.

Sweet Sugar.js 1.0 is finally out, adding data locales, Object.watch, string interpolation and much more. Guaranteed to make your JS development full of win.’

Live coding CoderDeck lets you create live-coding presentations.

Tricky iOS 5 tips & tricks.

Ugly secrets iOS secrets: what you don’t know the app you’re running is doing in the background.

Partial Fortune on the gender disparity:

“The issue isn’t that women don’t ask. Maybe it’s that men don’t have to.”

And the award for "Angry Birds-related Correction of the Year" goes to...

2011-10-26T14:00:06Z

The New York Times! With the following note in their review of Walter Isaacson’s Steve Jobs:

An earlier version of this article incorrectly stated the premise of “Angry Birds,” a popular iPhone game. In the game, slingshots are used to launch birds to destroy pigs and their fortresses, not to shoot down the birds.

Just goes to show you even the Grey Lady still might be running off Blackberry.

-Drew Millard

[via] [image]

Francis Cleary - Google - Probably my biggest fear with moving from Reader to Plus is…

2011-10-25T16:50:50Z

Francis Cleary - Google - Probably my biggest fear with moving from Reader to Plus is…:

Google Reader is was the best asynchronous social network ever made. It’s the closest thing to a party that 25 people, all on totally different schedules, can swing.

“Now” didn’t matter. “Who” barely mattered. Sharing 3,000 items a month or 30? Didn’t matter.

Reader, somehow, some way, became the best possible way for people who can’t stand talking about themselves to communicate with each other.

Even if every Reader feature made it to Plus — and shit no they haven’t, and it doesn’t look like they will — the entire concept, culture and process is completely different. You can’t remotely replicate the closed, tight, context- and content-first communities of Reader in Plus. You can’t efficiently or effectively share, excerpt, annotate or discuss a 3,500-word longform news article on Plus alonewithout opening at least two other tabs.

You can’t sit back with a drink and catch up on discussions that don’t have to be carried on right fucking now or they’re gone forever in Plus.

Reader did it so, so well. It was an ugly motherfucker. It broke early and often, it never joined the API craze even as its never-documented and barely acknowledged reverse-engineered API went on to power who only knows how many web and mobile apps. It was held together for months, if not years, by one or two developers whose names are maybe even lost to history now.

[excerpt from https://plus.google.com/u/0/110805491250386698039/posts/UkTTmfKBuGC]

The World Is Surprisingly Angry About the End of Google Reader - Technology - The Atlantic Wire

2011-10-26T06:09:30Z

Shared by Laine
!!!!!!!!!!!!!!!!

The demise of Google Reader's share features is affecting everyone from RSS-junkies to Iranian freedom fighters, and many of them are very displeased. Google Reader itself is very much alive and well, and in fact, the RSS reader will soon sport a slick-looking redesign. However, at some point this week, the ability to follow, friend and share links within Reader will cease to exist, as Google pushes people to use Google+ for those kinds of things. Along with it, the myriad communities that depended on Reader for years for everything from meeting new people to organizing protests will just have to figure something else out. It turns out Google wasn't so bad at social networks, after all.

Displeased is actually not a strong enough word to describe these sentiment. These people are pissed, and they're fighting back. (There are already protests planned outside of Google offices and a petition--using Google Docs, of course--to save Reader's social features.) The dissenters divide into two camps: Iranians and the Sharebros.

Iran

You've undoubtedly heard a lot about how the Iranian protests of 2009 were driven by Twitter. They were, and the government responded immediately, imposing firewalls and other censorship measures in an effort to quash the uprising. Ultimately, pretty much every single social network was banned in Iran over the past couple of years, leaving Iranians without a free speech forum--except Google Reader. As an Iranian blogger who goes by Amir explains, "Google Reader is not in a separated domain (like any other Google product) and thanks to https protocol, it is hard to filter by government." Amir and other Iranians are worried that Google+, which lives in a subdomain that could be more easily blocked, will suffer the same fate as the other social networks:

Popularity map for Google Reader shows that Google Reader is the 1st popular website in Iran, despite the fact that many users which are using VPN or proxies and are not counted! Then it makes sense why Google Reader matters for Iranian and why integrating it with Google+ will makes it like any already available and banned website like facebook!

Alan Green, the Google programmer saddled with breaking the bad news on the company's official blog, has received nearly 500 comments on his Google+ post announcing the changes, many of them from angry Iranians who believe their freedom of speech is in jeopardy. He hasn't responded to a single one.

The Sharebros

Sharebros identify themselves simply as "person(s) whom one is following and followed by on Google Reader (as formally recognized by a Google Reader founder)," but their devotion to Reader is uncanny. Like more well known online communities like Reddit or 4chan, they've developed their own glossary of hashtags and lexicon of pictograms. ( -_- denotes "dissatisfaction or defeat.") The community doesn't just exist online, either. They have #sharebro parties, and many of them say they've met some of their closest friends via Google Reader. At least one Sharebro met his wife.

We talked to a number of Sharebros about the changes, and their arguments against axing the social features were about half as compelling as their stories about how Google Reader changed their lives. Richard Berger told The Atlantic Wire about how he ditched email and now primarily communicates with his mother via Google Reader. "Reader is the best way to share and discover content on the internet, period," says Richard.

Another, Stu Watson formed a band, No Sky God, with his friend James who he met through Google Reader. They just put out a 12" record featuring Nat Baldwin, the bassist from Dirty Projectors. "James and I would likely have never met without Reader," Stu wrote in an email, "but more importantly the social aspects of Reader allowed us to get to know each other in a more intimate and ultimately meaningful way than if we had, say, just been Facebook friends or something." Stu tells us that people in the Sharebro sphere are already working on coding their own Reader replacement--they don't want to use Google+.

The most compelling Sharebro story comes from Ramey Moore. In a Reader forum post, Ramey tells the story about how he and his wife, who's expecting a child soon, "first met at a #sharebro event, scheduled and organized solely through Reader." The (long) post concludes:

I am 100% certain that even if someone at Google cares or commiserates with me that nothing will change. … Basically, this is a panegyric. An elegy. A final funeral oration. A fuck you to those who want to kill something that works and try to build a Frankenstein's Monster that will probably choke to death on its own blood. Reader works as is, this move is just a sad attempt to jump-start an already failed Buzz 2.0.

That's it, I'm done. If anyone cares I'm going to be trying to imagine how to delete G+.

At least one protest organized by Sharebros is scheduled to gather tomorrow at Google's DC headquarters. Meanwhile, the petition to save Reader's social features has gathered thousands of signatures. And despite all the backlash from their most devoted users, the Google Reader teams has yet to respond. We reached out for a response and haven't heard back.

Want to add to this story? Let us know in comments or send an email to the author at aestes@theatlantic.com. You can share ideas for stories on the Open Wire.

Google Reader Is Dying: Will You Cope By Protesting, Perhaps?

2011-10-26T06:07:21Z

Shared by Jim
#OccupyGoogleReader

I mentioned this yesterday, but despite plans to change its functionality and integrate it into Google +, Google Reader—an RSS feed reader—is alive and well for lots of people. Including, apparently, folks in Iran. Tech Crunch takes note:

According to a blog post now making its way around the Web, Google Reader served the Iranian community as a way to get uncensored, unfiltered news outside of government control. And now, that may be over.

As explained by Amir on Amirhm.com, Google Reader is not a separate domain (i.e., it’s available at www.google.com/reader) and it’s available behind a secure URL beginning https. This setup makes it hard for the government to directly block and filter Reader, even though many other social services, including Twitter, Facebook, FriendFeed, YouTube, Tumblr, Flickr and Picasa, are routinely banned in Iran, a country that’s ranked as the world’s worst oppressor of online freedoms.

My own usage of Google Reader is mainly as a social network where I share and discuss articles (and, who am I kidding, gifs of Beyonce) with a small group of witty friends. And while I don't need Reader to access unfiltered news, it's really nice to have a relatively private place to share content with friends. In the last two months, my most frequent interaction with Google + has been reading the daily notifications that 10+ men I've never heard of have added me to one of their circles.

As one pal put it, "I don't want the creepy dudes who add me on Google Plus to know which celebrity gossip articles I am reading!"

I'm managing to console myself with the reminder that change and the internet go hand in hand, and it's entirely possible that G+ will make it easy to share and we'll all end up loving it more than anything else that's come before.

But if you still have a case of #firstworldproblems, there's going to be a Google Reader protest at the company's D.C. offices at 1101 New York Ave. NW tomorrow from 12:30 to 4:30 p.m. And while I don't quite get the point of protesting, the organizers explain it thus:

Google has decided – without any user consultation – to kill our beloved Google Reader, and force us all to use G+ in its stead. Without any of the functionality that made Reader so useful transferring over to make G+ work for us.

In doing so, they are destroying all the features that makes Google Reader so great, and destroying a thriving community of dedicated and loyal followers.

We are the demographic that Google needs the most, and we need to let them know what they are losing, and what changes they need to make to this plan to win us back.

Join us for this peaceful protest outside Google's DC Headquarters, and let our voice be heard.

n9w5n.jpg

2011-10-26T06:07:14Z

Shared by Jim
For Courtney!

InfoQ: Presentation: Simple Made Easy http://t.co/ysXznKHv

2011-10-26T03:40:51Z

Shared by sconover
Simplicity > testing. Simplicity > ability to reason through. Simplicity > agile.

If you bring to bear a tool that's easy to use, to make a big ball of mud, because it's easy, you've failed - you've failed in the most profound sense of failure. The failure is total and inescapable.

Taking time to make things simple in the face of economic pressures takes courage.

IOW if you write code then this talk is a must-watch.

InfoQ: Presentation: Simple Made Easy http://t.co/ysXznKHv

Slide Design for Developers

2011-10-24T07:00:00Z

So I gave this talk called How GitHub Uses GitHub to Build GitHub. Someone submitted my slides to Hacker News, where it stayed at #1 for most of the day.

This was pretty strange to me at first.

My slides are not designed for people who didn't see the talk in person. They're designed to support my words, not some online audience. What's more, many commented that they found the design of the slides to be noteworthy. I'm expressly not a designer.

Working on your slide design pays off for the audience in front of you and for the audience online reading your slides later. I learned a lot designing this talk, and I think it can be helpful for you, too.

Colors

Color is the very first thing people will notice. It should also be the very first thing you think about.

Head to a color site like Colour Lovers and find a palette you like. Pick colors with a lot of contrast- it gives you a lot of flexibility with text, backgrounds, and objects. In my GitHub talk, I have around four colors I use frequently, and 8-10 total (lighter green to augment a darker green, lighter blue for my dark blue, and so on).

Size

Make your text huge. And then get rid of half of the words and make it huger. Almost all of the presentations I've ever seen at every conference screws this up.

Most of my text in my entire deck is at least 90pt. Usually I like to sit around 150pt, with spikes up to 300pt or more. You cannot get large enough.

For the curious, I use Yanone Kaffeesatz as the typeface for both my slide deck and the headings on my blog.

One of my favorite tweets from my New Orleans talk said "Great slide design- I was way in the back and could read every single word!" Forget the people in front of you: design for people three rooms away from you.

Words as Shapes

I took one design class in college. One of the most fascinating assignments they gave us was a study of shape: you get one letter, in one typeface… do something with it. The idea was that the severe limitation forced you to be creative with duplication, rotation, scale, alignment, and whitespace. It opened my mind to a lot of possibilities I hadn't thought before. Letters themselves can be part of the design.

Slides give you the same opportunity. The easiest way to make your slides visually interesting is to play around with the physical shape of the letters that constitute the word. Line things up. Don't line things up. Shift things around. Worry about pixels. Almost every single slide in my talk is a different font size, since I want things to work off of previous words, lines, and so on. Text sizes of 94.5 points are not uncommon in my deck. They create a much more interesting visual than throwing a random bullet point on-screen.

Repetition

Humans love repetition. It's one of the tricks used in lots of disciplines. The best jazz soloists are capable of starting a melody, repeating it, and then playing with it after the audience has identified with the repetition. The best storytellers will repeat the same line throughout a story to build a sense of familiarity, of excitement. Slides are no different.

Steve Jobs did this often. Before moving onto the next product announcement, he'd spend thirty seconds and go over the same information he just presented. It's a very simple way of keeping things memorable for your audience. I make this explicit by giving recap sections big green stamps in the upper corner saying "RECAP". I also giving the start of each section of my talk bright orange backgrounds with colorful, bold text. Simple reiteration is important.

Simple reiteration is important.

Worry about it

A good set of slides won't magically make your talk great. But a great talk is really hurt by terrible slides. Spend some time thinking about your slides. Put yourself in your audience's shoes: is this readable? Is this interesting? Should I pay attention, or should I get my laptop out and hack until lunch?

I'm certainly not a designer, but it's really remarkable how little design you need to put yourself far ahead of most talks. Huge text. Consistent colors. Less words. Worry about those, and it will already put you far ahead of the pack.

littleidea: I predicted Groupon would crater before it was cool.

2011-10-25T02:21:38Z

littleidea: I predicted Groupon would crater before it was cool.

Farewell, Dear Reader

2011-10-24T23:30:08Z

My favorite social forum has been Google Reader for a good couple few years now. Honest discussion, silly trolling, and safe exploration have been its key features to me. I remember forcing myself to notice how seamlessly they integrated the comments feature, how it became an intrinsic part of my life easily in exactly the way puberty didn’t. We talked gender, culture, ideals, memes, and love. I saw romances unfold and collapse, revolutions half start and dissolve or evolve, friendships be shaken and cemented.

It was a safe place because I could say who had access to my shares and comments, but also see how “outsiders” interacted on the shares of dear friends. It was intellectual and thought-provoking because it was based on content, not social exchanges. It introduced people dear to my Tribe in a way that was based around shared ideals and interactive thoughts, not popularity or witticisms. And most of all, it was a way to normalize my friendships and emotional connection during constant travel. I always knew, no matter what timezone I was in, that someone had shared something, commented on someone else’s shares, and would have the consistency in character and access that geography and timezones made cognitively dissonent otherwise.

I’ve laughed at the persistent humor and intelligence of friends left in other geographies. I’ve seen and cherished the exploration and shift of gender, sexuality, and relationships of tender souls. I’ve learned about fashion and pleating and nails, things I never would have cared about but now find fascinating. I’ve trolled about Juggalos and claimed BUNK. This medium has allowed me the closeness of connection, the vulnerabilities, and the rejoicing that closely approximate real life. To someone whose “local” is geographically distributed, this has meant the world to me. It let me determine how public I was, and that is a rare and beautiful thing. And now, in yet one more place, my friendships and thoughts have become a commodity.

Apparently the same usability exists to people on G+, with some changes to make people “click” more instead of delving deep into the content, assessing, and responding. It’s more public, more based on how many followers you have. As someone who is fairly well-followed, I will be clear that the only way I can be as awesome as I am is because of my core group of dear friends. My dear friends who, as cristobat (of course a sharebro) says, “you don’t have to be cool around.” My dear friends who I can share a post about disaster response next to an image one of my kinks next to an article about cyborgs and their only response it to comment honestly about each in a way which honors, questions, and builds upon those aspects of my Self.

I can’t join G+ because I have an odd name, and risk losing acces to the other tools of theirs I use. Yes, they’re allowing pseudonyms soon, but there will be several weeks at least in the interim. Google, why are you succumbing to a broken system of “clickiness” instead of standing up for the very real, very dear exchanges that occur on your established tool? It’s like a city cutting taxes by removing the arts. Sure, it benefits a few people in the short term, but the long term societal effects are disastrous. I thought you would be better than that. I guess I was wrong. A strong and informed community would have been more beneficial to you in the long run than any capitalistic metrics of potential consumers ever would.

I uploaded screencaps of some of my favorite GReader exchanges. You have to be a friend on Flickr to see them, because they are sensitive. Ping me if you don’t have access and think you should. You can also see the Lexicon for an index of ways we’ve interacted and might one day interact again in the future.

Farewell, Dear Reader. It’s been great.

Why I Love and How I Use Google Reader

2011-10-24T16:46:00Z

TL;DR: How would you feel if Google announced they were cleaning up Gmail’s UI, and oh by the way, they’re also “retiring” some key features you use every day? I know, right?!? Now read this and imagine it said…

“Many of Gmail’s social features will soon be available via Google+, so in a week’s time we’ll be retiring things like replying, forwarding and filters inside of Gmail.”

You should sign the petition:

https://docs.google.com/spreadsheet/viewform?hl=en_US&formkey=dE16SFVla3JFZ1lwTkxGRWN2SkZtb2c6MA#gid=0

Why all the hubbub?

The comments at this TechCrunch article are pretty articulate
So is the intro to http://googlereaderlexicon.wikispaces.com
Francis Cleary breaks it all down in his Google+ post
Dolly said it all a year ago
And I think I do an OK job later in this post

Two post-apocalyptic communities have sprouted up:

CodeSOD: The Query of Despair

2011-10-24T13:00:00Z

Jeroen's colleague had the misfortune of being assigned to debug an intermittent, unspecified error in the one of the oldest of the legacy applications. "The good news is that I've isolated it to a database query," he told Jeroen, "the bad news is that I've isolated it to a database query."

Knowing that his colleague wasn't a big fan of databases, Jeroen offered his assistance. In response, he received the following image.

"I don't think anyone can help me," the his colleague wrote.

Anonymous takes down darknet child porn site on Tor network

2011-10-25T02:32:24Z

Shared by Alex Chaffee
"Anonymous’ hackers were able to exploit the PHP site with a SQL injection attack and extract the user database before launching a denial of service attack. “The server was using hardened PHP with escaping,” Anonymous said in its statement. “We were able to bypass it with with UTF-16 ASCII encoding.”"

By Sean Gallagher | Published 11 minutes ago

Pedophiles connecting to a concealed child pornography site got an unwelcome surprise last week, courtesy of the hacktivist group Anonymous. Lolita City, a child pornography site run on over a concealed “darknet,” has been taken down by Anonymous members, and account details of 1,589 users from the site’s database were posted as evidence.

The takedown is part of Anonymous’ Operation Darknet, an anti-child-pornography effort aimed at thwarting child pornographers operating on on the Tor network. Anonymous’ attack was focused on a hosting service called Freedom Hosting, which the group claims was the largest host of child pornography on Tor’s anonymized network. “By taking down Freedom Hosting, we are eliminating 40+ child pornography websites,” Anonymous claimed in its statement. “Among these is Lolita City, one of the largest child pornography websites to date, containing more than 100GB of child pornography.”

Based on a secure networking technology originally developed by the US Navy, Tor routes traffic through a collection of volunteer servers scattered across the Internet, making monitoring of what is being viewed or where communications are coming from difficult. The Tor network also hosts a private “dark” top-level domain, .onion (which is not an official TLD), via its Hidden Service Protocol; these sites are visible only to Tor users or those using a Tor gateway such as tor2web.org.

Because of its anonymity, Tor is widely used by individuals and groups seeking to communicate without being surveilled by authorities, employers, or eavesdroppers watching packets on public WiFi networks, as well as those wishing to visit websites anonymously without having their IP address recorded. According to the Tor Project’s own metrics, the service has recently been averaging over 400,000 users per day.

The Tor network was heavily used in Egypt earlier this year by dissidents to get around the Mubarak regime’s Internet shut-down, and is used by bloggers in Syria to communicate with the outside world. The network is also used by some who want to publish other sorts of material and conceal themselves from prying eyes, including pirated movie and software torrent publishers (which has made some Tor server providers the target of DMCA takedown notices). It's also attracted child pornographers and the pedophiles who are their customers.

However, as revealed last December, the anonymity offered by Tor isn’t foolproof. While the IP addresses of sites on the Tor network are concealed, they have a digital fingerprint that can be used to identify services hosted from a single location, and track visits to that site. And while it blocks some services that are typically used for denial of service attacks and other hacks within the Tor networks, such as UDP, .onion sites remain just as vulnerable to hacking as sites on the open Internet.

The Anonymous operation against Lolita City began on October 14, when members discovered links to child pornography on a .onion site called The Hidden Wiki. According to the group’s statement, Anonymous members removed the links, but they were reposted by a site administrator. Anonymous then moved to shut down the site with a denial of service attack. Additionally, the hackers matched the digital fingerprints of links on the site to Freedom Hosting. After sending a message demanding that the hosting service remove the content, Anonymous’ hackers were able to exploit the PHP site with a SQL injection attack and extract the user database before launching a denial of service attack. “The server was using hardened PHP with escaping,” Anonymous said in its statement. “We were able to bypass it with with UTF-16 ASCII encoding.”

Anonymous doxes Bank of America CEO

2011-10-25T00:48:00Z

Shared by Nick Novitski
I'm in favor of dox becoming common language.

Anonymous' “CabinCr3w” group has upped its information warfare efforts in support of the Occupy Wall Street movement by publishing the personal contact information of Bank of America CEO Brian Moynihan, including his personal phone number, on its Tumblr blog. Moynihan is just the latest target in an ongoing campaign to embarrass financial sector CEOs.

Last week, the group published the personal information of CitiGroup CEO Vikram S. Pandit (such as his wife’s name, his address and the value of his home, his personal cell phone number, and details of lawsuits he is listed as a defendant in), as well as those of Project Veritas’s James O’Keefe (including contact information for his probation officer). Other targets have included Goldman Sachs chairman Lloyd Blankfien. The CabinCr3w group of Anonymous has also been involved in the hacking activities targeting the Bay Area Rapid Transit District after BART shut down cell phone access to riders.

Last week, Anonymous hackers also leaked data from the International Association of Chiefs of Police, the Boston Police Patrolmen’s Association, and two Alabama law enforcement organizations as part of a protest against police brutality corresponding with the IACP’s annual conference in Chicago. Some of the data, including Social Security numbers, has been taken down.

Read the comments on this post

Steve Jobs and the Purpose of the Corporation

2011-10-12T16:46:00Z

In the torrent of commentary following Steve Jobs' death, few have noted that his career and his company say something profound in the endless debate about the purpose of the corporation. Apple existed to "delight customers" first — benefits to other stakeholders, including shareholders, followed.

For more than a quarter century, the mantra, of course, has been that corporations' primary focus should be on shareholders and the primary goal should be to "maximize shareholder value." The famous Michael Jensen and William Meckling article in 1976 argued that the solution to the principal-agency problem — business leaders advance their own interests not those of shareowners — was to make the goal of the corporation the highest return to shareholders and to align shareholders and business leaders through stock options grants.

Although many business people and business school professors would still say that maximizing shareholder value should be the goal of the corporation, there have also been many critics over the years. Among the questions they raise: shareholder value over what time frame? Does stock price accurately reflect intrinsic value? How does the concept help business people make critical trade-offs between short and long term or between competing, legitimate concerns of stakeholders — employees, suppliers, customers and shareowners?

One of the most recent and most trenchant critiques comes from Roger Martin, dean of the Rotman School of Management at the University of Toronto, in his book Fixing the Game (Harvard Business Review Press 2011). In essence, Martin argues that agency theory and the goal of maximizing "shareholder value" have had significant and harmful side effects. Pressures from institutional investors for stock price increases, as well as stock-based compensation for executives, have led many business leaders to manage to the "expectations market" of the public stock exchanges. This in turn has led to narrow short-termism, accounting manipulation, cutting of ethical and legal corners, failures to invest in the long-term, and to the financial crisis. (For my co-authored account of problems raised by the rising power, and new types of, institutional investors see "Are Institutional Investors Part of the Problem or Part of the Solution.")

Martin argues that, instead, the primary purpose of the corporation should be a return to management in the "real market," not the "expectations market," and that this means "customers are the focus, and the central task of companies is to find ever better ways of serving them." Martin's manifesto is: "We must shift the focus of companies back to the customer and away from shareholder value. In other words, we must turn our attention back to the real market and away from the expectations market. This shift necessitates a fundamental change in our prevailing theory of the firm." (Emphasis mine.) Martin cites Thomas Edison and Henry Ford as people who created customer value through "innovations in products, services and business models.

And, of course, Steve Jobs. Without repeating the hundreds of thousands of words written about Jobs and Apple since his death, there can be no question that his deep commitment was to make innovative, robust and beautiful products that delighted customers. He took the time necessary to meet his own exacting standards. He spent extra funds to ensure that the product was right (replacing plastic with glass on the iPhone, for example). He believed deeply in his own capacity to define new products that customers didn't even know they wanted, in the process overturning other real markets in, for example, personal computers, music, cell phones, tablet computing and animated movies.

At least in my view, there can also be no question that Jobs was not focused on shareholders or taking short-cuts or short-term actions to maximize shareholder value. Apple has paid no dividends since 1995. It hasn't used leverage. It holds $76 billion in cash with nary a thought of a buy-back. It is hard to argue that fundamental business decisions were driven by stock options (although there is the issue of options back-dating in the debit column).

Obviously, Apple shareholders have done just fine, with Apple and ExxonMobil today changing places back and forth as the U.S. company with the highest market cap. Yet this has been a long process of product design, introduction and success. Ten years ago, Apple was not even in the top 100 U.S. companies by market cap ($7B then; around $340B now). And dramatic increases have occurred in the last five years as the suite of Apple products gained popularity (with share price quadrupling in that period).

But this is at it should be. Those, like Roger Martin, who argue that the purpose of the company should be to create goods and services that serve important customer needs — and to do so with efficiency, risk management and integrity — would further say that the long term shareholder value will follow, as it has in Apple's case.

So, as people reflect on Steve Jobs' legacy, surely one fundamental issue should be his attitude toward corporate purpose — with his devotion to customers, not shareholders, and his ability to withstand short-term pressures in the name of product excellence. As he enters the pantheon of great business leaders, it is hard to argue against his vision of the purpose of the corporation, given his remarkable success in carrying it out. Future debates on this fundamental subject must put Jobs' conception at center stage.

Bad Timing

2011-10-24T04:35:57Z

A cow-orker of mine once bragged about the DateTime class he’d written. “It’s fantastic,” he said, “It handles dates from 10,000 BC to 10K AD, down to the millisecond. It does all the correct calendar conversions. It knows about September, 1752. We don’t have to worry about our time API now.” He left the company a couple months later, and we shipped and started getting bugs from customers.

Most of the features he’d written were great on paper, but he’d never written effective unit tests. The code had a bottleneck that funneled everything through Unix time functions. Nothing prior to 1970 worked, nor anything past the Day of Armageddon in 2038. There was code to handle leap years, but it failed every 100 years.

I rolled up my sleeves and got into it. It was surprisingly hard to get it right. I spent about two weeks writing unit tests and making the thing work as advertised. Our start-up had a really neat smart messaging protocol with date/time as a basic type — we figured that since so many of our customers were getting it wrong, that we’d get it right and leverage that as a feature.

Something about “Those whom the Gods destroy they first make proud,” right. This is a class of problem that everyone knows is trivial. “Of course I know how to do this,” you probably think to yourself, “This is trivial, I can just code this thing up and have an early lunch.” Trivial is the most dangerous word in all of computerdom, it’s a misprounciation of “Evil”. Your blood should run cold if you hear it spoken out loud, because the Gods will be listening carefully and taking notes on how to screw you if they ever hear you say it.

When you deal with time, you have a number of choices.

What is the range of times you handle? Computer-era scale? Human (historical) scale? Geologic scale? Ridiculous death of the universe ranges, when protons have decayed, all galaxy-sized black holes have utterly evaporated and even Twinkies have gone a little stale?
What resolution do you need? Particle accelerators probably need jillionths of femtoseconds, for instance. Computer-scale times are probably on the order of hundreds of nanoseconds. Human-perceptible and most real-time processing can be done in milliseconds. Geologists don’t give a shit about a stretch of time less than a hundred thousand years.
What about daylight savings time? Time zones? Leap seconds? All the people who get this stuff wrong in the real world?
Do you need the ability to compare times? (This becomes an issue when you deal with some other time formats, for instance OLE uses floating point numbers, days since some epoch, and fractions of a day, and so representing 10AM exactly is impossible).

That’s just time; we’re not even getting into “date” issues like calendars, or holidays. Holidays are serial nightmares on roller skates.

I believe that most programmers (including this one) do not really understand time. It gets worse, though, when you have to deal with a hardware clock that was designed by a hardware engineer who not only did not understand time, but also failed to devise a way to reliably extract it from the circuit he designed.

“You set the Freeze register and wait, then read the value.”

“How long do I wait?”

“Um . . . about, well, a while.”

“How long is a while, given that this is the hardware that’s supposed to be telling me how much time is passing?”

“I guess you can just delay or something.”

So one of us is going to Hell because we have to turn off interrupts and spin for half an eternity, just to find out what time it isn’t any more. That tick you were interested in? Sorry, it happened while we were busy waiting for some moron of a flip-flop to make up its mind. See you last year.

Recommended reading: Calendrical Calculations. This is a really great treatment of time and calendars, and if you are writing any code in this area you should definitely read the first few chapters and then crawl under a desk and quiver, wondering how anybody gets this stuff right, ever.

Oh, and personal to you-know-who-you-are: I hope you are writing some bloody unit tests now. Right? Okay?

Rounded Corners 296 – Don’t bother using git blame. It was you.

2011-10-24T02:15:03Z

Streaming Current state of Node.js WebSocket modules.

The Resque way Lots of good info about Resque.

UNIX power Oh, the cool things you can do with lsof.

Measure Metrics and you.

Go fast Speeding things up using Nginx and microcaching.

QotD Ricardo Mendes:

Ricardo’s Law: don’t bother using git blame. it was you.

"PNN" via Noreply in Google Reader

Notesdeck is a simple text editor for iOS and OS X that aims to...

Expansionwire: Multiplying burrito chain Chipotle has plans...

Shifting to the client again

Grace Hopper to Programmers: Mind Your Nanoseconds!

@DreeStewart Pivotal Tracker, mais c'est de la crotte ! les hipsters utilisent sprint.ly ! :D

An ode to running a database on bare metal

Modularized Association Methods in Rails 3.2

The Onion on Facebook

Using False Alarms to Disable Security

CloudFlare Builds ‘Stop Censorship’ App, Lets Sites Easily “Black Out” Against SOPA

Splunk and Chef

Yak Shaving

I heard you liked files

Taking a new device API for a spin

Wisdom of the Ancients

Meanwhile, 6th and Mission

Related Posts:

Velocity is Killing Agility!

'Free' Games Dominate Top-Grossing Game List On App Store

Using functional style in a Ruby webapp

On Programming Deadlines

Scala: Option.isDefined as the new null check

Starting in the Middle

Things That Turbo Pascal is Smaller Than

The Internet Archive

Links for October 30th

Metagames: Games About Games

Program Or Be Programmed

"As a service grows in popularity, alpha users outlive their usefulness. The core users that helped..."

Photo

Photo

E-PARASITE Bill: 'The End Of The Internet As We Know It'

Richard Stallman's list of requests when speaking

PROTECT IP Renamed E-PARASITES Act; Would Create The Great Firewall Of America

Rounded Corners 298 – Venn piagram

And the award for "Angry Birds-related Correction of the Year" goes to...

Francis Cleary - Google - Probably my biggest fear with moving from Reader to Plus is…

The World Is Surprisingly Angry About the End of Google Reader - Technology - The Atlantic Wire

Iran

The Sharebros

Google Reader Is Dying: Will You Cope By Protesting, Perhaps?

n9w5n.jpg

InfoQ: Presentation: Simple Made Easy http://t.co/ysXznKHv

Slide Design for Developers

Colors

Size

Words as Shapes

Repetition

Worry about it

littleidea: I predicted Groupon would crater before it was cool.

Farewell, Dear Reader

Why I Love and How I Use Google Reader

CodeSOD: The Query of Despair

Anonymous takes down darknet child porn site on Tor network

Anonymous doxes Bank of America CEO

Steve Jobs and the Purpose of the Corporation

Bad Timing

Rounded Corners 296 – Don’t bother using git blame. It was you.