So a second additing to the auto updating Tumblr is now live.

Cuttr is written in scala and will apply randomised (but hopefully interesting) mathematically defined processes to the RGB values of an image.

Usual, found on Tumblr, shown on Tumblr rules apply.

I’m planning on adding a few more glitching possibilities to it but the early results are already pretty promising. Much of the time with this was actually spend wrestling with the OAuth stuff, made significantly easier due to the Scribe library. Also, I still don’t quite get reading of binary data in Scala. Should be easy, but never seems to be.

Anyway enjoy the results

In the past couple of months I’ve found I’m drifting away from my usual audio hacking and concentrating more on just programming for the sake of programming. Speculation leads me to believe this is down to me having a chance to learn a bunch of cool new stuff and generally just wanting to be a better software engineer. This is just a quick roundup of what I’ve been up to and the projects I’ve been creating.

Diddy-VM

This is just a really basic Virtual Machine I wrote because I’ve not written one before. Eleven instructions, very basic memory model, no stack or registers and both Python and C implementations. I’ve written a simple assembler program so writing code for it can be done more easily but it’s really very limited. Did the job as a learning exercise though.

dotfiles

Not really a programming project, but I’ve started having an active go at improving my workflow and an important part of that was to sort out a good bash environment. Having it on github means I can easily share it between home, work and any remote servers and I can keep track of what I’m testing out with it.

Cuttr

Having gotten Glitchr working I decided to have a go at using Scala for some image processing. Cuttr will (once it’s all finished) allow you do define mathematical functions and apply them to the image, either as a whole or as separate colour layers. It started with the idea being just to algorithmically cut them up but extended somewhat once I realised how simple it was.

Mandelbrot

Every programmer should be able to render a Mandelbrot fractal, this is mine. Written in C, using SDL to display it and allows zooming and outputting to PNG. The code is actually reasonably neat as well!

notes.txt

Based along the same lines as the very minimal and very cool todo.txt, this is a tiny command line app written in bash that allows me to quickly take notes. It’s pretty much functioning at the moment but I’m wanting to extend it with the ability to upload the notes to Evernote as well, once I’ve figured out what the hell their API is doing.

So that’s some of what’s been consuming my time recently, there are a handful of other smaller projects but none are in the sort of state where they’re of much interest. I do have some plans to start some SDL + OpenGL graphical experiments but there’s a bunch of maths I need to relearn first. Better get my nose in some good books.

So after having succesfully migrated my main Wordpress over to Octopress I’m not in the process of changing the PatchWerk Radio site to use a jekyll based site hosted on github. having a full blog for it was a bit overkill and really it’s just a handful of static pages.

I started with Jekyll Bootstrap and then created my own theme for it that essentially mimics the old look of the PatchWerk site. A few moments of confusion as to how to use liquid tags but it’s all up and running now. The new site is up at http://rumblesan.com/PatchWerk-Radio/ and hopefully it will use the old http://patchwerk.rumblesan.com domain as soon as I have the DNS settings all sorted.

The Author, Patch and Currently Playing info will all also be available with the plan being to create an api on the server that can deal with JSONP. Gives me an excuse to learn something new.

A little while ago I wrote a python script that opened up JPEG files, parsed the binary data, messed around with it a bit and gave you back some really interestingly glitched images. I’d intended to do some other things with it but it just got put on the back burner.

I resurrected it about a week ago and thanks to Michael Helmick’s TumblPy library I’ve now got it pulling images from and then re-uploading to Tumblr.

You can check out the images at rumblesan.tumblr.com and the project site is at rumblesan.com/glitchr

I want to improve the way the glitching happens at the moment. Currently it’s just the quantization tables that get played with but there’s plenty of other things that can be done. Also it tends to be quite aggresive glitching and I’d like to make it a bit subtler.

Something to play with either way. At least now it’s running it’ll be easier to mess around with

So a short, quick post about customising my octopress install. As has been pointed out in a few places on the internet, Octopress is great but people have a tendancy to keep the defaults once they’ve got everything running. Whilst it’s a really good theme, it’s not that great if your blog looks like everybody elses.

So using a base custom colors.scss file from Zachary Maril and a style.scss file from Alessandro Melandri I was able to rejig Rumblesan into something a little different. Pobablly a few things that need further tweaking, but it’s looking good already.

