It hasn’t helped that Damien Katz, the original visionary developer of CouchDB, has been largely absent in the community since the CouchOne and MemBase merger. And that’s a shame - few know CouchDB better than him.

His blog post about the future of CouchBase comes as no surprise to anybody who followed the merger; CouchOne was funded by venture capital, and as such the owners will be pushing for a return - and there’s nothing wrong with following the money.

Relevance

An important goal is to keep interfaces in CouchDB simple enough that
creating compatible implementations on other platforms is feasible.

Despite that, I still think that Apache CouchDB is not only relevant, but indeed essential in the increasingly internet-connected world. The trend is for people to put their personal data into a corporate cloud, where it is sliced, diced and ultimately resold. For most users, there’s simply no alternative, and CouchDB is to my mind the best way to develop a peer-to-peer internet.

I’d like to see CouchDB as being the enabler in open data, in breaking open the web for joe & jane user, and enabling interoperability of large data sets especially in research and for government. And an independent replication protocol, with a reference implementation, well supported and documented, is critical to that end - even if the back end isn’t actually CouchDB.

Community and Commitment

The points made by both Mikeal and Damien, and others, are valid, however. CouchDB needs to have both focus and drive, to keep up its active current developer base, and to grow the user community. And it needs to happen this year or it will likely be too late.

Healing the Wounds

So where to from here? What’s really needed? The top IRC peeves are not too hard to address:

• Inability to install or build on common platforms such as Ubuntu, Debian
• Finding appropriate documentation across the wiki, API, and the out-of-date Definitive Guide

But clearly that’s not sufficient – in terms of restoring confidence, and increasing mind-share, things are not so straightforwards.

Fundamentally the Apache CouchDB community needs to get it together – to start demonstrating progress to the wider coder community, and do so in a way that articulates the project’s objectives, and restores faith that the Apache Incubator process really did create a community around the code, that can survive the clumsy departure of its inventor. Here’s a suggestion:

Communicate the Way Forwards:

• Have an objective - what’s Apache CouchDB all about? Why should I use it?
• An awe-inspiring Road Map, and a way for people to influence it
• Predictable and reliable release schedule

Make it easy to get started:

• Clean up the wiki and main landing page
• Pre-built binaries to help people get up and running quickly on common platforms like Debian and Ubuntu
• Closer links to package maintainers
• Bring the Definitive Guide up to date with current CouchDB functionality

Continue to Build the Community:

• Tell a story around the rich Couch eco-system
• Have a Propaganda Pack to help people evangelise Apache CouchDB
• Do a weekly update on what’s happening in CouchDB world

Interestingly enough, there’s not a lot of code required, but there is a fair bit required from the community.

This is a great opportunity for people who’d like to contribute, and who are keen to learn more about CouchDB along the way.

Are you joining me?

I developed glazier for two reasons, namely document the Erlang build process on newer compilers with a scripted installation, and to provide a reference build of CouchDB on Windows by including steps to build the required dependencies. A fringe benefit of this process is that I now have debug symbols (.pdb files) available for both Erlang and CouchDB, and can make use of the Microsoft tools for performance optimisation in future.

I’ve developed an AMI (virtual machine on Amazon’s EC2 infastructure) that encapsulates the entire build chain, and makes building CouchDB on Windows as easy as launching it and logging in.

Here’s how, assuming you’ve already got an EC2 account:

1. Contact me @davecottlehuber or dch on irc/#couchdb to get access to the AMI, as it’s currently a private build.
2. Log into the AWS console for the EU West region, and view available images - you should see something similar to ami-674d7313 listed.
3. Launch an instance - you have a choice between spot which is what I use for temporary development work such as generating and testing builds, or a normal instance where you can shut it down without losing your work. If you’re mainly compiling, then the m1.large is a good deal - 2 fast cores at your service. If you’re running CouchDB, then pick m2.large or greater, multiple cores so you get that Erlang SMP goodness. Make sure your security group has at least 5984, 6984, HTTP and HTTPS, and RDP enabled.
4. Once your instance has started up, connect over RDP & log in.
5. Optionally set up dropbox.
6. Start a SDK 7.1 x86 release console from the prompt.

1
2
3
4
5
6
7
8
9

pushd d:\relax\couchdb
git clean -fdx && git reset --hard
git checkout -t origin/1.2.0
shell
# pick reqd erlang, I'm using R15B now
cd /cygdrive/d/relax/couchdb
./bootstrap
couchdb_config_js185.sh
couchdb_build.sh

