Really nice!
Thanks!
As an FYI, a snippet from the latest video (week5/2) where Alex shows how to generate this list within tidal:
[edit]
scaleList
also 
import Sound.Tidal.Chords
chordList
2 Likes
That's the chords, to get the scales you can do
scaleList
1 Like
This is amazing. Been playing with it for a couple hours.
Is there a way to pattern the iteration limit, or even the operator / function? I couldn't get it working myself. Its fun modifying these things as it plays, really expressive.
1 Like
I don't think there is an easy way of patterning that parameter but its a good idea. Very unpredictable results with that one. I might try to add that later and see how its sounds.
Reopening the discussion to deal with another important aspect of melodic expression: intention, nuances, musical phrasing. Not being able to phrase things correctly might be my biggest frustration with live-coding. Were you able to reproduce a "natural" phrasing using code?
I sometimes wonder if it wouldn't be best to play using some sort of weird modal velocity sensitive keyboard that allow you to switch between writing characters and triggering MIDI events but I couldn't find anything capable of doing that.
2 Likes
I had a go at this for my solstice set - I think it's getting pretty close to what you're looking for tbh,
I had at least one listener mistake the superpiano for a sampled line -
whether you can enact the lines more "deliberately" is probably the question - there's quite a bit of chance in there
4 Likes
Adding my 2 cents to this great thread -- I think that sequencing fixed melodies or phrases, while apparently not an expression of livecoding, can serve as a good start to mash, warp and re-pattern them with e.g. struct, bite or sometimes rev, and end up with something pretty different and open for experimenting.
Patterning euclidean values also works wonderfully to find interesting phrases and keep things under control without using randomness.
I've also been after more "natural" progressions (ofc "natural" could mean a lot), and maybe this snippet can work as a small example of melodic outputs with Tidal:
p "piano"
$ jux rev
$ rarely (# octave 4)
$ sometimes (# octave 6)
$ sometimes (# velocity 0.6)
$ struct "t([9|13]*16,16,1)"
$ n (scale "minor" (sometimes rev $ "[0 2 3 4 6 7 6 [8|10]]*2"))
|+ n "<6 1 4 4 3!4>" |+ n "-7"
# sound "superpiano" # velocity 0.5 # sustain 7
(@cleary that piano sounds so good, really curious if you have any composition/variation techniques to share?)
- sounds nice! 2. this has me confused:
why does it create rests and parallel events? Simplified (and using fast only to show more cycles):
draw $ fast 3 $ "a b c"
|abcabcabc
draw $ fast 3 $ rev $ "a b c"
|cbacbacba
draw $ fast 3 $ sometimes rev $ "a b c"
|.bcabc.bc
|..a.....a
rests and parallel notes definitely make the piece more interesting (less uniform). But why exactly does sometimes rev work that way?
I suspect it's because sometimes operates on an event in isolation, rather than a cycle (see someCycles) - so in your example the two a's were subtracted from the original pattern as individual events:
|a........| -> rev -> |........a|
|......a..| -> rev -> |..a......|
Add/blend the two resulting patterns -> |..a.....a| and you get your result.
Without deferring to the specific detail of the sometimes function innards, this makes sense to me, at least 
Thanks! brain is not in the space to parse old code ideas atm, but let me consider it and I'll write something if I can come up with anything useful 
Ah, nice, that cleared up gap of knowledge on my side: I thought that sometimes did what someCycles actually does:
draw $ fast 3 $ someCycles rev $ "a b c"
[1 cycle]
|cbaabccba
giving the expected (by me) sequential output.
Merging your graph, and my example, sometimes works like this:
input pattern: abc
randomly split into .bc
a..
apply rev to second: .bc
..a
resulting in a rest and a double note (a and c).
From the docs
- | Use @sometimesBy@ to apply a given function "sometimes".
I never got the idea to look for another some* function. (Docs of someCycles refer to sometimes but not other way around.)