Diaspora is an attempt to build a social network that contrasts with the locked-garden vision of Facebook, one built on open source software, open exchange of information, and distributed – rather than centralized – communication. I already let slip that we’ll be rebooting our own social endeavor, Create Digital Noise, in the new year. But it’s also telling to see the first noises emerge on Diaspora.

If you wrote off this service when it was in early testing, perhaps overwhelmed by its ambition and crowd-sourced nature, you may be pleasantly surprised. As users gain invites, the service is surprisingly stable and usable – at times, indeed, more so than the offerings of giants Google and Facebook. Most notably, features like tagging make it possible to actually focus on a task. (Compare what would happen on the rivals: even Google’s Circles can be more a chore than a useful feature, and Facebook still tends to dump everything in giant, overcrowded buckets of chatter.)

I’m game for any excuse to get together and make music with people, whether at a website, a studio, or in someone’s kitchen. So, here’s this experiment – Jóhannes Gunnar Þorsteinsson kicked off the first Diaspora sound project:

Here is the initial foundation track for the #diasporanoise2011 open collaboration project. Initially the rules are the following, Once you comment in this thread and ask to join you will be assigned into a queue according to the number of your comment. Apart from that, the rules are completely freeform. You can add a layer of sound to the original recording, or you can completely remix it, cut it up or even destroy it. When you are done you upload the bounced track to your upload service of choice with the same naming scheme as the link below. (yournumber_yourname_diasporanoise2011.wav), if you decide to upload more than one tracks for some reason, zip them together but use the same naming scheme.

There is no actual time limit, (at least not for now) but try to stick to max 1-3 days per person. Recordings and work at this nature is usually done improvised (and that’s usually where the magic happens) so more time shouldn’t be needed. Of course if more time is needed for some reasons then just let us know and I am sure we’ll understand.

I refer affectionately to many kinds of music as “noise,” but this certainly fits the bill – some experimental soundscapes going on, like this one (I enjoy it!):
04_juredimec_diasporanoise2011 by sundrdisko

Diaspora users can find the whole thread – and lots of tracks to hear – at:
https://joindiaspora.com/tags/diasporanoise2011

If you’re really, really desperate for an invite, explain why in comments and perhaps one of us can hook you up.

You’ll find in this thread that what happens for many musicians is various places to host sound, from Dropbox to self-hosted files to the increasingly-ubiquitous SoundCloud. Diaspora itself lacks audio upload features, but on the other hand, there are some limitations to what even a sound-focused service like SoundCloud offers in collaboration features. (For instance, I recently ran up against the inability to run private groups or easily download bunches of stems on SoundCloud, which makes even a simple remix collaborative easier on other services. More on that soon.)

The developer-friendly crowd also talk about how to roll your own player, taking on the primary advantage of services like SoundCloud. For instance, one contributor hosts their own files and uses a JavaScript-based solution (with HTML5 and Flash) on which some projects on other services are themselves based.

http://www.schillmania.com/projects/soundmanager2/

I’ll be continuing this conversation with readers over coming weeks and in more formal ways, but why not kick it off now: what would you want in a social website, or in collaboration? Leaving out fancy real-time collaborative environments, how would you most want to come together with fellow music lovers and geeks and make some stuff? Having used online communities since the days of BBSes, CompuService, and GEnie, I find often it’s basic, elemental communication that makes things work, so if you had only a select feature or two, what would they be?

(thanks, jure, for the tip!)

Alexander Chen, he of Kinect hacks and subways turned to strings, is back with another string visualization. Built in the browser (an interactive version is available), this work makes a visual accompaniment to Bach’s First Prelude from the Cello Suites. If you read music notation fluently, you may find the score itself suffices, but even so, the math to make this work – and the dance of circles across strings – is compelling. Alex, whose day job is with Google’s Creative Lab, talks to us a bit about the mathematics and process. First, his description:

baroque.me visualizes the first Prelude from Bach’s Cello Suites. Using the math behind string length and pitch, it came from a simple idea: what if all the notes were drawn as strings? Instead of a stream of classical notation on a page, this interactive project highlights the music’s underlying structure and subtle shifts.

Built in: HTML5 Canvas, Javascript, SoundManager
Made while a resident at Eyebeam

CDM: How did you settle on this particular visualization of this famous work? And how did you work out the maths, that is, why this specific number of dots, the distance from the strings, and the length of the strings themselves?

Alex: When I listened to the opening of the Bach, where it repeats the same bar twice, it made me think of a call and response. So I immediately pictured two wheels that echo each other, instead of just one wheel with four dots.

Figuring out the symbolic string lengths in pixels was a fun research project. I wanted explore the simple math behind string length. I learned that you can derive an entire chromatic scale just by using two fractions: 2/3 and 1/2. These correspond to the fifth and octave intervals. It’s called Pythagorean tuning. I stumbled onto this great little worksheet [PDF link] which seems to be intended for students.

Were there other things you tried, any failed experiments?

There were important learnings. It used to begin playing the piece right away. I started the opening tuning animation as an afterthought while I was preloading the strings. But that sequence became really critical.

What’s your sense of the music now having done this? Did it change your hearing of the piece

A lot of music visualization these days is linear, like reading a score. Logic’s editor, or even games like Guitar Hero, all follow that structure. And there’s a reason for that, as it’s convenient, for both computers and humans, since we can read it (and edit it) like a book. But I wanted to try something different. I think some of the magic of watching a performer is seeing such subtle, intricate finger movements produce such moving sounds. When I watch these strings morph, it feels more like the computer is performing, not just checking off notes one by one.

Seeing the Bach Prelude in groups of 8 notes gives me a bigger picture view of the piece. Instead of focusing on the individual notes, you can see each bar as a group. The strings start shifting very subtly, but as the piece builds, the strings seem to be panicking to me, shifting more rapidly. The computer is not expressive. All notes are played at equal volume. But the notes themselves, the data of the song, is inherently expressive.

http://blog.chenalexander.com/
http://twitter.com/alexanderchen
http://www.baroque.me/ [interactive - grab the ... circles ("grab the balls" doesn't sound quite right)]