And that’s it. Do note that there’s not a lot of error checking in the couchdb_*.sh scripts so make sure you’ve checked the logs thoroughly.

Erlang

• bump wxWidgets 2.8.11 to 2.8.12
• revert OpenSSL 1.0.0e to 0.9.8r to align with OTP R15B release notes
• start using OTP/R15B from now on

CouchDB

• bump curl to 7.23.1
• bump ICU to 4.6.1
• use Mozilla SpiderMonkey 1.8.5

Feel free to try these out from snapshots.

There are several ways, so let’s try each of them.

First, and easiest, is to request a list of all documents in the DB, and then use xargs wget to pull the data down.

1
2
3
4
5
6
7
8
9

$ DB=http://localhost:5984/posts
$ curl --silent $DB/_all_docs |
    sed -nE 's/{"id":"([0-9]+)".*/\1/p'
21298063
21298065
...
31797293
66018817
$

Octopress, which is based on Jekyll, uses a mixture of YAML and markdown for pages and posts. We’ll use a show function, which passes a JSON document to a JavaScript transformation function, to build this up.

First, the posterous format includes a whole lot of stuff we won’t need. For OctoPress we want title, display_date,tags, and body_full only:

1
2
3
4
5
6
7
8
9
10
11

{
   "_id": "21298063",
   "_rev": "1-8ba11a44954e3171de4f4fa9d68c3210",
   "is_owned_by_current_user": true,
   "slug": "setting-up-a-shared-photo-library-in-picasa3",
   "tags": [
   ],
   "title": "setting up a shared photo library in Picasa3 on MacOS",
   "display_date": "2009/01/09 13:49:53 -0800",
   "body_full": "setting up a shared photo library for several...",
}

Assuming OctoPress can parse the date format, this will be easy. Let’s map these to title, date, categories, and content to build our YAML like this:

1
2
3
4
5
6
7
8

---
layout: post
title: "setting up a shared photo library in Picasa3 on MacOS"
date: 2009/01/09 13:49:53 -0800
comments: true
categories: []
---
... body_full goes here ...

The show function is pretty straightforward:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

function(doc, req) {
    if (doc.slug && doc.title && doc.display_date && doc.tags && doc.body_full) {
        return {
            body: '---\nlayout: post\n' +
              'title: "' + doc.title + '"\n' +
              'date: ' + doc.display_date + '\n' +
              'comments: true\n' +
              'categories: ' + doc.tags + '\n---\n',
            headers: {
                'Content-Type': 'application/text'
            }
        }
    }
}

Let’s walk through that line by line.

1. Declare the function, and therefore our scope.
2. First I check that all the entities we require are present. This avoids generating an expensive exception in the JavaScript engine if later on I try to access data that isn’t actually present.
3. return an object comprising the body content, and the headers
4. the body is built up from JSON properties of the supplied doc object.

That seems like a good start, so wrap that up into a design document, drop it into your CouchDB and test it out:

1
2
3
4
5
6
7
8
9

$  curl --silent --header "Content-Type: application/text" \
  http://localhost:5984/posts/_design/posts/_show/yaml/31797293
---
layout: post
title: "ubuntu saves the day"
date: 2010/10/28 04:25:37 -0700
comments: true
categories:
---

Notice how we needed to query using Content-Type: application/text? Try that same link in your browser. You’re prompted for a download that refers to the _id stored in CouchDB.

It would be nicer to get that with the correct markdown filename already. Let’s use doc.slug for the name, prefixed with the date of the original post. Octopress expects a yyyy-mm-dd format so I’ve sprinkled liberally with regex pixie dust.

Finally, an additional HTTP header Content-Disposition: attachment; filename=<file.ext> is required to provide the proposed name via our show function.

Now’s a good time to append the actual blog post content too.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

