SuperCollider currently lacks good modern tutorial documentation. This needs to be addressed, so Nathan, myself and a couple of other people are going to do just that.
The plan is to have three ‘books’:
Tutorial for New Users.
Tutorial for Intermediate Users.
SuperCollider Cookbook
Tutorial for New Users
This will focus on writing music in SuperCollider, with an emphasis on patterns, SynthDefs, MIDI in/out, buffers and maybe a few other things (suggestions welcome). The idea is that this would get people making music quickly, and would address common workflows. These would include:
Writing beats/loops (address the Ableton crowd).
Writing melodies and chords.
Time signatures, bpm, tempo ramps.
swing
Structuring larger pieces (e.g. verse/chorus - maybe a simple dance kind of structure).
Algorithmic Composition (TBD as obviously this is a huge topic)
Recording (NRT and writing to disk).
Working with buses, mixing, compressing (I know Compandr sucks - work with me here) - with a strongly opinionated take on the ‘right’ workflow.
Different types of synth (mono, poly, etc) when working with patterns
Effects (limiting, distortion, filtering, etc).
Basic synthesis (additive, subtractive, wavetable, granular - possibly others if people have view points)
working with samples, buffers, granulation.
Livecoding with JITLib.
MIDI in and MIDI out (but at quite a basic level. The assumption will be that you either want Ableton/sequencer to control your Synths in SuperCollider, or you want to write patterns that will algorithmically drive external synths/record into your DAW).
And then as part of all this the following would be addressed:
Installation
Using the IDE
Explaining the server/client distinction.
Clocks
Dictionaries
Arrays/Lists
Common short cuts when coding (e.g. .() in place of .value).
Environments
Events
Patterns
The whole local/‘global’ and environment mess.
Simple functions (but not routines, or classes)
Synth Creation (including tricks with functions).
Various ways you can interact with synths when doing JIT/patterns.
Some good ugens from extras.
possibly some useful quarks (but probably only as pointers - as quarks are outside the control of the central team).
Using SuperCollider as a sound processor from mikes/line in, etc.
I very deliberately will not address a number of things in this tutorial (which is not intended to be complete). These will include:
Classes
Routines
Open Sound Control
Writing a GUI
Other things I haven’t thought of.
Tutorial for Intermediate Users
This tutorial will focus on programming. The expectation will be that the reader has read the intro tutorial but isn’t an experienced programmer. Sort of an intro to programming (not that SuperCollider would be my ideal first language, but no matter).
This will be a strongly opinionated tutorial on how to code in SuperCollider (e.g. alternative ways of coding will be shown - but discouraged). To the degree that we have a style guide, that will be emphasized. Otherwise it will be the strong opinions of Nathan, myself and anyone else who is involved.
The entire language will be covered, and in addition we will cover:
Communication with the server (what it is, how it works), OSC handling, etc.
Classes. Lots and lots of classes. All of it.
Prototype coding (i.e. JavaScript conventions).
All the weird and wonderful stuff you can do with arrays, lists, etc.
Routines. Lots of lovely routines.
Writing a GUI.
Variables.
Patterns the theoretical way.
How to write custom patterns.
How to handle events.
Demand UGens (maybe).
Other stuff TBD.
Cookbook
Really what it sounds like. An organized collection of solutions to more uncommon problems, or things people try to do. If it’s in the cookbook it’s either pretty advanced, or just something unusual that most users wouldn’t need to/want to do. Or the kind of thing that you only want to encounter when you have this particular problem.
I’m interested in any feedback. If there were things you struggled with when learning then let me know. If you think you can help at any level (e.g. just acting as a critical reader/editor would be awesome).
Also, if there are tutorials/resources that you think are good for any musical environment (Reaktor, PureData/MaxMSP or even [shudder] CSound) - let me know. Any existing SuperCollider tutorials that you think are good - also let me know.
Something that I miss in all SC tutorials and books is a deep course on synthesis techniques. Most tutorials teach you how it works, but they never explain it deeply. For example, I miss practical examples showing stuff like :
You can use the randomness of reverb tail and envelope it diferently to get stockhausen’s studie 2 clusters;
20Hz is the threshold of human hearing onset detection, so you can play with different clicks and diferent rates to get newer sounds;
Two noises out of phase creates some stereo effects;
What was Koening and Brun approach to synthesis? Can I make it on SC? ;
How could I control FM synths better to get only harmonic sounds?
What are the sampling strategies used by Barry Truax?
How can use granular synthesis like Horacio Vaggione ?
It’s really hard to find helpfull info like that related to SC… I think it worth improving tutorials on how to get new, unique and complex sounds, after all electronic music is basicaly about this.
Many infos are out there but spread over several sources. I’m not aware of a comprehensive synthesis tutorial in SC - but on the other hand such would have to be huge and still cover only basics in each sub-field. Questionable if something will ever come into being - but at least this forum is also a place to collect infos and, as we see, people have already started to do this.
I think getting “new unique and complex sounds” is an individual path and in the end a lonesome journey. If there would be a tutorial satisfying this goal it would destroy the effort in the very same moment, I’m afraid that’s part of the dialectics of art we have to live with
However I agree that often standardized synthesis techniques lead to boring results. IMO a general strategy to avoid this is cross-breeding different techniques. Try to mix things in a way that isn’t recommended anywhere. With some experience and patience you will find interesting stuff that’s not contained in any tutorial. Though in order to achieve such it needs study materials that are dedicated to technical questions and synthesis basics below refinement.
Just to clarify, the idea is not to re-write Microsound (Roads) using SC, which would be a really deep topic both on SC and Granular Synthesis, but to make a resonable overview of the techniques (2 or 3 docs with 500 lines each), then people could decide to if they want to go to the book to find an exaustive explanation.
I miss a deeper dig into some topics. For instance, there is a really deep tutorial on patterns, but some stuff showing how one could implement Xennakis ideas with notes and patterns is not available. Surely this should not be in the patterns tutorials, but it fits well to an intro to Xennakis ideas on form, material and stochatics. Then would lead to his synthesis ideas.
Same thing on sampling… What are the some frequently used strategies for playingback buffers ? Does the sample rate matters when you time stretch? Are there any other options for timestretching? Which composers use it?
It does need to be an exaustive explanation, just a deeper guide. Something more oriented to the sound results and to its historical usage, but coded with SC.
Being in danger of repeating myself, but such stuff is definitely there, though spread. See Alberto de Campo’s chapter on granular synthesis in the SC book (code can be downloaded). A real lot of examples, he has worked with Curtis Roads, so this is an excellent source.
I have written two tutorials on granular synthesis (Live Granulation and Buffer Granulation in the miSCellaneous_lib quark), partially not basic though.
That’s not totally true, I’ve implemented Xenakis’ sieves as methods and patterns, the latter approach is, at least to my knowledge, new. miSCellaneous_lib’s tutorial file “Sieves and Psieve patterns” contains a number of examples, though not directly related to Xenakis’ compositions.
Trevor Wishart is famous for morphing and stretching, in his paper on Vox 5 he explains some techniques. They are partially outside the RT world, and some of his FFT concepts can be (nearly) realized with PV ugens, but it’s not straight (we treated this last term in a seminar).
Currently synthesis techniques are not on the roadmap because I don’t have anyone to write them. If you would like to volunteer then that would be great! Even collecting the information so somebody else could write it would be a huge help.
Honestly I think the best way to start would be doing what I’ve already been doing when time allows. Starting a thread on a synthesis technique, post what you know and encourage others to post what they know. There’s also a lot on sccode and the mailing list. Collating all that here would be great.
Another thing you could do is if you want to know how to do something in SuperCollider, describe the technique (maybe link to an article, or post a photocopy PDF from the Wishart book or something) and see if people here can recreate it. I’d also suggest posting to the mailing list (but post anything you get there here also, as I think there’s great visibility). Then when we have some decent content we can start to think about the best way to present it in the tutorials.
Of course you may have your own ideas as well. And that’s totally fine.
I’m actually interested in contributing some stuff I’ve discovered/struggled with over the past 2 years (which is quite a lot to be honest).
One topic I’d find interesting e.g. is “debugging techniques”. It would mostly be basic stuff like postln, postcs, debug, trace, poll, FreqScope, etc, but could also touch on intermediate things like: “making sense of a stack trace” (not sure I can write this part already ) or more advanced techniques, like using OSC to custom visualize server generated data or sclang pattern data while it’s being generated. Some of these techniques took me way too long to discover.).
Sure, everything is out there somewhere, but I think it would be nice to have it grouped together in focused topic-oriented guides.
Something else entirely: can mdBook properly highlight sclang code fragments?
One thing I’d mention that should be addressed early on is Arrays. It took me a long time to get out of the habit of copying and pasting code (i.e. ~sine1= blah.ar; ~sine2= blah.ar;) when I needed more than one of something and I think it is a good habit to break early on as it opens doors to the programmability of SuperCollider really well.
@shiihs Yes these are important topics. Not sure how debugging will get worked in just yet (and stack traces - let’s just say that SuperCollider stack traces are not good). My plan for the beginner tutorial is for the programming element to be minimized, with the emphasis being on making music/sounds quickly. The idea is to hook people so that they want to learn more (and thus read the rather more demanding and theory heavy intermediate guide). Basically it’s propaganda so I can get people to use SuperCollider rather than PD/Max
Debugging matters for that crowd, but it needs to be treated lightly.
Some of those other topics are probably a better fit for the cookbook. Something on visualizing server data/patterns would a great cookbook topic. If you want to write it I can work it in somehow.
Structure for the first part of the tutorial is here:
No actual content, but hopefully this gives some idea of the direction I want to take. The emphasis is on making music, and also addressing issues that either come up a lot on the mailing list, or are just common musical issues. I do want to address more out there musical stuff later, but some of this is intended as a corrective to the typical SC tutorial where it assumes you’re writing Curtis Roads style experimental music. Sometimes you just want to write banging techno amirite?
The idea overall is that when you’ve finished the tutorial you’d have the tools required to fit SuperCollider into an existing workflow (be it Ableton, standalone, or recording stems to be mixed/mastered separately. Or conversely as a live audio processing thingy). And also enough to do at least basic synthesis/audio stuff.
Interludes are intended to be worked examples for how you can use SuperCollider that build upon the previous chapters. Again, these are intended to provide examples that could literally be copy and pasted by the user and used for their own pieces. Copy and pasting is good.
The later parts of the tutorial are currently a little hazy in my mind, though I do have a provisional structure as an org-mode file if anyone’s interested. The following chapter would probably be about working with samples/audio files - and the techno house interlude would probably follow that.
) or more advanced techniques, like using OSC to custom visualize server generated data or sclang pattern data while it’s being generated. Some of these techniques took me way too long to discover.).