[via Marc Goldberg]

Marc is pointing to an interesting presentation of Tim O’Reilly (PDF) at the last Eclipse conference. It is about Product Design and innovation in the web2.0 world.

Design for Participation

An open source operating system consists of “small pieces loosely joined.”
Discussion: Linux, Apache, Perl and CPAN
Therefore: Architect your software in such a
way that it can be used easily as a component of a larger system. Use a license that does not hinder such a combination. Keep your software modular, and make certain that you document all of the interfaces.

User-Centered Development

The benefits of open source come from sharing your development efforts and processes with your users
Therefore: Release early and release often. Set up mechanisms for users to submit bugs and patches. Promote your most active
users into roles of greater responsibility.

Don’t Differentiate on Features

When useful components are abundant and free, adding proprietary features will only slow you down.
Therefore: Focus your development efforts on speed of testing, assembly, and integration so that your users can always have the best components that the marketplace has to offer.

Follow Industry Standards

Users want choice, but not too much of it.
Therefore: Offer your products in a number of proven, industry-standard configurations, and let your users choose between them. As new application domains emerge, develop configurations to support them.

The Perpetual Beta

When devices and programs are connected to the internet, applications are no longer software artifacts, they are ongoing services.
Therefore: Do not package up new features into monolithic releases, but instead add them on a regular basis as part of the
normal user experience. Engage your users as real-time testers, and instrument the
service so that you know how people use the new features.

Leverage Commodity Economics

Scale matters. A successful internet service may need to scale up rapidly, at low cost.
Therefore: Use Linux, Apache, and other open source components running on commodity PC hardware as the basis for any internet service. Arrange these components in fault-tolerant arrays, with management tools that minimize the number of required sysadmins.

Users Add Value

The key to competitive advantage in internet applications is the extent to which users add their own data to that which you provide.
Therefore: Don’t restrict your “architecture of participation” to software development. Involve your users both implicitly and
explicitly in adding value to your application.

Network Effects by Default

Only a small percentage of users will go to the trouble of adding value to your application.
Therefore: Set inclusive defaults for aggregating user data as a side-effect of their use of the application.

The Long Tail

Many limiting factors from the physical world are absent from the internet.
Therefore: Use the power of the computer to monetize niches that formerly were too small to be commercial.

The Mechanical Turk

Services need to be robust, but because they are typically data-driven, they also need to be updated constantly.
Therefore: Build your core services infrastructure with traditional software components written in languages like Java,
C, and C++, but build your interfaces with templating systems and with dynamic
languages like Perl, Python, and PHP. Think of your programmers, designers, and
admins as part of the application.

Software Above the Level of a Single Device

The PC is no longer the only access device for internet applications, and applications that are limited to a single device are less valuable than those that are connected.
Therefore: Design your application from the get-go to integrate services across handheld devices, PCs, and internet servers.

Platforms and Tools (The Eclipse Pattern)

Third party developers are an essential part of the success of new platforms.
Therefore: Reduce complexity for developers by building tools that specifically support new classes of application, and use those
tools to simplify access to underlying components and services.

Intel Inside

Inside every open system there are proprietary, single-source components. The open PC architecture has Intel Inside; the open internet has Cisco Inside.
Therefore: Look for opportunities to be the single source for an essential subsystem of an open system.

Dual Licensing

The GPL allows special rights to the creator of the software to distribute the software under other terms.
Therefore: Make sure to obtain copyright assignment for all contributed code.

Data is the Next “Intel Inside”

Applications are increasingly data-driven.
Therefore: Owning a unique, hard-to-recreate source of data may lead to an Intel-style single-source competitive advantage.

Own the Namespace

Some data is a commodity and impossible for any one party to own, but access to the data can be controlled through legal means.
Therefore: If you can’t own the data, use legal means to own the namespace or
registry for the data.