function(doc, req) {
    if (doc.slug && doc.title && doc.display_date && doc.tags && doc.body_full) {
        // Replace / with - and trim display_date to yyyy-mm-dd- only
        // to match the octopress expected post format.
        // This will be passed as an HTTP header and will be used by
        // browsers or wget as the proposed filename.
        var post_date = doc.display_date.replace(/\//g, '-').replace(/^([-0-9]+).+/, "$1");
        var post_name = 'attachment; filename=' + post_date + '-' + doc.slug + '.md';
        return {
            body: '---\nlayout: post\n' +
              'title: "' + doc.title + '"\n' +
              'date: ' + post_date + '\n' +
              'comments: true\n' +
              'categories: ' + doc.tags + '\n---\n' +
              doc.body_full + '\n',
            headers: {
                'Content-Type': 'application/text',
                'Content-Disposition': post_name
            }
        }
    }
}

I’ve put this into a separate show function, and this is what comes back:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

$ curl --silent --header "Content-Type: application/text" \
 http://localhost:5984/posts/_design/posts/_show/octo/31797293
* About to connect() to localhost port 5984 (#0)
*   Trying 127.0.0.1... connected
* Connected to localhost (127.0.0.1) port 5984 (#0)
> GET /posts/_design/posts/_show/octo/31797293 HTTP/1.1
> User-Agent: curl/7.21.4 (universal-apple-darwin11.0) libcurl/7.21.4 \
 OpenSSL/0.9.8r zlib/1.2.5
> Host: localhost:5984
> Accept: */*
> Content-Type: application/text
>
< HTTP/1.1 200 OK
< Vary: Accept
< Server: CouchDB/1.1.1 (Erlang OTP/R14B04)
< Etag: "6PML44SHRNE54M212K0O6BLXZ"
< Date: Thu, 22 Dec 2011 13:02:36 GMT
< Content-Type: application/text
< Content-Length: 1668
< Content-Disposition: attachment; filename=2010-10-28-ubuntu-saves-the-day.md
<
{ [data not shown]
* Connection #0 to host localhost left intact
* Closing connection #0
---
layout: post
title: "ubuntu saves the day"
date: 2010-10-28
comments: true
categories:
---
My work laptop had a BSOD today, which looks like it was caused by bit rot ...

$ wget http://localhost:5984/posts/_design/posts/_show/octo/31797293 \
  --content-disposition
Resolving localhost... 127.0.0.1, ::1, fe80::1
Connecting to localhost|127.0.0.1|:5984... connected.
HTTP request sent, awaiting response... 200 OK
Length: 1668 (1.6K) [application/text]
100%[======>] 1,668       --.-K/s   in 0s

2011-12-22 14:04:46 (79.5 MB/s) - `2010-10-28-ubuntu-saves-the-day.md' saved [1668/1668]

Now we can transform arbitrary Posterous blog entries via CouchDB into Markdown format. Next time, I’ll use CouchDB to pull all the data out in one swoop.

CouchDB’s bulk loading API requires JSON documents to be embedded in an array called docs within a parent JSON object that contains optional parameters to indicate to CouchDB how to handle the upload. Note that the _id value must be a string.

1
2
3
4
5
6
7

{
  "all_or_nothing": true,
  "docs": [
    {"_id": "1", ... },
    {"_id": "2", ... }
  ]
}

I’m going to use the all_or_nothing model and keep munging my data until it works in one go. You could just as easily keep removing documents that were successfully uploaded from your parent JSON object, which might be a better approach if I had a lot of data.

The Posterous data I retrieved last time delivers my posts as a single JSON array. Here’s a trimmed sample:

1
2
3
4
5
6
7
8
9
10
11

{
    "is_owned_by_current_user": true,
    "slug": "motorola-marketing-from-the-munchkin-wrangler",
    "body_excerpt": "motorola's cellphone naming looks to me like ...",
    "views_count": 77,
    "skip some text" : "...",
    "comments_count": 0,
    "current_member": "admin",
    "id": 21298071,
    "replies_count": 0
}

That id field looks like an ideal choice to map to CouchDB’s _id field. It’s not a string though, so we’ll need to quote the following value. As an old-school kinda guy, I did a perl one-liner. I am sure you node.js ninjas out there can do it in 20 lines of valid js with beautiful nested callbacks though.

The final step is to wrap the documents in the _bulk_docs format we saw initially - { "options" :..., "docs": [array]}, and then run it through jsonlint to confirm that Douglas Crockford is happy. No doubt it would look prettier in ruby.

1
2
3
4
5
6
7

$ perl -pi.dist -e 's/^    "id":\s+(\d+)/    "_id": "\1"/g' posts.json
$ perl -e \
  'print qq({\n    "all_or_nothing": true,\n    "docs":\n); \
  print <stdin>;
  print qq(}\n);' < posts.json > bulk_docs.json
$ jsonlint bulk_docs.json
input text encoding is utf-8

So let’s push this into a new CouchDB and see what happens. In the worst case, our upload will be rejected in its entirety and we’ll simply need to re-try with improved data.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

$ DB=http://admin:passwd@localhost:5984/posts
$ curly -X PUT $DB
{
   "ok" : true
}
$ curly -vX POST $DB/_bulk_docs -d @bulk_docs.json
* About to connect() to localhost port 5984 (#0)
*   Trying ::1... Connection refused
*   Trying 127.0.0.1... connected
* Connected to localhost (127.0.0.1) port 5984 (#0)
* Server auth using Basic with user 'admin'
> POST /posts/_bulk_docs HTTP/1.1
> Authorization: Basic d3ViOnd1Yg==
> User-Agent: curl/7.21.4 (universal-apple-darwin11.0) \
>    libcurl/7.21.4 OpenSSL/0.9.8r zlib/1.2.5
> Host: localhost:5984
> Accept: */*
> Content-Type: application/json
> Content-Length: 151723
> Expect: 100-continue
>
< HTTP/1.1 100 Continue
} [data not shown]
< HTTP/1.1 201 Created
< Server: CouchDB/1.1.1 (Erlang OTP/R14B04)
< Date: Sat, 17 Dec 2011 00:08:09 GMT
< Content-Type: text/plain;charset=utf-8
< Content-Length: 1222
< Cache-Control: must-revalidate
<
{ [data not shown]
* Connection #0 to host localhost left intact
* Closing connection #0
[
   {
      "rev" : "1-fe25f5fa414e78b90b08959ef6763972",
      "id" : "66018817"
   },
   { "trimmed": "..." },
   {
      "rev" : "1-f4ee768657f44f87b6774489ceca042f",
      "id" : "21298071"
   }
]

In the subsequent post, I’ll transform it using CouchDB’s show, view and list functions to load into octopress.

Log into Posterous and then open the API page. Use the first entry to obtain your API token. Put this, your login and password below and you should be able to obtain a list of your Posterous Sites, or Spaces as they’re now called.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$ curl --silent -vX GET --user you@domain.com:passwd \
  -d "api_token=your_API_token" http://posterous.com/api/2/sites

* Connected to posterous.com (184.106.20.99) port 80 (#0)
* Server auth using Basic with user 'you@domain.com'
> GET /api/2/sites HTTP/1.1
> Authorization: Basic BEEFDEADXNlLm5ldC5uejp3dWJ3dWI=
> User-Agent: curl/7.21.4 (universal-apple-darwin11.0) libcurl/7.21.4 \
        OpenSSL/0.9.8r zlib/1.2.5
> Host: posterous.com
> Accept: */*
> Content-Length: 42
> Content-Type: application/x-www-form-urlencoded
>
} [data not shown]
< HTTP/1.1 200 OK
< Server: nginx/0.7.65
< Date: Tue, 13 Dec 2011 00:49:49 GMT
< Content-Type: application/json; charset=utf-8
< Connection: close
< Status: 200 OK
< X-RateLimit-Limit: 1000000
<
{ [data not shown]
* Closing connection #0

Lovely. Now that will also provide you with some output, deep inside that is a site_id field - your site. I’ve conveniently relabelled this one as 1234567:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{
      "is_private" : false,
      "hostname" : "your_posterous_site_name",
      "readers_count" : 1,
      "admins_count" : 1,
      "full_hostname" : "your_posterous_site_name.posterous.com",
      "profile_image_35" :
        "http://files.posterous.com/user_profile_pics/1357443/dch_thumb.jpg",
      "admins" : [{
            "current_user_following_info" : null,
            "firstname" : "Dave",
            "nickname" : "dch",
            "site_id" : 1234567
        }]
}

Take that site_id and bung it into this curly command, and stash your posterous content to a file. Note how I use the pages=2 parameter to retrieve the subsequent page.

1
2
3
4
5
6

$ curl --silent -X GET --user user@domain.com:passwd -d \
  "api_token=DeaDBeeFDogFooducDdoG" \
  http://posterous.com/api/2/sites/1234567/posts > /tmp/posts1.json
$ curl --silent -X GET --user user@domain.com:passwd -d \
  "api_token=DeaDBeeFDogFooducDdoG" \
  http://posterous.com/api/2/sites/1234567/posts\?pages\=2 > /tmp/posts2.json

In particular, note the headers returned by cURL - this is a simple validation that we’re on the right page, and have recovered all the data. Great!

1
2
3
4
5
6

< X-Current-Page: 2
< X-Runtime: 29
< Content-Length: 148638
< X-Total-Entries: 31
< X-Per-Page: 20
< X-Total-Pages: 2

For bonus points, next time I’ll use CouchDB’s awesome powers to convert this back into octopress format.

1. overview
2. paging, dialogs, ajax and history
3. core UI elements - toolbars, buttons, lists, forms, grids
4. theming
5. the new jQM events and methods, and customisation
6. putting it all together by building a twitter app from scratch

There are some good quick tips thrown in throughout the book, bringing some practical experience to help newcomers, and a few bones for more experienced people as well. The first third (paging, dialogs, ajax and history) are straightforwards and anybody already familiar with HTML of any era, and basic jQuery syntax, should eat this up. At this point a basic jQM web app is easily within reach of most people, as the author provides plenty of examples with code and screenshots.

The latter stages of the book pick up the pace quickly, and requires more than a cursory understanding of HTML and Javascript/jQuery. A number of tips focus on the underlying event model & while this is of interest, it is also well covered on the official jQM website now. The author takes the docs further and shows how to integrate these models into useful code such as handling changed orientation, or enabling swiping to produce page transitions. He finishes up with a sample Twitter app, pulling what was covered in the book nicely.

Overall: If you are not a full-time mobile developer, or have intermediate HTML and Javascript, ideally jQuery, experience, this book will both get you started, and give you a head start on applying core mobile jQuery functionality. It’s a practical book representing good value at its price point, and seems to have survived the pre-1.0 changes in jQM well, and will be something I refer back to for a refresher each time I pull a new mobile app together. i This review was brought to you by the O’Reilly blogger programme.

It was a good opportunity to give ubuntu maverick a spinup before it goes on the big iMac at home as dual-boot. The install is slowly tweaked each time, and it’s really clean. I am pretty sure my mum could do this without any help now, and the fresh look is nice - it’s truly a class act OS.

One workaround was needed to resolve what is probably a stuck trackpad on the loan laptop; with a rmmod psmouse then it was all go. Everything works which really is an impressive step forward for Canonical, with strong OEM relations clearly now paying off. Hats off guys!

Anyway long story short, nautilus and brasero to the rescue, and I now have a bunch of md5 checksummed DVDs stashed before the hired goons come tomorrow to blow it away. I love the ntfs integration in linux, and the new maverick Ubuntu gets thumbs up all round - especially as it’s now got CouchDB 1.0.1 included - yay!

Building Erlang & CouchDB on Windows requires a custom build environment, which is very sensitive to path order amongst the three different compilers used to build wxWidgets, Erlang, JavaScript, and CouchDB.

This is further complicated by different install locations on 32 vs 64 bit windows versions, and which Microsoft C compiler and Windows SDKs are installed.

Each component is described via Makefiles in the Cygwin unix/posix emulation layer, and then handed over to the appropriate compiler to run.

Cygwin

The full Cygwin install comprises several GiB of data. Run setup.exe using defaults, optionally installing all components if you have the bandwidth, or alternatively with the following additional modules at a minimum:

• devel: ALL
• editors: vim
• utils: file

We’ll be using the new shell icon on a regular basis from here on in.

>Mozilla Build

• The mozilla build toolchain is needed solely for building our javascript engine.
• download it from mozilla and install per defaults.

>Microsoft Visual C++

Erlang and CouchDB can be built using the free VS2008 Express C++ edition from MSDN if you don`t already have a full VS2008 commercial released install. You’ll only need to install Visual C++ 9 only, to the default locations, either using the [DVD ISO](http://download.microsoft.com/download/E/8/E/E8EEB394-7F42-4963-A2D8-29559B738298/VS2008ExpressWithSP1ENUX1504728.iso”, or the smaller [msvc++webstart]. You can exclude the optional MSSSQL & Silverlight components. I’ve not tried compiling CouchDB + components using Visual Studio 2010 yet as the project file and build tool formats have changed again - but feel free to let me know if you get it working.

>Windows 7 SDK

The (free) windows 7 SDK is required, as the free VS2008 install is missing the message compiler. Download one of the following version per your requirements & install. - intel 32bit - amd64

Getting the environment right

After installing VC++ 2008 Express, there is a new batch file which correctly sets up the environment for you. "%vs90comntools%\..\..\vc\vcvarsall.bat" x86 will automatically find the correct path, and set up our 32-bit build environment correctly, independently if you have installed on 32 or 64bit windows. I set up a script to do this for me & then launch a cygwin shell directly:

Liquid error: ClassNotFound: no lexer for alias ‘cmd’ found In your new cygwin prompt look at your path echo $PATH | sed 's/:/\n/g' and check ther’s nothing missing or unexpected. In the next post, I’ll include getting Erlang/OTP set up ready for compilation<

    LESS=FSRX
    TERM=cygwin

If you are trying to install cygwin or similar tools on Windows 2008 R1SP2 Datacenter Edition, either 32 or 64-bit images, you’ll likely not even be able to complete the installation. bash dies regularly, the cygwin installer spits out errors faster than an uncapped BP oil well. This bug affects mozilla build tools, cygwin bash and other tools, such as the msys/mingw compiler as well. Apply the reg fix from KB956607, reboot and re-install any tools to ensure their final installation tweaks complete successfully. This still hasn’ been sufficient for me but I am getting further than before.

Corinna on the cygwin list has confirmed that this issue does not recur on a physical install - thanks! So this is either an EC2 tweak or a Xen bug. While I’ve not tested this, it is possible that the older AMD chipset Xen hosts will run successfully, vs the newer Intel x86_64 chips which don’t.

I will be following this up with Amazon.

Getting into CouchDB on Windows

So you just can’t wait to relax can you? The fastest route is just 4 easy steps to CouchDB zen:

Install the bits; 32-bit versions only

• install OpenSSL libraries to your system path
• unzip curl and add to your path
• run the latest couchapp installer
• sign up for beta cloud couch hosting to get your own couch ready to go

relax!

• read the quick start notes on using CouchApp
• for more info on CouchDB you can read the Definitive Guide
• or check out the wiki with more info on running CouchDB under Windows

1
2
3
4
5
6
7
8
9
10
11
12

FOLDER=common
GROUP=staff
mkdir $FOLDER
chown -R $USER $FOLDER
chown -R :$GROUP $FOLDER
chmod -R g+rw $FOLDER
chmod -RN $FOLDER
chmod -RI $FOLDER
chmod -R +a '$GROUP allow list,add_file,search,delete,\
  add_subdirectory,delete_child,file_inherit,directory_inherit' \
  $FOLDER
ls -lde $FOLDER

You can use the slightly more permissive ‘$GROUP allow list,add_file,search, \ delete,add_subdirectory,delete_child,readattr,writeattr,readextattr, \ writeextattr,readsecurity,file_inherit,directory_inherit’ which allows that group to change permissions and ACLs as well.

By explanation;

• chown -R :staff changes the standard unix group
• chmod -RN and -RI remove any inherited and initial ACLs; this is not needed for new folders but if you are converting an existing folder, this helps a lot to clean up crap
• chmod -R +a this is the permissions-mojo being applied
• ls -lde displays the extended permissions for a folder note that the ACLs must not have spaces in them if you are pasting code from above

Further reading:

• the manual
• sage uni
• ars technica
• ideo

1
2
3

brew install erlang
brew install icu4c
brew link icu4c

Then, to install CouchDB normally you’d just go ahead and brew install couchdb… and relax. But for a release it’s different; download the bits and:

1
2
3
4
5
6
7
8
9

cd /tmp
tar xvzf ~/Downloads/apache-couchdb-1.0.0.tar.gz
cd apache-couchdb-1.0.0.tar.gz
./configure --prefix=/tmp/couchdb
make
make check
make install
pushd /tmp/couchdb/bin
./couchdb &

Then go to the browser-based test suite to check its all good.

Key Apps

Transmission Komodo MailPlane KeePassX iTerm Aperture Firefox + jsonview + adblock plus + sync + firebug + about:config exportHTML=true QuickSilver Growl & GrowlTunes JungleDisk EyeTV vmWare Fusion Skype VLC Colloquy

Tweaks

• Deep Sleep
• enable disk-based hiberation with sudo pmset -a hibernatemode 1
• use to find out what slows things down use this: pmset -g log

Build Tools

• XCode no surprises here
• Install brew then sort out perl and gems
• brew install git, rsync, python
• use pip not easy_install

• Learning to Relax
• Advanced CouchDB
• as well as any videos by J Chris Anderson …

Finally two key couch resources are:

• the Definitive Guide to CouchDB - some of the sections (templates, building an app) are a little dated now due to version creep but it’s still a great book.
• the wiki
• not to mention the mailing list, as well as the #couchdb irc channel