Norns and General Purpose Computing

anon45924993 · 2022-06-27T15:09:11.205Z

I don’t think this zen approach to programming is encouraged or taught frequently enough. We tend to regard improvised tools as inferior to engineered ones, but it takes improvisation to develop new forms of practice including the culture that supports the practice. Engineering can follow culture. When we put the engineering cart before the horse, the solutions often lack some x factor we might call “soul”.

That being said, I can also relate to the mindset that “I’ve been programming in the code factory factory all day and if I have to look at one more line of text, I’ll scream” at which point I can certainly understand wanting to use some finished and engineered products in order to make bug free music for an hour or two.

The trouble with programming is that it can become engineering before you notice the transition.

eblomquist · 2022-06-27T15:21:32.299Z

As a yet-to-be coder, I’m thrilled that there is a robust library of scripts developed by the community. But I’m also fascinated by the embodied philosophy @tehn is pointing to here.

This heightens my anticipation about joining the norns conversation as an active participant in the very near future!

skeletons · 2022-06-27T16:51:46.760Z

While I’m not sure it’s quite as general purpose as the interface lua+norns exposes, the first few years of eurorack pre-norns I was mostly controlling my synth with a WW that used custom firmware for keyboards and loop recording (ty tehn for helping me debug some 64 power issues i had at the time :D).

My main “un-norn’d” use of crow right now is as a clock source. Input 1 when unpatched defaults to 90 BPM (my personal fave) with various intervals… i think like 8th notes, 8th note triplets, quarter notes and 1 bar. Patching input 1 with a voltage offset (for instance from a quadratt) will allow you to change the BPM to your liking, patching input 2 will make it work like a standard “clock divider”. In that same vein of “things that are useful don’t have to be complicated” I could very easily rewrite the script if for some reason I accidentally blew it away.

I’m a programmer by trade and I would be “into computers” even if I didn’t do it for a living, but I’m not sure that I would have ever gotten into linux or open tools in software if it wasn’t needed for work. As Jonny said, the “unix philosophy” sort of encapsulates the idea of general purpose computing, but it’s not something that’s really taught in a curriculum outside of higher education (at least in the midwest USA). I think most people don’t view a computer as a tool which I think in part is because most computing is notably not general purpose.

mik · 2022-06-27T20:25:45.166Z

This thread is really cool and very deep thank you…
I have been surprised by the reference to Beauty from PPOOLL!

Since I have a Norns I wanted to clone this bad guy and of course I saw this SC link in the past.
This was my first Norns goal or first project.
I failed like a starting pianist who by a piano for playing his favorite Beethoven pieces… But i was really interested by code!

Your comment made me confident (somebody did this quick and is happy).

So I had to try again today and —— succès ! I was in the game to not ask how you did it, I can do by mi self…

Dirty but sound close to the instrument I use to play in PPOOLL playground in MAX.
Dirty but in my favorite music computer écosystème and without MAX.

That’s not nothing for me!
A Norns Happy user in France since 3 years…

tehn · 2022-06-28T19:56:43.070Z

the story continues:

sharing code (and ideas) is a form of potential preservation. after yesterday’s post @ioflow (who holds this forum together!) had recalled that i shared the code during the marathon set in the twitch stream (it was that kind of show).

the code

s = require 'sequins'

m = midi.connect(1)

function init()
  params:add_number("filter","filter",0,127,64)
  params:set_action("filter", function(x) jp("vcf_f",x) end)
end

jmap = {
  lfo_rate = 0,
  lfo_delay = 1,
  dco_lfo = 2,
  dco_pwn = 3,
  dco_noise = 4,
  vcf_f = 5,
  vcf_r = 6,
  vcf_env = 7,
  vcf_lfo = 8,
  vcf_kbd = 9,
  vca = 0xA,
  a = 0xB,
  d = 0xC,
  s = 0xD,
  r = 0xD,
  sub = 0xF
}
  

function no(n,t)
  m:note_on(n,127)
  clock.run(noff,n,t) 
