Chris Swithinbank

Last se­mes­ter I as­sisted Hans Tutschku with a class called Music 264 at Har­vard Uni­ver­sity on im­pro­vi­sa­tion with elec­tron­ics, and we used Max as our main tool for stu­dents to build their own elec­tronic “in­stru­ments.” Faced with stu­dents rang­ing from Max be­gin­ners to more ex­pe­ri­enced pro­gram­mers, and want­ing to spend as much time as pos­si­ble mak­ing music, we needed a so­lu­tion that would allow us to teach Max and si­mul­ta­ne­ously start ex­plor­ing per­for­mance.

I wanted to write up some of our ex­pe­ri­ences, in par­tic­u­lar fo­cus­ing on a pack­age of Max patches I built for the class called 264 Tools.

Get­ting Max to make music

The com­mon ap­proach to Max-learn­ing of spend­ing time with the fa­mous tu­to­ri­als can be help­ful, but what to ac­tu­ally do with all this list pro­cess­ing, data type ex­pla­na­tions, and math­e­mat­ics can be less clear. It favours ab­stract thinkers and peo­ple with ex­ist­ing pro­gram­ming ex­pe­ri­ence, but may be less use­ful to some­one with­out that ex­pe­ri­ence who wants to start mak­ing music. Be­sides, there are im­por­tant rea­sons for not just send­ing some­one off to learn by them­selves or as­sum­ing prior knowl­edge.

Even if one is fa­mil­iar with Max, it takes time to build things that can start to be mu­si­cal and re­spon­sive. The process of mov­ing from some kind of con­troller input, han­dling that data, and map­ping it to some audio pro­cess­ing takes time. Build­ing a delay unit or even a ver­sa­tile sound file player takes time. It is pos­si­ble to teach this type of pro­gram­ming in a se­mes­ter, but prob­a­bly not in a class where you want much music to hap­pen.

By build­ing 264 Tools we tried to cir­cum­vent these chal­lenges for both new and more ad­vanced Max users. 264 Tools is a col­lec­tion of patches for Max that can be loaded in bpatcher mod­ules, pro­vid­ing ready-to-use play­back, pro­cess­ing, and analy­sis tools with graph­i­cal in­ter­faces. To any users who have played with BEAP, this will be a fa­mil­iar ap­proach — the dif­fer­ence being that where BEAP fo­cuses on sound syn­the­sis, the 264 Tools pro­vide ways of work­ing with recorded and live audio input.

These mod­ules don’t do any­thing par­tic­u­larly new on the in­side. Sev­eral rely heav­ily on amaz­ing ex­ist­ing work by mem­bers of the open-source com­mu­nity: Ivica Ico Bukvic, Ji-Sun Kim, Dan True­man, R. Luke DuBois (munger~); Patrick Delges (filesys); Randy Jones (yafr2); Miller Puck­ette, Cort Lippe, Ted Apel, Volker Böhm (sigmund~); Jean-François Charles (spec­tral freez­ing); Ro­drigo Con­stanzo, and raja (karma~). 264 Tools builds on these by pro­vid­ing graph­i­cal in­ter­faces and a con­sis­tent way of com­mu­ni­cat­ing be­tween mod­ules.

This is also not an at­tempt to build a “com­plete” suite of tools for all con­texts. There are some ob­vi­ous lim­i­ta­tions: we found it im­mensely prac­ti­cal to make every­thing mono, for ex­am­ple; and the GUI makes the mod­ules less per­for­mant than they might be. (If you have any Max GUI per­for­mance tips, let me know!)

Learn­ing by doing