Max 6 in Public Beta; For Home-brewing Music Tools Graphically, Perhaps the Biggest Single Update Yet

Just because a music tool fills your screen with tools and options doesn’t necessarily make it easier to realize your ideas. From the beginning, the appeal of Max – as with other tools that let you roll your own musical tools from a set of pre-built building blocks – has been the blank canvas.

Max 6 would appear to aim to make the gap between your ideas and those tools still narrower, and to make the results more sonically-pleasing. The reveal: it could also change how you work with patches in performance and production. I was surprised when early teasers failed to impress some users, perhaps owing to scant information. Now, Max 6 is available in public beta, and the details are far clearer. Even if Max 5 was the biggest user interface overhaul in many years, Max 6 appears to be the biggest leap in actual functionality.

It’s what I’d describe as a kitchen-sink approach, adding to every aspect of the tool, so there’s almost certain to be some things here you won’t use. What could appeal to new users, though, are I think two major changes.

More visual patching feedback and discoverability. First, building upon what we saw in Max 5, Max’s approach is to provide as much visual information as possible about what you’re doing. It’s probably the polar opposite of what we saw earlier this week in something like the live-coding environment Overtone: Max’s UI is actively involved with you as you patch. There are visual tools for finding the objects you want, then visual feedback to tell you what those objects do, plus an always-visible reference bar and rewritten help. This more-active UI should make Max more accessible to people who like this sort of visual reference as they work. No approach will appeal to everyone – some people will find all that UI a bit more than they like – but Max’s developers appear to be exploiting as much as they can with interactive visual patching.

Multiple patches at once. New objects for filters and data, a 64-bit audio engine, and low-level programming are all well and good. But the change that may more profoundly impact users and workflow is be the way Max 6 handles multiple patches. Max – and by extension Pd – have in the past made each patch operate independently. Sound may stop when you open a patch, and there’s no easy or fully reliable way to use multiple patches at once. (Compare, for example, SuperCollider, which uses a server/client model that lacks this limitation.) That changes with Max 6: you can now operate multiple patches at the same time, mix them together with independent volume, mute, and solo controls, and open and close them without interrupting your audio flow. (At least one reader notes via Twitter that you can open more than one patch at once – I’d just say this makes it better, with more reliable sound and essential mixing capabilities.) Update: since I mentioned Pd, Seppo notes that the pd~ object provides similar functionality in regards to multiple patches and multi-core operation. This has been an ongoing discussion in the libpd group, so I think we’ll revisit that separately!

One upshot of this change: some users have turned to Ableton Live just to host multiple patches. For users whose live performance set involves Ableton, that’s a good thing. But it could be overkill if all you want to do is bring up a few nifty patches and play with them. Now, I think we’ll start to see more people onstage with only Max again. (Check back in a few months to see if I’m right.)

Here’s an overview of what’s new:

• Discoverability: A “wheel” makes the mysterious functions of different objects immediately visible; Object Explorer makes them easier to find, and new help and reference sidebar keep documentation close at hand.

• 64-bit audio engine

• Open multiple patches, solo and mute them, open and close them without stopping audio, mix audio between them with independent volume, and take advantage of multiple processors with multiple patches.

• Low level building blocks: You don’t get new synth objects, but you could build them yourself. New low-level data-crunching goodness work with MSP audio, Jitter Matrix, and OpenGL textures

• More JavaScript: An overhauled JavaScript engine makes JS scripting faster and more flexible, and there’s a proper text editor with syntax highlighting (though, of course, you may still prefer your own).

• New visuals: Vector graphics and “HTML5 Canvas-like” UI scripting (though to me it’s a shame this isn’t just the HTML5 Canvas). There are also massively-expanded Jitter powers, but those are best left to our sister site Create Digital Motion.

• Filters: New filter-visualizing tools for audio filter construction and manipulation.

• Dictionary data type and associated objects let you describe information in a more structured way (all kinds of potential here from control to composition)

• Projects now let you organize data, media, and scripts in the manner more associated with conventional development environments

• What about Ableton? No news on that front, but I expect more soon. Max for Live users will at the very least get the advantages above, since Max for Live is really Max inside Live.

Looking over all that Max does, I have to say, I’m really amazed. I wonder if computer musicians ever pause to consider how fortunate we are. Even if this isn’t the tool for you, its availability – compounded by the availability of a range of other tools – is itself worth reflection.

Max is a program that shouldn’t exist, doing a number of things it shouldn’t do, for a user base that shouldn’t exist, doing things they shouldn’t be doing.

It doesn’t make sense that you could maintain a commercial project for this kind of audience, that you’d wind up with something this mature and powerful that had a continuous lineage stretching back to the 1980s. It doesn’t make sense that musicians would embrace such a tool and produce invention. The only explanation is sheer love.

Then, even as Max reaches new heights, some of the alternatives you have for making your own music tools are simultaneously growing by leaps and bounds. They provide very different approaches to music making (compare Overtone and SuperCollider, or Pd and libpd, or AudioMulch, or new Web audio tools). There really aren’t many fields that have this kind of choice, free and commercial, in their medium. In science and engineering, there’s private and public funding, producing some amazing tools but nothing with this kind of meeting of power and accesibility. There’s just something about music.

The fact that Cycling ‘74 can maintain a business model – just as open source projects maintain volunteer contributions – is a testament to sheer passion and love for music, and a commitment to perpetually re-imagining how that music is made from an atomic level up. There was a wonderful piece on C creator and UNIX co-creator Dennis Ritchie, whom I remembered yesterday, that observed that what he did was to do what others said couldn’t be done. From Max itself to what people make with it, I think that fits nicely.

So, have a look at the public beta, and let us know what you think. The release of Max 6 has caused more people to ask what this means for Pd and other tools, or even whether to patch things from scratch at all, but I’ll leave that question to a bit later. (I do have my own opinion about which tool fits which circumstance and user, but that’s best left to a separate discussion.) For now, you can try Max yourself and see what the fuss is about. If it doesn’t fit your means of music-making, know that you have a wide array of other options – pre-built to low-level code to old-fashioned tape-and-mic approaches, and everything in between. Go out and listen and see what you discover.

http://cycling74.com/downloads/max-6-public-beta/