end

function noff(n,t)
  clock.sleep(t)
  m:note_off(n)
end



--m.event = function(data) tab.print(data) end

function jp(p,x)
  m:send{0xf0}
  m:send{0x41}
  m:send{0x32}
  m:send{0x0}
  m:send{jmap[p]}
  m:send{x}
  m:send{0xf7}
end

function panic() for i=0,127 do m:note_off(i) end end



a = s{0,5,3,8,s{15,19},12,s{24,29,8}}
a = s{0,3,8,5,12,15,s{19,24,31}}
a = s{0,3,8,5,12,24,s{19,24,31}:every(2)}

b = s{0,0,0,12,0,7,0,0,s{7,12,24}}

e = s{45,50,55,60,65,70}

c = s{false,false,false, true, false, s{false,true}, true, s{false}:every(2)}

tra = 60
tra2 = 48
ti = 0.1


n = function()
  while true do
    jp("s",5)
    jp("vcf_f",e())
    no(tra+a()+b(),ti)
    if c() then
      no(tra2+a()+b(),ti)
      jp("s",50)
      jp("vcf_f",60)
      clock.sync(2)
    else
      clock.sync(1/8)
    end
  end
end
  
ca = clock.run(n)

a few details jumped out after i saw this. i knew i started with the pedal-to-juno already worked out before the set. but at some point i clearly started editing it live— some sequins emerged so i could, well, hang out with visitors. the giveaway is this:

a = s{0,5,3,8,s{15,19},12,s{24,29,8}}
a = s{0,3,8,5,12,15,s{19,24,31}}
a = s{0,3,8,5,12,24,s{19,24,31}:every(2)}

the first two definitions just get overwritten by the third, so i was line-executing via maiden, testing things out without restarting the script. the likelihood then that this code is “not the final product” is assured by definition: changing the code was part of the process of the performance unfolding.

you’ll also see that despite my previous resistance to use parameters, i did use them this earlier time:

  params:add_number("filter","filter",0,127,64)
  params:set_action("filter", function(x) jp("vcf_f",x) end)

which suggests i just added these two lines then used the param system to map the pedal via the midi mapping system (perhaps with the ranges adjusted, that makes sense… but note, as easy to do with a few more numbers typed for some math scaling.)

and also, some “infrastructure” in the form of a lookup table for the various other sysex params:

