A standard way of coming up with new ideas is to juxtapose
two existing well-known ideas to see how they could be
combined.  So suppose you're talking about bodies of
information, such as software (either running on your own
computer or accessed through the web).  What are the
software features I use day to day?

- a web browser (such as Firefox)
  - remembers what I'm doing
  - downloads data off the web
  - helps me store things on the web
  - renders HTML user interfaces
  - supports my customizations, like bookmarklets and
    Greasemonkey
- Google:
  - caches the web
  - indexes the web
  - computes trust metrics for web pages
  - performs boolean queries on large data sets
  - excerpts web pages to find the answers to my questions
- Emacs:
  - remembers what I'm doing
  - helps me make new versions of my files, or write things from
    scratch
  - automates common processes like feeding a source file to a
    compiler and finding the error in the source 
- LiveJournal:
  - aggregates streams of updates from various friends about
    their lives into a single stream
  - provides a single namespace to allow me to name the
    people I want to be able to see things I write
  - provides authentication services on that namespace
  - supports high-latency group conversations extending over
    days
  - hurts people's feelings
- Gaim:
  - displays my friends' status in real time
  - supports real-time one-to-one conversations
  - encrypts conversations and authenticates conversational
    partners to provide privacy (with OTR)
- AIM or Yahoo! Messenger
  - provides a single namespace to allow me to name people I
    want to talk to
  - ferries messages back and forth between us
- del.icio.us
  - remembers what I've read and tags it so I can find it
    again
  - tells me what people I know have been reading
  - remembers and collates people's annotations of external
    web sites
- IRC
  - supports real-time group conversations extending over
    years, either public or private
  - hurts people's feelings
  - integrates the functions of the world's largest
    distributed systems with one-to-many pub-sub messaging
- Twisted Python
  - provides easy programmatic access to many network protocols
  - supports concurrent programming
- apt
  - tells me about pieces of software
  - installs software with very little effort, including its
    dependencies
  - upgrades software to newer versions
- ls
  - lists pieces of information with their titles, ordered
    by name, date, or size
- eBay
  - categorizes products
  - authenticates people
  - remembers reputations
  - searches product listings
  - mediates auctions
  - gets me used products cheap
  - turns my old stuff into money
  - gives me market prices for goods
- grep
  - evaluates queries on large unindexed collections of records
  - searches large collections for keywords
  - returns context around keyword uses
  - determines whether something simple is true of a piece
    of data
- icewm
  - rearranges my screen at my whim
  - keeps track of tasks I'm working on
  - merges output from many programs
  - quickly switches between current tasks with alt-tab
- craigslist
  - remembers classified ads classified by geography and type
  - displays them by recency
  - gets me used products cheap
  - turns my old stuff into money
- dict.org
  - gives me word definitions
- WordPress/Movable Type
  - displays recent articles
  - supports high-latency public conversations lasting days
  - archives articles at stable URLs to facilitate later
    comments and links
- DNS
  - makes physical location invisible
  - provides worldwide global transparently distributed
    read-only database
- Linux
  - isolates misbehaving programs from each other
  - isolates misbehaving users from each other
  - interfaces with innumerable hardware devices
  - provides resource sharing for mutually untrusting
    parties
- gs
  - runs untrusted PostScript programs in relative isolation
    from the rest of the world
  - provides sensible API for drawing device-independent
    graphics
  - displays existing documents
  - transforms existing documents between formats
- iwconfig
  - tells me about my local wireless network
  - reconfigures my wireless hardware to attach to that
    network
- LinkedIn
  - lets me check my friends' resumes
  - reminds me of my friends' existence
- squeak
  - runs Smalltalk code
  - supports interactive experimentation with UI elements
- Snikisniki
  - contains and queries heterogeneous semistructured data
    expressed as RDF-like triples
  - supports easy user editing of that data
- CVS
  - maintains multiple versions of a file
  - allows multiple copies of a file to be eventually
    synchronized when the time is right
  - remembers history of a file, so you can tell who wrote
    which parts, and when
- WikiPedia
  - contains a summary of the world's important knowledge
  - lets me search that knowledge
  - lets me add to that knowledge, esp. by correcting it
- Google Maps
  - displays maps
  - displays satellite (and aerial?) photography of the
    world
  - supports search by address
  - supports display of satellite photography by location
- SpamAssassin
  - examines incoming mail to guess whether it's spam
  - evaluates a user-defined set of rules on the mail to
    make this guess
- nopaste
  - makes chunks of text URL-addressable to support IRC
    conversations
  - announces new text chunk URLs and titles in IRC
- URL shortener (makeashorterlink or csua.org/u)
  - makes long URLs addressable by shorter URLs, supporting
    conversations in media that don't support long URLs well
  - tracks popularity of URLs