If you’re looking to turn an Android phone or flashy, new Android tablet into a touch controller for music, you’ll be really glad to see OSC and MIDI controller Control. Furthermore, here’s a solid, powerful app based on the Web that lets Apple and Android fans play well together.

I’ve sung the praises of Control’s philosophy before. Templates are built on Web/HTML5 (WebKit) rendering, not proprietary, inflexible interface widgets, and can be created in JSON. You can make templates dynamic, too, because of everything JavaScript does.

(Non-jargon-filled translation: you can use the goodness of the Web to make control layouts that do whatever you like.)

The iOS version is a great option, but now Apple and Android owners (or people with both) can both get in on the action. The Android version already has multitouch on supported hardware, Bonjour/Zeroconf networking support, OSC support, and interface downloading. That means it’s already a usable wireless controller for musical and visual performance. Soon, it’ll also add sensor input and MIDI.

With new tablets from Samsung and Toshiba – the Samsung thin and slick, the Toshiba hefty but with tons of ports – the timing seems right. Also, because the app itself is open source, developers curious about adding any of those features to their own apps can share code and (ideally) contribute back to the project, which could accelerate Android development. I’ll leave our audio API gripes for another time – this is a controller app, so therefore doesn’t make sound – but for those looking for more mobile tools, this is unqualified good news.

Full feature list:

- Outputs Open Sound Control (OSC). MIDI coming soon!
- Handles multitouch on capable devices
- Bi-directional communication: use Control to set values on your computer, use your computer to set values in Control
- Dynamically add and manipulate widgets via OSC messages
- Reads and outputs data from Accelerometer and Compass sensors (on applicable devices) with adjustable update rates
- The ability to script behaviors for widgets using JavaScript
- Auto-discovery of wireless networks via Bonjour
- Interfaces can be pushed to the phone via OSC or downloaded from the web
- Supports both portrait and landscape interface orientations
- Interfaces work on both phones and tablets (tested on Droid and Asus Transformer)
- Free

And here’s some of the new, dynamic jQuery functionality, relevant to both iOS and Android users. The idea is, using OSC, you can dynamically create your own interfaces:

More documentation on that, with an example in Max/MSP:
Control 1.3: Dynamic Interfaces, jQuery integration & more

Finally, some images of the Android version, which looks – rightfully – quite a lot like the iOS version. (That’s the idea.)

Learn more about Control, and follow its development across platforms:
http://charlie-roberts.com/Control/

Or for Android users, grab a copy – I’ll be trying it on my Galaxy Tab 10.1 right away:
Control (OSC + MIDI) @ Android Market

The software is really entirely the work of Charlie Roberts – really brilliant work, mate! Thanks for keeping CDM posted!

With Web data providers offering generous cash prizes and a strong emphasis on harnessing data to transform listening, music consumption took center stage at Music Hack Day’s debut in New York. But it was novel music controllers, the sort that once were commonplace only at academic music conferences, that stole the show. That suggests that whereas building the next MySpace was once the hot music tech, the future might look more like a race to build the next Theremin.

Whatever the cause, the event proved just how productive hotshot DIY coders can be when left to their own devices and given ample sources of electricity and caffeine. The weekend marathon has now been exported to nearly a dozen installments in Europe and the US, though this was its first appearance in the boroughs of New York City. The result: nearly 200 participants, hundreds (yes, hundreds) more on a waiting list, and over 70 projects completed in a weekend. From just Saturday afternoon to Sunday afternoon, programmers working with Web and desktop technologies whip up quick software creations. The emphasis is on “hacking” for a reason: there’s no time to second-guess or obsess over quality, or indeed to waste a moment conceptualizing. This is all about making a working product, trying out an idea in practice, mashing together whatever is most accessible as rapidly as humanly possible. Sure, there aren’t any hard, fast rules against bringing in previously-prepared tools. But make no mistake: very much that was live in a demo Sunday was pure theory just twenty-four short hours earlier.

Coders laid out cushions on the floor and packed toothbrushes. Some were local, but others were still bleary eyed-with jetlag from trips across the Atlantic. Hopped up on coffee and Red Bull (and then beer), they coded projects that often had nothing to do with their employment – even those who came on the dime of some of the Web companies. Nor was there a lot of fishing for venture capital or IPOs. Most gave away code (if they could bear to let anyone else see it) on public code repositories like GitHub, and listening to coders, many even blatantly ignored the promise of cash prizes. It was programming for love.

Here are few of the most promising projects, and a few noticeable trends. If generating automatic playlists or finding music videos that match tastes of friends on Twitter isn’t your cup of tea, don’t despair. We had alternative instruments and music-makers, too – and, take note, they generally took home the cash.

Invisible Instruments, Made with Gestures

Invisible Instruments, the winning hack by Tim Soo, began at the Boston event. I think what made it so compelling – the voting was done by the entire audience, entered via SMS – may have been the recognizable instrumental metaphors. Using Max/MSP and OSCulator, a Wiimote, and iPod touch, the instruments emulate a violin, drum pads, and

Now, none of this is news to regular readers of this site, of course. But that should present another lesson: if you’re doing this kind of cool stuff, you should tell the sorts of people who don’t normally pay attention to such things (even, very often, tech-savvy folks). Music tech involves all sorts of wildly cool things that we’ve inadvertently kept a secret. Let’s change that.

(Or, to put it another way, apparently the whole world isn’t reading this site. If you want to help us with that, let me know.)

Previous videos / project work:
Invisible Instruments

Note that Tim does say, “Scout’s honor,” that he built new invisible instruments just this weekend. And you can grab these and older patches from his site.

Plucking Strings and DJing with Kinect

Just got a Kinect? Want to make it do something? What better than a couple of coder friends to make it happen? The three-person team that worked on Stringer, a musical instrument for plucking strings controlled with Processing, wound up easily paying for their Kinect hardware by pocketing some change in prizes.

Participants Aidan Feldman, Tyler Williams, and Alex Chen contributed. In the process, they found that using a camera to simulate string plucking wasn’t entirely effective; they didn’t have enough tracking intelligence to tell the difference between a pluck and a motion near a string, so wound up going for simpler reactivity. The clever string animation works wonders to make you feel like you’re playing real strings, even with samples, however, and it’s amazing how much they accomplished and learned in a short space of time.