jmap = {
  lfo_rate = 0,
  lfo_delay = 1,
  dco_lfo = 2,
  dco_pwn = 3,
  dco_noise = 4,
  vcf_f = 5,
  vcf_r = 6,
...

i don’t remember if i did this on the fly or not, but it is later used in the sequins to make more variation.

the variable names are terrible, but this is normal for thing-in-the-moment, when these obtuse strings are close to your brain.

none of what’s happening is complex: it’s just putting together a few existing musical facilities that the system provides— in a way that allows for a level of control much beyond stringing plugins together with some automation. it’s starting from a lower level. (and again, this example i think works well because it’s nothing genius or original— the point is that it illustrates a different approach to thinking about technological capability.)

license:

mode 13h

what a serious nostalgia trip you just provided. (i recall reading so much about mode x and having it feel just beyond my grasp with assembly/etc. these were the golden demoscene years…)

though i’d say my quintessential general-purpose-computer experience was using basic on the apple 2. having the computer boot to a repl, expectantly. having that be the low level.

teletype and crow have a more narrow focus given their limited capabilities. the nature of these machines ask for a small scope and provide a direct-to-the-point command set. it takes dedication to not just keep going deeper with a more powerful/feature-full machine.

anon45924993:

The trouble with programming is that it can become engineering before you notice the transition.

i couldn’t agree more. and am constantly seeking ways to defeat this pattern. i’m hoping this thread can be about that journey.

(not that engineering should be avoided. it’s a necessary task, when called for.)

anon45924993 · 2022-06-28T20:22:35.366Z

tehn:

having the computer boot to a repl, expectantly. having that be the low level.

For me it was the TRS-80 Color Computer 2, but same difference, just more constrained. I often wonder how much it “matters” that this was my introduction to computing. More than a little bit, I suspect.

license · 2022-06-29T02:29:29.001Z

that 256-square grid ( ) is the exact image I had in mind, and is permanently burned into my subconscious. the fabled mode X was always beyond my chops as well, and I settled for flinging of bytes at registers with stolen snippets to edit/animate palettes (and control OPL3 synths - a sort of proto-w/syn, at least in my mind).

teletype and crow definitely offer more focus, which often plays nicer with my scattered/distract-able brain. though the moderately richer domain of norns makes it more of a “bicycle for the mind” possibly - more to see, more to do, more to choose from.

rvense · 2022-06-29T05:40:37.410Z

I remember someone saying, “Before presets, everyone made their own sounds, back then that was just called using your synth!”

Similarly, it’s a great tragedy of modern life that we ended up with such a separation between “programming computers” and “using computers”. Not that everyone should have to do everything from scratch, but they should be much easier to shape to fit the users need.

radioedit · 2022-06-29T06:28:43.523Z

rvense:

they should be much easier to shape to fit the users need

I kinda feel like it has never been easier for the average person to do this than it is today. If you consider the choice of apps and software on offer, and the ease of browsing the library, let alone the web apps we have access to, we’re living in a golden age of computing!

The biggest win - you no longer have to fiddle with a command line and config files to achieve want you want to achieve, but you can if you want to!

driedstr · 2022-06-30T23:02:32.693Z

tehn:

(and i’m hoping to hear more about micro-projects that people have done like this, but keep private!)

Here’s such a one, it’s a glue script to get a graphics tablet plugged into a linux box talking to crow: Dave Riedstra / inscribe · GitLab. It currently outputs X / Y / Pressure / Gate (on contact) through the outputs, but could be modified to do a lot more stuff (like using those values to interact with running scripts). I don’t have the energy / time to flesh this out into a full project but I hope that aspects of this will be useful or interesting for others.

The story basically goes that my main interface to crow has been via the great snippets to talk to druid from vim. These use websockets, which means pretty much anything can talk to crow via a running druid session. I’ve got an entry-level graphics tablet on the shelf above my desk and some experience with using linux’s device input data from another project so I thought, “Hey, my euro system doesn’t really have a controller, what if…” and got to coding. Using websockets didn’t work very well because druid’s repl prints every lua snippet that’s sent to it to the terminal before it’s passed on to crow, and printing lines takes time. At this point I remembered, “Hey, druid is an open source python thing, what if I just re-used how it talks to crow in my own thing?” and after some browsing of the source, I was able to import one module and use two of its functions for good communication to crow with low enough latency to use with a controller.

Usage notes

make sure the druid source is in the same directory as the script (best done by getting crow-inscribe with git clone --recurse-submodules)
you’ll need the evdev python package as well (pip install evdev or sudo apt install python3-evdev)
you need to provide the device address to the script (something like /dev/input/event23), you can find the right one by scanning the output of libinput list-devices)
tweak the output ranges in lines 20-22 to suit
I swapped the Y axis so origin is in the bottom left instead of the top left (and therefore up is up)
if you want to explore other uses, start by modifying the crow_set_volts() function (using crow’s public API seems like the most sensible way to me)

lua · 2022-07-01T11:51:04.742Z

Most are just slight variations on standard high-level abstractions. Some enable, some coerce. And some do neither.

While Emacs is still kicking.

It is easier than it was. But we’re still at a distance from true personalization.
(Whether it’s technology, or medicine, or social policy) We’ve only just begun, it seems.

Lots of interesting generators, but very few ways of composing and organizing material.

eequeue · 2022-07-01T14:13:25.192Z

tehn:

but there’s also a level of project management and sense of support obligation and thing-ness that such a project accumulates. sometimes a project becomes large enough that it’s difficult to change directions quickly, or reacquaint oneself after a few months away. someday you might think you need a changelog, or do a fix for major system version update.

