HelpSource/Overviews/JITLib.schelp

   1 title:: JITLib
   2 summary:: An overview of the Just In Time library
   3 categories:: Libraries>JITLib
   4
   5 section::Introduction
   6
   7 emphasis::"Passenger to taxtidriver: take me to number 37. I'll give you the street name when we are there."::
   8 footnote::
   9 an austrian math teacher's joke
  10 ::
  11
  12 Disclaimer: there is no time, really; punctuality is your personal responsibility though.
  13
  14
  15 emphasis::Just in time programming:: (or: emphasis::conversational programming, live coding:: footnote::For Live Coding see: http://toplap.org ::emphasis::, on-the fly-programming, interactive programming::) is a paradigm that includes the programming activity itself in the program's operation. This means a program is not taken as a tool that is made first, then to be productive, but a dynamic construction process of description and conversation - writing code thus becoming a closer part of musical or experimental practice. SuperCollider, being a dynamic programming language, provides several possibilities for modification of a running program - this library attempts to extend, simplify and develop them, mainly by providing abstract placeholders strong::(proxies):: that can be modified and used in calculations while playing. There is some specific networking classes which are made to simplify the distribution of live coding activity.
  16
  17 JITLib simplifies and unifies some orthogonal aspects of SuperCollider.
  18 It consists of a number of strong::placeholders:: (server side and client side) and strong::schemes of access::.
  19 These two aspects of space corresponding to emphasis::inclusion:: and emphasis::reference::, depend on their context - here the placeholders are like roles which have a certain behaviour and can be fulfilled by certain objects.
  20 It is useful to be aware of the three aspects of such a placeholder: a certain set of elements can be their strong::source::, they can be used in a set of strong::contexts:: and have a default source, if none is given.
  21
  22
  23 Frequently used classes:
  24         link::Classes/Tdef:: (for tasks), link::Classes/ProxySpace::, link::Classes/NodeProxy:: and link::Classes/Ndef:: (for synths), link::Classes/Pdef:: and link::Classes/Pdefn:: (for patterns).
  25
  26
  27
  28 For additional functionality, see also strong::JITLib extensions Quark::. To install it, evaluate:
  29 code::
  30 "JITLib extensions".include;
  31 ::
  32
  33
  34 section::Tutorial: Interactive Programming with SuperCollider and jitlib
  35
  36 This tutorial focusses on some basic concepts used in JITLib. There are many possibilities,
  37 such as server messaging and pattern proxies which are not covered in tutorial form presently.
  38
  39 definitionList::
  40 ## content: ||
  41 definitionList::
  42 ## placeholders in sc || link::Tutorials/JITLib/jitlib_basic_concepts_01::
  43 ## referencing and environments || link::Tutorials/JITLib/jitlib_basic_concepts_02::
  44 ## internal structure of node proxy || link::Tutorials/JITLib/jitlib_basic_concepts_03::
  45 ## timing in node proxy || link::Tutorials/JITLib/jitlib_basic_concepts_04::
  46 ::
  47 ::
  48
  49
  50 section::Overview of the different classes and techniques
  51
  52 list::
  53 ## One way or style of access is the strong::'def':: classes (Pdef, Ndef etc.). It binds a symbol to an object in a specific way:
  54 code::
  55 Pdef(\name)             //returns the proxy
  56 ::
  57 code::
  58 Pdef(\name, object)     //sets the source and returns the proxy
  59 ::
  60 the rest of the behaviour depends on its use.
  61
  62 client side: link::Classes/Pdef::, link::Classes/Pdefn::, link::Classes/Tdef::, link::Classes/Pbindef::, link::Classes/Psym::, link::Classes/Pnsym::, link::Classes/Fdef::
  63
  64 server side: link::Classes/Ndef::
  65
  66 ## Another way, for server side NodeProxies, is an strong::environment:: that returns placeholders on demand:
  67 code::
  68 ProxySpace.push
  69 ::
  70 code::
  71 ~out = { ...}
  72 ::
  73
  74 helpfile: link::Classes/ProxySpace:: for the use together with other environments, see link::Tutorials/JITLib/jitlib_basic_concepts_02::
  75
  76 ## There is also direct access strong::without using the access schemes:: : NodeProxy, TaskProxy etc. provide it. Internally the former use these as base classes.
  77
  78 client side: link::Classes/PatternProxy::, link::Classes/EventPatternProxy::, link::Classes/TaskProxy::, link::Classes/PbindProxy::, link::Classes/Pdict::
  79
  80 server side: link::Classes/NodeProxy::
  81
  82 ## To record all textual changes, link::Classes/History:: is provides navigation and a memory of code.
  83
  84 ## For playing back on multichannel systems, link::Classes/Monitor:: (used internally) has a link::Reference/playN:: method.
  85
  86 ## GUI classes: overviews and mixers: link::Classes/ProxyMixer::, link::Classes/TdefAllGui::, link::Classes/PdefAllGui::, link::Classes/NdefMixer::
  87
  88 (for separate use: link::Classes/TdefGui::, link::Classes/PdefGui::, link::Classes/MonitorGui::, link::Classes/NdefGui::, link::Classes/NdefParamGui::)
  89 ::
  90
  91
  92 section::Tutorials
  93
  94 definitionList::
  95 ## link::Tutorials/JITLib/proxyspace_examples:: || (a broad variety of inputs and uses)
  96 ## link::Tutorials/JITLib/jitlib_efficiency:: || (optimising code)
  97 ## link::Tutorials/JITLib/the_lazy_proxy:: || (how the initialisation works)
  98 ## link::Tutorials/JITLib/jitlib_fading:: || (how crossfade of code works)
  99 ## link::Tutorials/JITLib/jitlib_asCompileString:: || (storing and reproducing proxies)
 100 ## link::Tutorials/JITLib/recursive_phrasing:: || (a specific use of Pdef)
 101 ## link::Tutorials/JITLib/jitlib_asCompileString:: || (how to reproduce source code from objects)
 102 ## link::Tutorials/JITLib/jitlib_networking:: || (how to collaborative live code with JITLib)
 103 ## link::Tutorials/JITLib/basic_live_coding_techniques:: || (live coding without jitlib)
 104 ::
 105
 106 section::Networking
 107
 108 list::
 109 ## in remote and local networks thanks to sc-architecture node proxies can be strong::used on any server::, as long as it notifies the client and has a correctly initialized default node. strong::note that the client id should be set::.
 110 ::
 111
 112 section::Internal classes / abstract classes
 113
 114 definitionList::
 115 ## link::Classes/BusPlug:: || (listener on a bus)
 116 ## link::Classes/SkipJack:: || (a task that keeps awake across cmd-period)
 117 ## link::Classes/LazyEnvir:: || (and environment that returns proxies)
 118 ## link::Classes/EnvironmentRedirect:: || (abstract superclass for redirecting environments)
 119 ## link::Classes/EnvGate:: || (singleton fade envelope)
 120 ## link::Reference/NodeProxy_roles:: || (adverbial syntax for NodeProxy sources)
 121 ::
 122
 123
 124 section::Feedback
 125
 126 for suggestions / comments contact me
 127 Julian Rohrhuber, rohrhuber@uni-hamburg.de.
 128
 129 History and GUI classes are written by Alberto de Campo.
 130
 131 Thanks a lot for all the feedback and ideas!
 132
 133
 134
 135 _____________________________________________________________
 136
 137 The research for this project is funded by: German Research Foundation (DFG)
 138 and the Future Funds of Styria, Austria.