The Processing libraries aren’t quite as complete as some C++-based libraries, but they’re a good place to start. If you’re considering doing something similar, I recommend my friend Dan Shiffman’s posts on his library contributions:
Kinect and Processing
Updated Kinect Library for Processing

And by the way, this work was an extension of the strings featured in Alex’s excellent New York subway sonification, about which we I to interview him:
Music Made with NYC Subway Schedules; HTML5+Flash, Q+A with Artist-Developer

Another Kinect hack: Matt Gattis produced the Bionic DJ project with “Kinect, libfreeconnect, and the OSC MIDI protocol.”

Beat Grids and Sine Waves with ChucK

I unfortunately don’t have good documentation of Jordan Orelli’s project, but he has some fascinating ideas. I laughed and said what he did was build a DIY Tenori-On with a Novation Launchpad and ChucK, but it is actually unique.

The grid of the Launchpad is a pitch sequencer – that we’ve seen many times before, and it’s very useful. But the grid can also become beat-synced modulation, which makes it possible to do some lovely, rhythmic manipulation of sounds.

The top row of the Launchpad is used for selecting instruments. The rightmost column selects “modes” specific to that instrument. The grid controls the current mode. All instruments run concurrently, so you can reasonably have a rack of 7 instruments, with the 8th instrument slot being reserved for the “mixer” instrument, which doesn’t actually mix anything but it lets you change the tempo (generally crashing the application in the process).
Everything is written in ChucK and no samples are used.

http://wiki.musichackday.org/index.php?title=ChucKPad

The SMS DJ

DJs may want to replace the crowd members making requests. Tough – the crowd may just ditch the DJ for a robot.

There were a number of crowd-sourced playlists ideas, including one cleverly named Youzakk and hooked into location check-in service Foursquare.

But djtxt was, amazingly, a whole service built in a weekend, complete with slick user interface. To make it work, it uses a whole lot of services: Twilio for SMS connectivity, Grooveshark for playback, Last.FM and musXmatch for albums and lyrics, and many others. Full details:
http://wiki.musichackday.org/index.php?title=Djtxt

And they did the other thing widely-respected by Web geeks: they deployed to a live site.
http://djtxt.me/

Drum Loops, From Your Browser to SoundCloud, and More HTML5

Two big trends emerged that are relevant to anyone interested in making music in the Web browser – without necessarily giving up your “real” (read: traditional desktop) production tools.

One: HTML5-based Web tech, while not entirely polished yet, is indeed enabling some basic music functionality right in the window of modern browsers.

Two: things like SoundCloud connectivity mean you’ll be able to generate quick ideas and then download samples later. (Ableton Live made a number of cameos in the afternoon demos.)

One great example of that is PatternMusic. It’s a pretty terrific little drum machine. But Ghostly International’s Haig and Miguel, who began the project in last summer’s Visual Music program at Eyebeam (in which I was also a participant), made a big leap forward this weekend: SoundCloud export. In turn, Haig worked out how to make PHP wrappers for SoundCloud much simpler and more effective. That’s a hack I hope we get to share soon.

http://wiki.musichackday.org/index.php?title=PatternSketch

http://patternsketch.com/

Also very cool: battling beats at SoundCloud beat battle. Match your groove-constructing skills against Ghostly’s Miguel or Com Truise. You’re going down, Truise, no matter how cool you are.

http://patternsketch.com/battle/

CDM Coolest Hack: Vib-Ribbon Clone

For the uninitiated, Vib-Ribbon, a Japan-only masterpiece by music game innovator Masaya Matsuura, is one of the high water marks of music games, a trippy walk through cartoon lines animated by sound.

Vib-Ribboff by Robert Böhnke cloned that game entirely in the browser, using SoundCloud music and intelligence engine Echo Nest for analysis, all with JavaScript frameworks Coffeescript and Raphaël.js. It’s a sharp parody of the original, and the sonification works. It’s too bad lawsuits exist, because otherwise it could become the most popular feature of SoundCloud. Can’t someone, like, license this?

CDM Funniest Hack: Faux Geocities Fans

Fans Forever and Ever cracked up the audience with a brilliant, generative version of horrible fan pages. It even fakes the awful GeoCities-era HTML and creepy, stalker-ish poetry (see screenshot). I hope this actually shows up online.

CDM Underdog Bet: Music Notation

Trendspotters no doubt got into the crowd at the hackday. (Famed venture capitalist Fred Wilson was there, for one.)

Trend they almost certainly wouldn’t spot: the likely growth of music notation on the Web and tablets.

Only two hacks really capitalized on this – one a score follower, and the other, pictured here, live annotation. But recall that, alongside the better-publicized MP3, guitar tab was an early hit of music on the Web. (Yes, it made music publishers and copyright holders grown, but that misses the point: huge swaths of the public consume notation.)

The reason is this: even as music education suffers in the US, a mind-boggling number of people play music, and since nothing has really replaced music notation, that means scores still matter.

The ability to mark up a score in a browser and share those markings, live, with anyone with a computer or tablet or other Web-enabled device? Priceless.

http://wiki.musichackday.org/index.php?title=Live_score_annotator

This clever tool will even follow a score in time, coupling algorithmic processing (to hold the right place) with broadcast information (to keep everyone in sync):

Follow the Muse

Drawing Sound with SuperCollider

Drawing Restraints by Mike Clemow was one of a number of pieces that focused on live synthesis and not just clever ways to replace Muzak. I have to give a nod here to Mike, as aside from his own project, he was an anchor of a little corner of the room working on live music apps, a big source of energy and enthusiasm. His work, aside from live performance, also appears in gallery contexts.

Also, bonus points for actually performing in his demo – that takes guts.

Drawing Restraints is a musical work for joystick, pen tablet and digital synthesis software. There are four modes for the instrument, two are buffer-based granulation modes using recordings of meat frying and a group of men talking, respectively. The third is a sine wave granular synthesis mode, and the last uses a saw-tooth wave through a filter bank to generate sound.