- Flickr
  - stores photos
  - categorizes photos in customizable ways
- the Python interpreter
  - supports interactive experimentation with OO design and
    algorithms
  - lets me write simple programs very easily, then scale
    them to enormous ones
- pushd/popd
  - quickly switches between filesystem locations
- BGP
  - routes packets to their desired destinations quickly by
    means of interpersonal trust relationships and social
    sanctions for broken trust
- gprof
  - tells me why things are slow
  - lets me view software execution in a different way to
    provoke different insights
- Creative Commons
  - expresses permission to use, copy, modify, and
    redistribute information
- Postfix
  - safely stores incoming mail messages so I can read them
  - interfaces with other message sources and sinks on the
    network
  - queues outgoing messages so they don't kill my machine
- units
  - remembers the definitions of different units of
    measurement
  - converts between different units of measurement
- bc or my DHTML calculator
  - calculates with numbers
- orkut
  - reminds me of the existence of my friends
  - reminds me of which friends know one another
  - hurts people's feelings
- Pipermail
  - turns email into web pages
  - permanently records email
  - makes email browsable
- xwd
  - permanently records what I'm seeing on my screen at the
    moment
- Lotus Agenda
  - organizes index-card-like items in an ad-hoc fashion
  - allows me to program pattern-action rules very easily
  - automatically classifies short bits of text
    heuristically
- pobox
  - provides a stable URL and email address for me
  - filters my mail for spam
  - forwards my mail to the location where I presently read
    and store it
- Bugzilla
  - tracks current and future action items
  - supports very slow ad-hoc conversations lasting years,
    typically about particular software features
- ifconfig
  - reconfigures my network
  - gives me network usage statistics
  - tells me about my network environment
- Wiki
  - supports very rapid hypertext creation
  - lets me edit, annotate, and correct anything I read
  - shares my edits with others
  - remembers old versions of Wiki pages
- Babelfish
  - translates text from one language to another, poorly,
    but often well enough to enable communication
- procmail
  - applies pattern-action rules I write to my incoming
    email
- gcc
  - generates fast machine-code versions of programs
  - checks programs for machine-detectable errors
- PHP
  - lets me insert little bits of on-the-fly-generated stuff
    into web pages
  - lets me easily glue together a bunch of C libraries into
    a web interface
  - supports rapid application development
  - supports easy code deployment
  - isolates mutually untrusting users from each other
- tcpdump
  - tells me about my network environment
  - lets me look at my software at a lower level of
    abstraction in order to debug it or understand its
    performance
- Technorati
  - searches recent blog posts with keywords
  - finds blog posts that link to a certain URL
  - computes trust metrics over blogs
- nmap
  - tells me about my network environment
  - lists inputs and outputs of large systems
- BitTorrent
  - rapidly transfers popular files to many people 
  - reduces the cost of publishing by five orders of
    magnitude
- top
  - lists running processes
  - explains why my computer is slow
  - helps me make my computer not slow

So suppose I crossed some of these two?
- iwconfig and xwd
  - permanently records my current wireless network setup so
    I can restore it later, or send it to someone else so
    they can connect to the same network
  - or prints statistics about what I'm seeing on the screen

- PHP and BGP
  - lets me insert little bits of on-the-fly-generated stuff
    into routing tables
  - or, let web pages advertise the services they can
    provide, and an easy way to glue a bunch of the services
    together to make an integrated service
  - or, use interpersonal trust relationships and social
    sanctions for broken trust to let a large number of
    people update code that runs on my web pages

- Technorati and Linux
  - isolates misbehaving blogs from each other
  - or, interfaces with innumerable blog backends
  - or, interfaces with innumerable search backends
  - or, computes trust metrics over hardware drivers
  - or, provides resource sharing for blogs (Technorati
    already does this, eh?)

- WikiPedia and gprof
  - summarizes why all the software in the world is slow
  - or lets me view collaborative authoring in a different
    way to provoke different insights
  - or lets me search histories of past program execution to
    see if it was really faster last time, and when it
    changed
  - or provides hooks into programs to let me search their
    execution patterns and add pattern-action rules to them

- nmap and nopaste
  - makes information about my network environment
    URL-addressable to support IRC conversations
  - or announces new network environments, open ports,
    etc. on IRC

- BitTorrent and LinkedIn
  - rapidly transfers popular files to people I trust
  - or reminds me of the existence of files I care about
    (maybe new podcasts?)
  - or reduces the cost of keeping in touch by orders of
    magnitude?  Not sure how to do that.

- BitTorrent and xwd
  - rapidly transfers what I'm seeing on my screen at the
    moment to a bunch of other people all at once --- a sort
    of videoconferencing system