This, also. I have such huge love and respect for the developers and maintainers out there. All of you. As someone who has yet to contribute but has it on their “to-do” list, I feel such a sense of awe sometimes at the level of creativity I see here daily.

I want to call out @dani_derks, @infinitedigits, and @tyleretters for being so insanely generous on a daily basis. That being said, there are so many others out there, here and on the discord, giving of their time and knowledge to help others.

I guess what I’m saying is not all heros wear capes.

infinitedigits · 2022-07-03T14:43:36.608Z

eequeue:

huge love and respect for the developers and maintainers out there

much appreciated

tehn:

treat norns scripting as a sort of musical construction set, where code is fluid and changing

your examples exemplified here are really what make norns special. I also love norns as the musical construction set. especially when it comes to the prototyping of ideas - ideas can quickly become reality with the tools at hand. couple of examples: I was thinking about a cv sequencer that had multiple lanes asynchronously playing and prototyped it into grid+crow (code). I had an idea about different diameter circles rotating with beads that play chords only when they align and otherwise play single notes (demo, code). I made “lights out” on the grid (code). little projects like these took little time because of the ease the available musical construction set. and I don’t sweat that these projects didn’t have much life after coding them, they served to prototype the idea and answered the questions I had about the musical ideas I was thinking through. also just fun sometimes.

also realizing code is fluid helps to interact with a lot of norns scripts. I consider most of the code in norns “fluid” and constantly change other scripts to suit my own needs (e.g. recently modded colorwheel to add strings, even modded norns itself to get more softcut voices). I whole heartily encourage others to do the same. the barriers to doing so are surprisingly small. and if you’re stuck there is lots of help at hand

norns + supercollider

I’d like to stick a point onto the general computing when it comes to SuperCollider. definetly norns is slick when it comes to the music fundamentals - its super easy to connect midi, make complex sequences+clocks, and connect it an interface (i.e. screen+controls). but, it is also possible to do these things in SuperCollider (e.g. sequencing+clocks, midi, and even gui interfaces).

but because norns is such a great musical construct set, that you don’t have to do things in SuperCollider. why is this useful? well, it means you can write your idea in Lua. and Lua is a language that describes itself as being easy to learn. SuperCollider, on the otherhand, is not (though now there’s lots of help for learning SC).

a real example: I recently ported some code I wrote for a norns script “mx.samples” from lua into SuperCollider. they are a similar number of lines (Lua a bit shorter) but I have to say it was easier on my brain to do the Lua. you may judge yourself. but broadly speaking, I find the general purposefulness of the Lua language makes it easy to take shortcuts that are harder to do in SuperCollider. though they both work, I had to work harder in SuperCollider to do the exact same thing.

–

anyways, all of this to say is that I used to have to explore musical ideas using portmidi + custom code libraries / python dependencies, etc… but with norns I can explore musical space in a few dozen lines of Lua and enjoy and have time to explore some more.

skeletons · 2022-07-06T16:12:06.565Z

the way lua blankets itself over SC with very easy to understand abstractions is quite wonderful.

i recently reinstalled linux on an older X1 thinkpad and within an afternoon of futzing i got the norns stack working “natively”. so rather than having to figure out how to do a buncha glue to make supercollider work nice with osc/midi i can instead focus on the more fun part of “just making music”.

i don’t think that running norns on “baremetal” outside of the shield/factory/fates is necessarily something that needs to be promoted given how high the support burden is with even the factory/3/4/fates variations, but given that it’s built on free software if you’re unable to afford a norns and you have a working computer you can still interact with the ecosystem given enough patience.

lua · 2022-07-11T14:21:47.092Z

How much does it depend on a well designed environment?

skeletons · 2022-07-14T21:32:02.569Z

i think the main considerations (at least for working in the same space as monome devices and midi) are easy access to being able to send, receive and interpret open sound control messages and being able to send, receive and interpret MIDI messages. as long as you can use either of those to communicate with $SYNTHTHING or $SEQUENCERWIDGET then that’ll get you into a spot where you can plumb things around in interesting ways.