The synthesis is done entirely in SuperCollider and the input data is routed through OSCulator in the case of the Wacom tablet and a simple Pure Data patch for the HID based joystick. OSCulator does not have a HID input feature as of this writing. Both send the input data over Open Sound Control to Supercollider. While Supercollider does have a HID interface, I prefer to keep my programming interface unified; I merely have to create OSC responders in Supercollider in order to receive the data.

The different modes have similar parameters, however, each is mapped in a different way to the inputs. The modes can be combined to create complex sound objects that are independent, but their behavior is constrained relative to the state of each of the other modes. Their orchestration is constrained by the mapping scheme.

During Music Hack Day 2011, I came in with the hardware and the idea and brought the instrument to a state of playability. This piece will premiere at Zora Art Space in Brooklyn on Feb 23rd along with two others, “3coil,” a piece for induction coils and laptop, and “Outis,” a piece for video stream, computer vision algorithms, and custom synthesis software.

http://michaelclemow.com (home page has information about upcoming show)

Music Hack Day Page:
http://michaelclemow.com/index.php?/projects/music-hack-day-2011—nyc/

Best Networked/Collaborative Hack

JSONloops, an open-source real-time multi-user audio sequencer for collaboration, was an insanely ambitious project. And it wound up failing, likely for simpler reasons. While a first demo ran into network problems, the second go indeed worked!

The team:

Marak Squires – Created project, invented the JSONloops format, built core sequencing code
Elijah Insua – Writer of C bindings, solver of the hard problems
hij1nx – C Programming, JavaScript, HTML, UX and User Interface Dominator

Oh, and here’s what happened the first time around, according to Marak: “The software was working the whole time, but the machine connected to the projector decided to connect to a different WIFI network and we couldn’t access our local server.”

Yep, been there. But the project looks fantastic and does actually work perfectly well. Networked music-making is a topic for an entirely separate article, so I hope to talk to this crew more.

Updated – Marak lets us know he used the Socket.IO cross-browser sockets library:
http://socket.io/

Seriously cool stuff, as it also supports mobile browsers and older desktop browsers that don’t have direct sockets support.

Three features you wished were in SoundCloud

1. Pulling samples into Ableton Live.
2. Splitting up DJ sets into tracks.
3. Downloading SoundCloud sets as zip files.

Done, done, and done. Hope to see them released.

Fun SoundCloud Tricks

Tweetsonbeats.com turns a Tweet into a synthesized hip-hop memo. You can do it to your own tweets (or perhaps retweet beat poets of our time like Sarah Palin) with hashtag #tweetsonbeats. This is what SoundCloud co-founders do for fun. Really. For instance:

@haynes_dave: It went down but Tweets On Beats did a great demo. Just add this hashtag to a tweet and you’ll get a hip-hop memo by Tweets On Beats

And they composed a theme song for the hackday.

Listen to the NYC #musichackday 2011 theme song. Produced by @ericw, vocals by @lenberg at General Assembly on Sunday afternoon by David Noël

Follow up…

I hope that we see some of the code from this event polished and further developed; if it’s relevant to CDM readers, I’ll absolutely share it. And if you have creation events you’d like to see, let us know.

Liveblog of demos

If you care to read my own notes to myself, I live-blogged the event.

2011 hack list, with some great resources and (for many projects) code

Alexander Chen transforms the steady pulse of the (actual) New York City subway system into gentle, generative string plucks in his new interactive piece “Conductor.” The visual effect as well as the musical one is mesmerizing, as the subway is viewed in the abstract, sparse geometries of designed Massimo Vignelli’s 1972 diagram.

New York subway nerds and long-time residents will note that the schedule itself is from 1972, hence the appearance of the K train and the elevated along Third Avenue (the 8), one I imagine we wish we still had.

http://mta.me/

The work is also a glimpse of the Web as a canvas (figurative and literal) for this kind of work – your browser as your very own virtual chamber music setting. And it’s a window into some of the challenges (cough, buggy audio implementations!) to making that happen.

Built in HTML5′s Canvas element with SVG vector data and JavaScript, the application must rely on Flash as a back end for audio delivery, though via a very cool JavaScript tool, SoundManager (which also supports HTML5 audio if its implementation improves). There’s also some use of open source sounds of string plucks, via the freesound project.

Important as the technical details are, though, I find what Alexander says about the inspiration for music made from subways to be the most compelling.

He shares with CDM some insight into the process, technical and artistic.

How did this project come about? What made you decide to translate subway schedules into music?

I’ve been kind of interested in turning everyday things into music. I did a project in 2003 called Sonata for the Unaware, where I used security-cam style footage of commuters and generated music from that.

This project sort of started last September when my friend David Lu (velluminous.org) and I were having a conversation about an idea he
had for an illustrated string instrument, where drawn lines turn into plucked strings. This turned into a project (which is still in progress) called Crayong. So I had written code for that. As a violist, I really wanted to duplicate the feel of grabbing and pulling a string, how there’s more tension near the pinned points.

Once I had that string code, I started brainstorming other things I could do with it. My wife and I started talking about a subway map that you could strum. My friend owns a print of the 1972 Vignelli map, which is really beautiful.

I liked the idea of the trains being the performers. And with all of the realtime location-sensitive information we can get now, I thought about a website that starts off feeling realtime, but then time starts unraveling.

How it was put together — good notes on your site, but want to share any tips that you learned in the process? You had to give up on HTML5 audio, it seems; was that in all browsers or just some of them? With Flash for sound and Canvas for visuals, seems the results are at least largely compatible, yes?

I’m excited about HTML5. The graphics went pretty flawlessly, but unfortunately there definitely were limitations in the audio layering. There’s an in-detail post at my site:

Limitations of layering HTML5 Audio

I ran into problems layering multi-shot triggers of the same sample. It could layer a handful of sounds (seemed to cap off around 8), but would increase load time unnecessarily. This was at least happening in Safari, where I could see the HTTP requests. I tried some workarounds but every approach had its trade-offs.

So all in all, I think Flash still performs better for the audio portion of these types of experiments. But I’m hoping that will change, as it would be nice to not rely on any plugins.