- ifconfig and Google
  - remembers previous network configurations and lets me
    search them
  - or computes trust metrics for my network environment (to
    turn on or off unencrypted/unauthenticated services)
  - or performs queries on large collections of network
    configuration information (to find misconfigured or
    similar nodes?)
  - or gives me statistics about the web

- Babelfish and squeak
  - a compiler: translates code from one programming
    language to another well enough that it can be run.  Or
    perhaps even read and edited.
  - or, something that supports interactive experimentation
    with phrasing in an unfamiliar natural language

- LinkedIn and dict.org
  - reminds me of the existence of words (a la word of the day),
  - or shows me the "resume" of words --- their uses
    throughout the literary canon of the language in question,
  - or gives me more information about the companies, jobs,
    skills, etc., on people's resumes.

- PHP and Flickr
  - lets me insert little bits of on-the-fly-generated stuff
    into images,
  - or categorizes bits of code in customizable ways,
  - or supports easy photo deployment

- Lotus Agenda and IRC
  - heuristically organizes chat-lines into topics of
    conversation,
  - or supports very simple pattern-action rules on chat
    lines,
  - or allows people to organize chat-lines into topics of
    conversation very easily,
  - or hurts people's feelings in a very organized fashion,
  - or is just like Agenda, only accessible in real time
    over a network.

- bc or my DHTML calculator and top
  - lets me conveniently make calculations starting from
    performance numbers (e.g. the sum of the memory usage of
    several processes)
  - displays a bunch of numbers computed by data that
    changes in real-time, according to user-specified
    formulas, and allows me to keep them sorted however I
    want

- CVS and Wiki (CVWiki's been around for a long time, I
    guess, but...)
  - merges changes to a Wiki page made by multiple
    contributors, or
  - lets me keep a local version of a Wiki offline

- URL shortener (makeashorterlink or csua.org/u) and BitTorrent
  - turns any file accessible by URL into a torrent, or
  - precaches popular URLs on your computer

- URL shortener (makeashorterlink or csua.org/u) and IRC
  - an IRC bot that shortens URLs --- done this already; or
  - hurts people's feelings more conveniently, or
  - makes previous lines of IRC chat accessible by short IDs
    (like perplog --- I guess someone did that already too),
    or
  - tracks popularity of chatters

- AIM or Yahoo! Messenger and Bugzilla
  - provides a single namespace for all bugs --- well, maybe
    that's the URL namespace;
  - or provides a real-time chat channel for each bug;
  - or provides an interface to create new bugs simply by IMing
    the bug tracking system;
  - or the bug tracker IMs you when a bug you care about is
    fixed, or when you're assigned a new bug.  At least if
    it's really urgent.

- Babelfish and icewm
  - translates text in place on my screen in any two
    applications between human languages

- icewm and Bugzilla
  - keeps track of windows I plan to open to get something
    done soon;
  - or lets me create, delete, reprioritize, and merge bugs
    with a few keystrokes.

- Linux and icewm
  - isolates misbehaving programs from each other;
  - or rearranges my resource allocation at my whim;
  - or keeps track of tasks I've asked the system to do for
    me, running them in a queued fashion

- nopaste and tcpdump
  - makes captured packets and connections URL-addressable
    to support conversations about them;
  - or announces new "interesting" network events in IRC

- Creative Commons and eBay
  - categorizes freely-redistributable information and
    tracks the reputations of its creators;
  - or authenticates copyright holders, or those who claim
    to be copyright holders, and allows other people to
    publicly dispute their claims of authorship;
  - or searches freely-redistributable information;
  - or just does online auctions without being butt-ugly and
    a half.

- Postfix and Flickr
  - safely stores incoming photos so I can view them or
    forward them to others;
  - or categorizes email messages in customizable ways;
  - or interfaces with other photo sources and sinks on the
    network so I can use a single unified photo-viewing web
    site.

- Wiki and Google Maps
  - supports very rapid map creation;
  - or lets me edit, annotate, and correct any map I read;
  - or supports geographical (or at least geometrical) data
    embedded in a Wiki;
  - or remembers old versions of satellite photography of
    the world.

The random combining in this essay was done with this
program:

#!/usr/bin/python
import sys, re, random

def items(infile):
    curitem = None
    for line in infile:
        if line.startswith('- '):
            if curitem is not None: yield curitem
            curitem = line
        elif line == '\n':
            if curitem is not None: yield curitem
            curitem = None
        elif curitem:
            curitem += line

def randpair(some_items):
    ii = random.randrange(len(some_items))
    jj = ii
    while jj == ii: jj = random.randrange(len(some_items))
    return some_items[ii], some_items[jj]

if __name__ == '__main__': 
    print ''.join(randpair(list(items(file(sys.argv[1])))))

Many thanks to Matthew O'Connor for the ideas of his I've
incorporated above.

Reply via email to