if you’re making stuff only for yourself i don’t think the design of an environment matters too much as long as it’s repeatable enough for you - the main consumer of $APPBLOB - to make again, but it becomes a bit more complicated once you start introducing different versions and environments for different types of operating systems (for instance running old max and PD patches can be difficult). part of the success of norns is that the environment is constrained, there’s a common language and wrapper around the sound things but the user-experience is such that non-techy people can still interact with it.

tehn · 2022-07-15T11:22:47.877Z

cross posting

https://llllllll.co/t/email-newsletters-low-tech-decentralized-web/34878/131?u=tehn

ypxkap · 2022-12-16T00:24:52.643Z

i had an experience this week that made me think of this thread.

i am a video editor and i’m working on a project in davinci resolve. i’m out of practice with it, and consequently, i made a big technical mistake: all of my notes for my show were the wrong format (resolve distinguishes “timeline markers” from “clip markers”—only the latter are searchable, leaving me with several hundred carefully curated and unsearchable (useless) markers).

many googles later, it was looking like i was out of luck. this issue is the subject of a number of support forum threads going back years, all ending in “submit a feature request”

i never would have had time to clean this up manually and was resigning myself to go into the edit without access to any notes.

but digging around the manual i discovered resolve has significant support for scripting with lua. it’s been well over a year since the last time i wrote more than 3 lines of code, but between my faded norns scripting memories and the resolve API i had a viable solution to my unsolvable problem in like 2 hours!

spaghetti code 😎

resolve = Resolve()
project = resolve:GetProjectManager():GetCurrentProject()

--get current timeline with markers 
resolve:OpenPage("edit")
current_timeline=project:GetCurrentTimeline()
current_timeline_name=current_timeline:GetName()

--get markers
timeline_markers = timeline:GetMarkers()

--get correct multicam we are copying markers to
mediapool = project:GetMediaPool()
workingfolder = mediapool:GetCurrentFolder()

--for every clip in current bin, if the clip has the same name as the current timeline, set multicam to that clip
for k,v in ipairs(workingfolder:GetClipList()) do 
	if v:GetName() == current_timeline_name then 
		multicam=v
	end
end

--write function copying markers from timeline to Multi
local function CopyTLmarkerstoMCmarkers (frame,markercontents)
	multicam:AddMarker(frame, markercontents["color"],
	("COUCH_".. markercontents["name"]),
	markercontents["note"],
	markercontents["duration"])
end

--move the markers 
for key,value in pairs(timeline_markers) do 
	CopyTLmarkerstoMCmarkers(key,value)
end

this isn’t as “pure” in scope as the original context of the thread—i’m using my script to control a locked up corporate owned application. nonetheless i’m v grateful to have been exposed to this idea—scripting is an approachable topic, it’s totally doable to write some lines of code for personal use without knowing what the “right way” is, and you really don’t have to be a computer scientist, etc.

i dabbled in applescript etc a little bit over the years, but without norns i’d never have felt comfortable attempting something like this. i was still a little afraid of wasting time on something over my head. but it wasn’t even that hard. i only had to google one thing (“attempt to call a table value lua”—something about ipairs that i didn’t actually need to understand in order to fix)

just wanted to say thanks for that, and thanks to everyone on here over the years who has made a point to draw this distinction between programming and engineering, etc. this was not something that was intuitive for me to understand at all, but figuring it out has provided so much value to my life!

tehn · 2022-12-16T02:34:42.754Z

i cannot convey the degree to which this warms my heart

radioedit · 2022-12-16T09:24:51.451Z

This reminds me of Matt Webb’s recent post about apps exposing a Google Sheet of their data that advanced users could tinker with:

Interconnected, a blog by Matt Webb

Let’s use spreadsheets to rewire apps and make new ones

Posted on Tuesday 13 Dec 2022. 909 words, 8 links. By Matt Webb.