For projects where I am triggering say, 30+ samples, I often compile them into one audio file and manually store the start times of each sample in the code. Seems to load faster overall, because each HTTP request has some overhead. (But I didn’t have to do that here, because I only had 20 notes.)

I also think it’s nice to work with technical limitations. For example, Flash has a limit of how many sounds can be simultaneously layered. Instead of trying massive code fixes, I decided to simply use samples with shorter sustain. That’s why I ended up going with cello pizzicato instead of say, a sustained harp. The samples are from the http://www.freesound.org, recorded by user corsica_s.

Can you tell us a little bit about yourself?

About me – Besides doing interactive work, I’ve released three albums as Boy in Static and one as The Consulate General. I’ve toured on-and-off the past
few years, usually performing on viola and vocals. I’m currently working at Google Creative Lab in New York.

Besides various new art and technology projects I see everyday, my wife and I recently found a DVD of Al Jarnow’s stop animation from the 80′s. Incredible mathematical grid-based animation experiments done by hand, frame by frame.

More on Alexander:
chenalexander.com
presentcompany.tv

Music:
theconsulategeneral.com
boyinstatic.com

His day job is at the Google Creative Lab.

Music notation is powerful because it’s a standard. You can share it between musicians and understand what it means. What if, instead of being confined to individual, platform-specific apps, digital controls for music were the same way? We’re not just talking a MIDI message here or there, either – someone could walk in with some new-fangled noisemaker they just build in hardware or software, and all you’d need to talk to it and change its sound would be a Web browser.

At first glance, the generically-titled “Control” seems like just another iPhone / iPad touchscreen controller, in an already-crowded field. But look closer, and you see the first steps toward a future where browsing someone’s synth is as easy and accessible as browsing this site. By building on cross-platform, open Web standards, and then providing a basic but elegant way to send interaction as messages, Control is more significant than just a convenient wireless touchscreen on your phone. As such, it embodies some ideas some of us (cough) have been hoping would catch on.

It’s available free today for iOS devices, with other platforms possible soon.

First, it is Web nerd compliant, with JSON and WebKit and HTML Canvas and CSS. But what does that actually mean?

• Included templates: Built-in controllers for DJ interfaces, a Game of Life, and a multi-touch widget that tracks two more fingers than you have … on your hands.
• Make your own templates: Templates are specified as JSON, which some advocates describe a more efficient, readable alternative to XML.
• Dynamic interfaces: JavaScript in the interfaces means that you aren’t limited to making unsatisfying fake knobs and faders; you can make stuff that actually does things.
• OSC interaction: Not only does Control transmit OSC messages, but you can also describe JavaScript interactions and widgets themselves using OSC. Over time, this could lead to yet more dynamic interface creation, especially if others pick up the developers’ ideas.
• All based on Web tech – and not limited to iOS in the long haul. Control uses WebKit (the open source browser engine that’s the basis of Safari, Chrome, and others), plus open Web standards, via the new Canvas element in HTML5. Thanks to a lovely, open source toolset called PhoneGap, that means the ability to port to a variety of mobile platforms. Right now, Control is only on iOS, but Android and many other platforms could be possible. Furthermore, the developer’s ideas could be extended to desktop browsers, too, and used in other apps.
• MIDI, too. Thanks to Core MIDI wireless support, you can transmit MIDI alongside OSC. Hardware support I hope isn’t far behind, using, you know, wires. It is a beautiful thing to buy something off eBay from 1986 and program it with your iPhone 4 (or, soon, other phone).

Developer Charlie Roberts I believe is really onto something here. These ideas could all ultimately be bigger than just this one app, which is the idea – but at the same time, having something out there makes a huge difference. (Remember MIDI?) This isn’t the first controller to use Web tech, even on iOS, but it could be the first based on technologies and ideas with OSC that could extend that implementation to other platforms and software.

CDM in one tab, your synth in another, your friend’s live set in a third? We’ve got a ways to go yet, but just having a way of avoiding mobile controller app fragmentation could make us more productive. Stay tuned for more; I hope to talk to Charlie more this week.

And check out the video…

http://charlie-roberts.com/Control/
iTunes link

I’ll be in Stockholm the week of 27 September, speaking at Stockholm’s Android Only conference Wednesday/Thursday 29-30. I’m particularly excited by the lineup, because it emphasizes pushing the envelope of Android and cross-platform development. I’ll talk about how Processing for Android can allow “sketching” audiovisual apps on mobile. Martin Roth of RjDj will talk high-performance audio development. There’s also discussion of advanced uses in embedded hardware, cross-platform PhoneGap development, CouchDB and JavaScript goodness, hardware-accelerated graphics … all good stuff, and all potentially relevant to creative music and visual development not only on Android but future platforms generally.

I need to revisit Android on this site, but in the meantime, if you’re interested in the platform, MusicRadar did an exceptional round-up:
The best Android music making apps in the world today

I’ll have more information for everyone (whether or not you’re in Stockholm) in time for the conference on CDM.

But beyond Android…

Calling All Swedes! CDM is co-hosting a party Wednesday night 29 September at the conference venue in Stockholm, with .SE, Dialect, and most importantly the fantastic Swedish music mag Studio Magazine.

If you’re a CDM reader and music artist in the Stockholm area and have a project/studio to show off, and/or if you’re up for playing (with or without an Android device involved), please let me know right away, send some music/files/info, and we can discuss details. We’ll finalize the lineup over the weekend. I’ll also try to make a visit or two in my free time, limited as it may be.

Music scores remain one of the best ways to record or share many musical ideas. If you’ve done even casual notation, you’ve likely had the experience of scrawling something down on a scrap piece of paper, manuscript or otherwise.

Imagine, instead, quickly scrawling something in the now-ubiquitous web browser window.

Gregory Dyke writes with a notation project he’s built with Paul Rosen; he says that it’s further along in its development than the notation project we saw last week. As before, it employs JavaScript and HTML5, and the Canvas element SVG support, rendering quickly in any modern browser right inside a web page. (Correction: it’s SVG, not Canvas, that makes this work, thanks to the raphaeljs library.)

