I've started a new album. It is called squeakyshoecore. It is algorithmically generated acid using some software I wrote. I am going to release it online bit by bit, as I finish each track. I will announce each new track here on this blog.

The software makes two different beats and two complementary melodies using random number generators and some carefully tuned algorithms for using those random numbers. The melody shaping rules involve applying a low dimensional random fractal effect on very basic seed melodies, producing a type of self-similarity which seems to sound interesting to humans. The beats are created using a variety of custom rule sets, much like my previous work with algorithmic hip-hop in CanOfBeats and my algorithmic drum-and-bass generator, GhostWave.

After that I manually control how loud each of the parts are present in the mix, what effects are being applied to the different parts, and the parameter values of those effects. I use a midi controller to mix it in real time and record it.

Soon I will make the latest version of the Pure Data patches ("GarageAcidLab") available online under a Free Software license.

Enjoy the first tracks!

P.S. Some other music I've released on the net previously is Cryptolect, end-of-millenium style chopped-up breakbeats.

• The coffee tastes really good
• Free wifi
• Nice, agreeable, pleasant staff who leave you to your own devices
• Walking distance from Northbridge, Mount Lawley, and Perth
• The coffee tastes really good
• Coffee is slightly cheaper than most other places in Perth ($3.80)
• Organic, sustainable, fair-trade, and vegan friendly
• The coffee tastes really good

View Larger Map

I haven't tried their food, but it looks tasty and generally reviews well.

Here are some links:

• Google info page
• Source Foods Homepage

Be conservative in what you do; be liberal in what you accept from others.

-- Jon Postell

I wonder if there is a formal proof that it is an optimally efficient algorithm for interacting entities who don't completely know eachother's context/protocol, from the perspective of information theory?

This problem is solved by things like virtualenv and buildout, but I find that this will suffice for a lot of cases, or if you don't want to learn the ins and outs of those systems.

First, create a directory somewhere for your alternative Python libraries to go into:

$ mkdir ~/my-python-libraries/

You only have to do that step once.

Next, tell future Pythons that we have an alternative path where libraries live by setting an environment variable:

$ export PYTHONPATH=~/my-python-libraries/

This means that Python will check that directory for Python libraries when you try to import them. If you are always using that library path, you could put it in your .profile or .bashrc file so that it is set on login.

Now when you install new libraries, make sure they go into that alternative path:

$ cd some-library
$ python setup.py install --prefix=$PYTHONPATH --install-purelib=$PYTHONPATH --install-platlib=$PYTHONPATH --install-scripts=$PYTHONPATH/bin --install-data=$PYTHONPATH

One good thing to do is make a handy little one-line script which sets the PYTHONPATH variable when you want to start working on a project which needs those libraries. You could put it in ~/bin or in your project's root or scripts/ subdirectory.

You can also make a script in your ~/bin directory which runs the python setup.py command with those command line arguments set and call it something like "install-python-library".

update: More power-of-two fun at Frank's blog with Fast power-of-two modulo.

To find the nearest power of two (linearly) to a given number:

pow(2, int(log(n, 2) + 0.5))

To find the next highest power of two:

int(pow(2, ceil(log(n, 2))))

That's Python code, but pretty much applies in any language. There are some very fast log2 implementations out there if you need them.

Also, if you only have access to log10 in your programming environment (as I did when I worked that out), you might need this:

log2(n) = log10(n) / log10(2)

This is expressed generally as:

logX(n) = logY(n) / logY(X)

(Those two aren't Python code).

• Apple periodically come out with a single near-perfect product.

• Android products get incrementally better with each iteration from each phone company.

• Apple must make every product a hit - they can't afford failures like Apple TV. Failures are very expensive for Apple.

• Android allows Google to outsource failure. Infact, failures by the 3rd party companies who make Android phones actually help the evolution of other Android products as all products in that class can learn and benefit from the mistakes of eachother. This is like the transfer of genetic information. Failing phones are part of the survival of the fittest style of interaction that occurs in nature.

• Like the traditional Mac platform strategy, the iPhone strategy is about elite, expensive, "cool" devices with fantastic usability.

• The Android strategy is more like the PC platform of years past. It will result in a wide choice of generally uglier phones that don't work as well as the iPhone, but that slowly get better and better. Everyone will use them anyway, much to the confusion of die-hard Apple fans. This will be because market pressures will ensure that the cheapest phones of the highest quality, which give the user the most control and choice, will be the most popular. Often the most successful new designs will be copied from market leaders like Apple and other Android makers.

Evolution is dirty, ugly, and messy, but the end result is always more successful in a competitive ecosystem. It's interesting to consider which strategy will be more robust in the smartphone market.