There’s been a bit of a change to the site, which hopefully people will have noticed. I’m now using the excellent Octopress and hosting everything on github. The comments have been moved over to Disqus and should all be migrated soon.

What this means for me is that

• I don’t pay dreamhost for my hosting
• It’s easier to integrate stuff from github
• I get to write all my posts in markdown
• I get to use Vim for everything

In other words, good times. There’s still a few things I need to sort out but hopefully I’ll have them done in the next couple of days.

Moving house is potentially a lot of hassle and effort, but usually alright. Except when you weren’t organised enough to sort out the internet before you moved in….. Then it becomes a serious inconvenience.

Everything will get sorted in a week or so but updates may be even more sporadic than they have been.

The good news is that I’ve thought of something new to keep me busy and entertained with Pure Data. More on that in a week

Hey, just a small post, coding some PD and realised that the small snippet I just made to select a random element from a list may well be useful for some people. I think I might start doing more small, code snippet type posts because they’re quick and easy to do.

So the section on the right, after the first trigger, takes the list length then calculates a random number between 0 and length 1. The list goes to the split which will send the first section of the split out the left inlet, and the latter section out the middle inlet. This middle output list will have a random element at the beginning so we just trim that off with another split.

So Processing.JS is pretty cool, this much we know. GitHub is also pretty cool, I don’t think anybody is going to deny that either.

It turns out that the two work really, really well together and because of this I decided to throw up a gallery of my Processing.JS sketches that’s hosted using githubs pages.

Check it out here http://rumblesan.github.com/ProcessingJS-Gallery/

So I got an interesting couple of questions in the comments for the last post. Many thanks to Joe for asking some good questions, as well as giving me a reason to get off my arse and write something. I’ll repeat it here for everyones ease.

Hi

I actually came across your blog/web page via various discussions on the Pure Data forum, which naturally I followed up and enjoy reading. However, I noticed in one of your earlier posts (on your own blog) the mention of SuperCollider. Naturally, since I came from the Pure Data forum, I’m a PD fan, like many out there. But reading your remarks about SC I’m interested to ask what is the difference between the two programs? Is it worthwhile (a personal choice of course) looking into both programs, or in fact is one enough and it’s all a matter of interfaces?

Oddly enough I notice that you do your ‘models’ in PD, probably because it’s freely available, or is that not correct.

Thanks for the posts, I’m trying to hang in there, but since there’s no real order easy to complicated etc I often find myself out of my own depth. I also have to say I sometimes try to understand the importance of certain ideas in connection with the results. But in the final picture who cares, it’s very interesting and I’m learning as I read your posts.

Thanks in advance.

Joe

I wrote a reply back in the comments but I think it’s worth expanding on some of these questions with a bit more space to talk. Also on Thursday night at the London Hackspace I got to hear two members of the Birmingham Laptop Ensemble (BiLE) give a talk about the work they did and their thoughts on working with SuperCollider.

So, what do I feel the differences between SC and PD/Max are and why have I gone down the visual patching route.

Essentially, it does just boil down to being typed code versus visually patched code. Both have their strengths and weaknesses but really for me it’s just that I prefer the do audio work in a visual language. I generally think that it can be much easier to see the flow of data through a patch, especially if you’re not a programmer which is why I think that Pure Data has a much nicer learning curve that SuperCollider. That said, if you find yourself wanting to do anything involving dynamic object creation or needing large banks of voices then SC does make it much just because it is written code.

My advice? Try both. and as many other programs as you can. They’re all good for something and ultimately, it’s more about work flow than anything else in my opinion.

So as to why I do everything in PD and not Max/MSP, partly, yes the cost is one reason. Not because I don’t think that Max is worth it because it really is, more just because I want to make the barrier for entry as low as possible.

The other reason is that I believe that there’s less happening in PD, so the learning curve is again that bit shallower. You’ll generally find yourself having to build abstractions for things that come as built in objects in Max but I think it’s an advantage in some ways. The less objects you have to remember, the quicker you can get going and if you need something regularly then it’s good practise to turn it into an abstraction.

I always liken the PD to Max view as being similar to C vs C++. PD and C are like a subset of Max and C++, they’re more minimal, require more building and aren’t as nice looking, but the language itself is pretty small and very versatile.

Make of that what you will.