Abcjs is an open source parsing and rendering tool for ABC written entirely in javascript, so it allows sheet music to be rendered as both standard notation and MIDI entirely with the browser.

Here are a couple ways to use this:

For rendering any ABC notation found on a web page as standard notation,
see http://drawthedots.com/abcplugin

For the simplest ABC editor in a web page, see http://drawthedots.com/abcjs

For a free on-line editor and tune storage website, see
http://drawthedots.com

Enjoy! And we’d appreciate feedback of all kinds.

Notes:
1) ABC 1.6 is mostly done, and many parts of ABC 2.0 are supported. We are actively working on improving the rendering.

2) We know that the rendering in IE is not as pretty as Firefox, Safari, and Chrome, but we’re working it!

Here, the ABC notation format is a standard, so you can simply type in or copy and paste any ABC-encoded text and render it right away.

It looks ideal for dropping musical excerpts or examples into a page, but this project even in its early stage offers another idea: why not quickly type in your notes in simple text characters, then store and share that score with others? There’s even instant music rendering.

Simple, lightweight examples do have a way of opening the door to more technically-involved discussions, and this is no exception.

ABC is nifty and easy, but it isn’t capable of representing more sophisticated scores in the way that the free Lilypond format is. I noted last week that Lilypond is nonetheless readable and easy for basic entry, even as it adds sophisticated features with a little more work. I think even having a web window with ABC is nice enough, and it should be possible to go from the simpler format (ABC) to other, more complex formats (MusicXML or Lilypond). But this question of how to interchange files remains one of interest. After the post last week, the project we saw spawned a long discussion in its blog’s comments on how interchange might work. Greg, for his part, concedes that “abc is quite powerful, but stops at complex multivoice scores where voices move across staves (simple multivoice and multistave is possible).” That could make putting Lilypond in the browser a useful activity, and since it is possible to go from MusicXML to Lilypond, it should enable MusicXML, as well.

As with sound synthesis, putting notation in the browser demonstrates how both the “desktop” app and the “browser” app can differentiate themselves. The browser focuses on quick, simple entry and sharing. The desktop app remains the tool for connecting to MIDI hardware, performing more sophisticated entry and layout, and project management. Far from competing, each gives the other greater purpose and a clearer sense of how the two design approaches can differ. Because a Web rendering engine like WebKit is also embeddable, the line doesn’t even need to be absolutely clear. I can imagine, for instance, Lilypond editors that use WebKit for lower-quality, real-time notation previews, prior to doing a full Lilypond render in PDF. (There are real-time PDF rendering libraries like Cairo, too, so I have no idea whether that makes sense, but the array of options open to developers is nonetheless expanded.)

The project is free and open, so let us know if you modify it somehow. (JavaScript-controlled, 3D-produced generative scores, perhaps?)

http://code.google.com/p/abcjs/

Updated: Gregory replies with an email, and it was useful enough to me that I’m reprinting it in full. He notes most importantly that ABCjs is capable of more sophisticated rendering than seen here, even if it doesn’t yet do as much as, say, the Lilypond renderer does.

Thanks a lot. You’re spot on with the note taking idea – I wonder whether this would be a good way to create a mobile browser app – still runs a bit slow on mobile safari though – about 8seconds for rendering on my 3g. Nice to see you discuss abcjs as a full blog post.

Just a note: we don’t use canvas, but svg, using raphaeljs to bridge across browsers.

In hindsight, we should probably put a more sophisticated example on the landing page. For example, the tunes below render quite nicely (although not with complete midi playback). We should probably finds ourselves a demo score which runs the whole gamut of several voices, ornamentation, chords, guitar chords, dynamics, etc.

Thanks again for the heads up

Greg

X:3
T: TEST: Erev Ba % —
C: from Israel
M: C|
L: 1/4
K:G
V:1
“G”dgf g/b/ | “Am”a3z | “D7″ab c’/d’/ b | “G”b3z | dgf g/b/ | “Am”a3z |
“D7″ab c’/d’/ b | “B7″b3z | “C”ceg>g | f/g/f/e/ e2 | “Am”Ace>e | “D”d>c B/A/G/F/ |
“Em”G2 E2 | “Am”A2 “D7″A/B/ G | (“G”G4|G2) z2 | dgf g/b/ | “Am”a3z |
“D7″ab c’/d’/ b | “G”b3z | dgf g/b/ | “Am”a3z | “D7″ab c’/d’/ b | “B7″b3z |
“C”ceg>g | f/g/ f/e/ e2 | “Am”Ace>e | “D”d>c B/A/G/F/ | “Em”G2 E2 | “Am”A2 “D7″A/B/ G |
“G”G>A B c/A/ | “G7″d>e =f/d/B/A/ [K:C] ||”C”G2z2| “Dm7″d/e/f/e/ d/c/B/A/ |\
“G7″G2z2 | “C”z/ G/c/B/ c/d/e/f/ |
g g/a/ g2 | “Dm7″f/g/a/g/ f/e/d/c/ | “G7″B/c/d/c/ B/A/ G| “E”^G>B e/d/c/B/|\
“F”c2 a>a | g/a/g/f/ .f .e |
“Dm”d2f>f | “G”e>d c/B/A/B/ | “Am”c/d/c/B/ A/G/F/E/ | “Dm”D/E/F/D/ “G7″G A/B/ |\
“C”c3 e| .g.a.g e/d/ |
GcBc/e/ | “Dm7″d3z | “G7″def/g/e| “C”e3z | GcBc/e/ | “Dm7″d3z |
“G7″def/g/e| “E”e3z | “F”FAc>c| B/c/B/A/ A2| “Dm”DFA>A| “G”G>F E/D/C/E/ |
“Am”c2A2 | “Dm”d2 “G7″d/e/c | (“C”c4|”Dm”c2) “G7″d/e/c| (“C”c4| c2) z2 |]
%
V:2 gch=0
“G”z4 | “Am”z4 | “D7″z4 | “G”z4 | z4 | “Am”z4 |
“D7″z4 | “B7″z4 | “C”z4 | z4 | “Am”z4 | “D”z4 |
“Em”G2Bd | “Am”c2 “D7″c/d/ B | “G”B>ABd | B>A G/A/ B| d2 z2 | “Am”A/B/c/B/ A/G/F/E/ |
“D7″D2 z2 | “G”z/D/G/F/ G/A/B/c/ | d d/e/ d2| “Am”c/d/e/d/ c/B/A/G/ |\
“D7″F/G/A/G/ F/E/D/C/ | “B7″^D/B,/D/F/ B/A/G/F/ |
“C”c2 e>e | d/e/d/c/ cB| “Am”A2 c>c| “D”B>A G/F/E/F/ |\
“Em”G/A/G/F/ E/D/C/E/ | “Am”A/B/c/^c/ “D7″d e/f/ |
(“G”g4|”G7″g2)z2 [K:C] || “C”GcB c/e/ | “Dm7″d3z | “G7″de f/g/ e| “C”e3z |
GcB c/e/ | “Dm7″d3z | “G7″de f/g/ e| “E”e3z | “F”FAc>c | B/c/B/A/ Az |
“Dm”DFA>A | “G”G>F E/D/C/D/ | “Am”c2 A2 | “Dm”d2 “G7″d/e/c | (“C”c4|c2) z2 |
Gede/g/ | “Dm7″f>e f/e/d/c/ | “G7″Bcd/e/c| “C”c c/B/ c/B/c/d/ |\
e e/f/ ee | “Dm7″f>e f/e/d/c/ |
“G7″Bc d/e/ c | “E”B>A ^G/A/B/G/ | “F”F2 A2 | c2 FE | “Dm”D2 F2 | “G”B2 e2|
“Am”e2c2 | “Dm”f2 “G7″f/g/ e | (“C”e4| “Dm”e2) “G7″f/g/ e | (“C”e4|e2) z2 |]

