My final project for my independent studies course in Jitter was to revisit a dance piece called “Hello World” that my wife, choreographer Jacque Bell, and I created back in October of 2012 for Repertory Dance Theatre here in Salt Lake City, Utah. (You can see an entry with still image and links to reviews here or another with a video of the performance here.) My major goal for this project was to explore the possibilities of Max/MSP/Jitter (with an emphasis on the latter…) for use in future dance and technology pieces, especially Dance Loops, the major project that Jacque, Nichole Ortega, and I are working on for this year and next.
I did two major things for this Jitter project:
Worked with several different visual effects within Jitter (as facilitated by the Vizzie modules); and
Experimented with using a hardware controller – a Korg nanoKONTROL2, in this case – to manipulate video in real time.
Overall, it was a lot of fun and I think there’s a lot of potential there. I’ll spend the next several months learning ways to work out the kinks in the patch, as not everything worked reliably, and learning how to use other hardware, such as my Kinects, Novation Launchpads, Akai APC40 and 20, KMI Softstep and QuNeo, as well as the projectors, etc. (That’s the nice thing about grant money – you can get some excellent gear!)
The major lesson is that it is much, much, much easier to do a lot of this in Max/MSP/Jitter than it is in Processing, which is what I have been using for the last two or three years. The programming is easier, the performance seems to be much smoother, and the hardware integration is way, way easier. (I find it curious, though, that there are hardly any books written about Max/MSP/Jitter, while there are at least a dozen fabulous books about Processing. Go figure.)
I’ve included a few still shots at the top of this post and a rather lengthy walk-through of the patch (where not much seems to be working right at the moment…) below.
In the spirit of the 20Objects lessons that I mentioned in the last post, Cycling ’74 also created (well, partially, in any case) a second series of tutorials called “20Concepts.” Perhaps the most important difference, aside from the fact that they’re not actually finished, is that they start not with the simplest object in the Max/MSP/Jitter universe – the button – but, instead, they start with one of the most complex – the Vizzie modules for video manipulations. Actually, I think it makes great sense, as it’s much more engaging to start with the big pictures. And, besides, the Vizzie modules are fun!
Here’s the complete list of (intended) tutorials in the 20Concepts curriculum:
20Concepts Curriculum Overview (Done)
01: Vizzie Part 1 (Done)
02: Vizzie Part 2 (Done)
03: Messages Part 1 (Done)
04: Messages Part 2 (Nonexistent)
07: More About Numbers
10: Presets and The Pattr Object
11: Audio Generation
12: Audio Filtering
13: Audio Levels
14: Audio FX
15: Jitter Input
16: Jitter FX
17: Jitter Compositing
18: OpenGL Part 1
19: OpenGL Part 2
20: Max Output
As with the 20Objects tutorials, these look like they might be short but, when you actually do all of the exercises, they are veeeery time-consuming. So far, I’ve only gotten through the first three, but they have been very, very helpful so far. I look forward to the rest!
Here are video walkthroughs of the lessons that I’ve done so far.
Cycling ’74 20Concepts, Lesson 00, 20Concepts Curriculum Overview; Lesson 01: Vizzie Part 1; Lesson 02: Vizzie Part 2, and Lesson 03: Messages Part 1 (13 exercises)
Lesson 04: Messages Part 2 is empty on the web page
Cycling ’74 has a fabulous set of tutorials under the rubric of “20Objects.” Unlike the 20Concepts curriculum, which starts very macro (with the Vizzie objects for video manipulation) but is ultimately incomplete, the lessons for 20Objects start at a very basic level (with the button object) and follow all the way through to Jitter objects. Here’s the complete list:
20Objects Curriculum Overview (Done)
01 – The Button Object (Done)
02 – The Number Box (Done)
03 – The Message Box (Done)
04 – The Pack Object
05 – The Metro Object
06 – The Random Object
07 – The Noteout Object
08 – The Patcher Object
09 – The Scale Object
10 – The Pattr Object
11 – The Table Object
12 – The Cycle~ Object
13 – The Buffer~ Object
14 – The SVF~ Object
15 – The Line~ Object
16 – The jit.qt.movie Object
17 – The jit.matrix Object
18 – The jit.brcosa Object
19 – The jit.xfade Object
20 – The jit.gl.render Object
It turns out that while these all look like short lessons, they’re rather time-consuming if you do all of the steps. As such, I only got through the first three of the 20 lessons (and the introduction) before I had to go work on something else. So far, they do extremely elementary things – this is a button, this is a number box – but I’m learning things I didn’t know and I’m better for it.
Cycling ’74 20Objects: Lesson 01, The Button Object; Lesson 02, The Number Box; Lesson 03, The Message Box; and Lesson 04, The Pack Object (60 exercises)
Well, I’ve finished VJ Manzo‘s book Max/MSP/Jitter for Music but, in the true academic fashion, it served mostly to let me know how much I don’t know. (And that’s a compliment, VJ!) And so I’ve decided to start working on the tutorials that Cycling ’74, the creators of Max/MSP/Jitter, have on their own website. I’m a linear kind of guy and I like to start at the very beginning, so I took at look at their “Quickstart” page on the fabulous Vizzie objects. Here’s my first take at what they offer.
The very last chapter of VJ Manzo‘s excellent book Max/MSP/Jitter for Music is a final exhibition of some of the applied work that can be done with Max/MSP/Jitter, as well as a few of VJ’s own compositions with Max/MSP/Jitter. As before, these don’t have much to do with Jitter, per se, but they’re at the end of the book so they’re listed under my Jitter course. More significantly, I got some wonderful inspiration on how I could make my own music. (I also got a very informal hearing test with the mosquito patch, and I’m glad to say that I hear high frequencies just fine, thank you very much.)
The book is done but I will be referring back to it very, very often as I start doing my own from-a-blank-patcher programming. (By the way, I also just bought a print copy of the book to go with my Kindle version.) In addition, I’m going to go through the plethora of tutorials that Cycling ’74 offers on their own website as a way to continue and expand my training. All of this is very, very exciting!
Max/MSP/Jitter for Music, Ch. 20: Compositions and Perceptions Tools (0 exercises)
Like the previous chapter, chapter 19, on “Informal Music Learning Instruments” is more of show-and-tell than hands-on. In this chapter, VJ Manzo shows how Max/MSP/Jitter can be used to create programs that greatly facilitate the exploration of musical concepts like harmony. In addition to this pedagogical goal, though, I also see application of a lot of these principles and patches to my own hoped-for work on live looping with my saxophone, especially as VJ’s patches might be good for harmonizing. Hmm… we’ll have to see later this summer.
Max/MSP/Jitter for Music, Ch. 19: Informal Music Learning Instruments (0 exercises)
This was an interesting chapter because it consisted almost entirely of a guided tour of one of VJ’s patches and not much in the way of person patching. That’s fine, though, because it was a complicated piece and the principles have/will come in handy in other work.
I find it especially interesting that the patch he develops can be used to gather times feedback on videos. If you recall, my day job is as a psychology professor and I have extensive training in experimental research methods. As such, this falls right in line with some of the things that I or my students could do. In that very practical sense, this was a very useful chapter.
Max/MSP/Jitter for Music, Ch. 18: Video Research Instrument (0 exercises)