The idea of teach­ing with 264 Tools was to have stu­dents spend as much time as pos­si­ble in­side Max it­self, and have that time as mu­si­cally fo­cused as pos­si­ble. They may not have mas­tered vexpr or fig­ured out all the ins and outs of poly~, and cer­tainly didn’t have to go through the pain of learn­ing how pattrstorage works, but they had Max open, were cre­at­ing and con­nect­ing ob­jects, and started to un­der­stand how one might ex­tend a mod­ule’s func­tion­al­ity by adding a few basic Max ob­jects. Most im­por­tantly, from the first week we were work­ing with sound. For peo­ple with back­grounds in music, the im­me­di­ate feed­back of hear­ing changes — rather than only un­der­stand­ing them ab­stractly — is very help­ful.

To keep stu­dents im­mersed in Max we ex­ploited the strengths of Max’s pack­age sys­tem.

In par­tic­u­lar, by using the extras di­rec­tory in the pack­age we could pro­vide weekly patches in­tro­duc­ing new mod­ules that would ap­pear in Max’s ‘Ex­tras’ menu. These overviews pro­vided ex­pla­na­tions of each mod­ule’s func­tion­al­ity along­side demon­stra­tions. Stu­dents could play with the demos and copy-paste bits of patch to their own pro­jects. (I’m cur­rently in the process of con­vert­ing much of this to proper help files.) As of v0.13.0, these have been con­verted to help and ref­er­ence files, so you can alt + click on a mod­ule and open its help file.

In our first week, 264 Tools con­sisted of a delay line, a sound file player, and a fil­ter. We added a cou­ple of mod­ules each week from then on.

As stu­dents built per­for­mance patches for class, it was as­ton­ish­ing to see the va­ri­ety of pos­si­bil­i­ties they un­cov­ered, even with a min­i­mum of mod­ules.

Be­yond the lap­top

The most ob­vi­ous re­quire­ment in order to make the stu­dents’ patches “per­formable” in im­pro­visatory con­texts was a con­troller that prob­a­bly wasn’t the lap­top’s track­pad or key­board. We ended up build­ing light­weight per­for­mance kits, and chose Korg nanoKON­TROL2 MIDI con­trollers for the stu­dents to in­ter­act with their patches. These pro­vide 8 faders, 8 dials, and 35 but­tons and send MIDI mes­sages over USB.

We built all 264 Tools mod­ules to work seam­lessly with any ex­ter­nal MIDI con­troller. You can quickly map a MIDI fader, dial, or but­ton to your patch using the 264.midi-learn sub­mod­ule, which is built into many of the 264 Tools.

Be­yond the MIDI con­troller, we also pro­vided stu­dents with a mi­cro­phone, a sin­gle-in­put audio in­ter­face, and a loud­speaker. It was great to be able to keep each per­former’s audio dis­crete using these per­for­mance kits, clar­i­fy­ing who was pro­duc­ing which sounds in group per­for­mances. This tied into a kind of “in­stru­men­tal” think­ing while de­vel­op­ing 264 Tools: mono sources, pro­cess­ing, and out­put lent them­selves to these multi-lap­top per­for­mances. We couldn’t have done this with­out the amaz­ing lo­gis­ti­cal sup­port of our stu­dio tech­ni­cal di­rec­tor Seth Tor­res. The per­for­mance kits he put to­gether were just per­fect.

Con­clu­sions

By the end of the se­mes­ter our stu­dents were able to per­form im­pro­vi­sa­tions, in some cases with no prior Max knowl­edge. While my teacher’s pride un­doubt­edly clouds my judge­ment, I was in­cred­i­bly im­pressed by their work. I can also say that a class­room of cap­tive beta testers, who are di­rectly im­pli­cated in the tool you’re build­ing, is an amaz­ing re­source to have. We fin­ished up with 22 mod­ules, from a MIDI-ready toggle to a pitch-tracker, and built a fairly easy to use pre­set sys­tem (I cursed pattrstorage so no-one else had to).

If you want to try out the tools for your­self, take a look at the in­stal­la­tion in­struc­tions. Please let me know if you find any bugs (or just have ques­tions).

I’d love to hear from any­one else teach­ing Max about their ex­pe­ri­ences, and if any­one does play around with 264 Tools, let me know what you think!