The mobile question is especially interesting to me; it may be that you need non-JavaScript, “native” SVG libraries, but porting that shouldn’t be impossible either way. I’d love to have a mobile Android sketchpad, especially since my Droid has a keyboard. I’ll look into some testing.

The march of “because you can” experiments with the new generation of Web browsers continues. Last week, we saw real-time synthesis in the browser from a team at Mozilla. Next up: music notation.

Mohit Muthanna has executed a gorgeous example of musical notation using HTML5′s Canvas. (The Canvas is a new feature of the Web standard that makes drawing to the display directly in the browser more functional than in the past.) JavaScript code is translated directly to “engraved” notation on the screen, without any other dependencies, plug-ins, or intermediate libraries.

Music Notation with HTML5 Canvas

This isn’t just using browsers for the sake of it, however; music notation is an important language for sharing musical ideas. Back when I was a freelance educator for Sibelius, a popular feature was that program’s pioneering “export to Web” function. Sibelius’ feature even allowed commerce and other features, but it also meant the need to install a plug-in.

Mohit’s work is a project that spanned “a few weekends.” That’s some of the beauty of the current age of development: you can scratch together a prototype quickly, so that you do something rather than just talk about it. Once a prototype is available, visible, and tangible, it’s sure to lead to deeper discussions about the “right” way to do something, which is the primary reason for creating prototypes in the first place.

Accordingly, the demo of the technology isn’t any more interesting than the comments that follow. As they should, observers immediately wonder about how standard interchange formats could aid in exchanging scores.

So, what are the common interchange formats for notated music? Glad you asked. Some front runners:

Lilypond is mentioned most in comments, because it’s a rich, human-readable format so simple you can comfortably edit it directly in a text editor, it’s a standard format, and it’s the only format here that has an accompanying engraving standard. That is, a common, open-source renderer will immediately turn your score into printed notation. Most formats (like a Word DOC for instance) depend on different apps to be rendered and used; Lilypond is both the format and the standard renderer, and both are free.

MusicXML:Perhaps the most sophisticated of these formats, MusicXML is a royalty-free standard supported by virtually everything on the planet, including, notably, Lilypond itself. MusicXML is the most common way of interchanging with tools like Sibelius and Finale (and many more obscure options).

Abc notation is a very simple language for encoding notation as ASCII. What’s nice about it is that it’s very compact. It can also interchange with formats like Lilypond.

Those are the three that interest me the most. There are others, I’m sure; feel free to bring them up in comments. (Fair warning: I could go on various rants about how complex and inscrutable some of the TeX-based formats are.)

A follow-up post engages the format and interchange issue. SVG support appears to be a definite.
A Question of Formats

Side note: I disagree with the idea that Lilypond is a “TeX-based format” that fails to be “accessible to non-geeks.” I’m not a “non-geek,” but I’m enough of a geek that I have no time, and accessibility is really important to me. Lilypond I find to be eminently readable and concise, usable by hand in a way that TeX is not. There’s no need to attach the stigma of one to the other. ABC is too informal to handle anything beyond simple scores, though it might be just fine for the browser context. I do agree with the MusicXML complaint, though: it works well with these software packages, but it’s not something you’d want to actually use directly.

You may notice that there are richer, freer, easier means of exchanging notation files than there are, say, multitrack music project files. You can thank centuries of music notational tradition for that – the original “standard” before anyone used such things. (“Paper: the original browser!”)

I realize I have to put some disclaimers on any mention of browser standards, lest people think I’m joining the hyperbolic “let’s move everything to the browser” movement. That’s not the point. The idea is, if you can have a standard means of representing something like a score, and you can standardize mechanisms for displaying it in current-generation browsers without the need for plug-ins, exchanging ideas becomes easier. That doesn’t compete with the idea of “native” clients on your desktop. On the contrary, standardizing on a format like Lilypond has made those clients smarter, easier to work with, and more compatible with one another. The browser is itself a bundle of native code, dependent on the desktop operating system to work, and making use of that OS’ facilities for everything from typography to sound.

As with the synthesis last week, something as essential to musical expression as notation is a perfect example of how those facilities evolve. There is no real difference between doing something “on the desktop” and “in the browser.” As these formats demonstrate, though, there’s a big, big difference between doing something with a standard, with the ability to exchange material and remain compatible, instead of having a bunch of isolated software packages that can’t communicate with each other.

I hope some readers here who are experienced both with technology and notation will suggest some ideas for how these tools can continue to evolve and interoperate.