Fork me on GitHub

Hi, Iam newbie Linux user and i wanna try install Alda but there is some problem /alda$ bin/alda play --code "piano: c6 d12 e6 g124" clojure.lang.ExceptionInfo: java.lang.IllegalArgumentException: No such task (bin/alda) data: {:file "/tmp/boot.user6319139997439029247.clj", :line 17} java.util.concurrent.ExecutionException: java.lang.IllegalArgumentException: No such task (bin/alda) java.lang.IllegalArgumentException: No such task (bin/alda) boot.core/construct-tasks core.clj: 665 ... clojure.core/apply core.clj: 630 boot.core/boot/fn core.clj: 699 clojure.core/binding-conveyor-fn/fn core.clj: 1916 ... Can you help me?


hi @danielvagina that's a strange error... it's almost like the alda task-runner script is trying to run itself as a task, which makes no sense


there are a few pieces of info you could give me that will help me figure out the problem


could you run the following and paste the output?


(in the same directory that you ran the above)


cat bin/alda


bin/alda version


boot --version


java -version


i am unable to reproduce this error locally -- when i run the same command in the alda project directory, i hear the chorus hook from "too many cooks" 🎶


it may be useful to make sure that you have the latest boot and the latest alda


What I exatly shoud have in the first line of Alda !#??????


Hello, Thank you for response. What I exactly shoud have in the first line of Alda file !#??? Thank you so much


you don't need anything special in the first line of an alda score -- you can just start writing alda syntax


e.g. this is an example of a valid alda score file:

piano: c d e f g a b > c


So I was researching tori for my cellular automata library and came across a couple of interesting links that relate a torus to music theory. Thought some of you music folks might find them interesting:


I haven't gotten around to generating fractal music yet, but if anyone else is interesting in taking a shot at it my ergo library is shaping up and does a good job at supporting L-systems. I'm still working on the cellular automata support, but that is coming along nicely as well.


Awesome. Yes, if you look at Neo-Riemannian music theory in particular, David Lewin describes the system of harmony in late romantic music using a hyper-torus


In particular, there are three operations that map a triad to another triad with two common tones, called P, L and R, each of which are involutions. I think it would possible to describe these within the L-System thing you’re working on


This was first introduced in the “Generalized Music Interval and Transformation Sytems” and has been expanded on quite a bit. One such variation by Adrian Childs adds the handling of tetrachords, especially sevenths and uses this system to analyze some Wagner passages that are particularly challenging within typical roman numeral analysis


@meow: I’d be very interested if you start anything in this direction. IDK if I have time to commit to it ATM but would love to eventually


@csmith: I don't have any background in music theory, so it's going to take me a while.


ok no worries. I’m familiar with CA but haven’t really seen L-system before. I half-understand it I guess.


I have a lot of background in music theory. LMK if maybe you have specific questions or things you want to look at that I can point you to


My main interest is in developing a toolkit to make it easy to use generative code and custom rules to create sequences of commands that get rendered graphically or musically.


If you look at L-systems you'll see that they are very simple, but can be powerful.


The code in ergo pretty much supports every known variation of L-systems, many of which have formal names that are basically BS, imnsho.


They reflect poor or shortsided implementations or mathematicians trying to represent everything on paper.


sounds cool


My half-understanding so far makes me think that the neo-riemanian stuff would be appropriate. A lot of folks have done various group theory things with them


I think my implementation solves all these limitations. The potential is that even with the poor implementations out there, L-systems are used to model plant growth, caves, architecture, game content, music, fractals, crystals, etc. Lots of potential.


I have a cellular automata runner in C with OpenGL that is programmable in Scheme. It’s super fun but somewhat limited by what CA’s do, though some “impurity” WRT a true CA is allowed


so, interested in something that generalizes and takes similar stuff abit farther


I'd be interested to know what you think of my approach to the CA stuff. It's been influenced by having started with the L-systems and after many iterations coming up with this nice function that drives everything:

(defn produce
  "Returns a lazy sequence of colls from a recursive, axiomatic, transducible
  [seed prep-f get-xf]
  (letfn [(process
              (when (seq coll)
                (let [new-coll (into (empty coll) (get-xf coll) (prep-f coll))]
                  (cons new-coll (process new-coll))))))]
    (process seed)))


Those examples show a range of features, letting you express more and more in the rules


looks cool. Have you worked on game of life?


its in the core file as an example: (-> (ca-builder :conway-game-of-life cell (pattern :acorn)) (nth 10))


heh ah nice ok


I started putting the various rules in a map:

(def cellupedia
   {:S #{2 3} :B #{3} :N neighbor-freq-8}
   {:S #{1} :B #{1} :N neighbor-freq-8}
   {:S #{1 3 5 7} :B #{1 3 5 7} :N neighbor-freq-8}
   {:S #{1 3 5 7 9} :B #{1 3 5 7 9} :N neighbor-freq-9}


Very nice, I recognize how you’ve done the survive/birth thing. Can you support CA’s with > 2 states?


Like I did with the L-systems, I want to push the CA stuff to the limits.


So multiple states and cells with other attributes, like age or color.


Haven't done it yet, but that's the plan.


right, nice


Brian’s brain and wireworld are some cool ones with 3 or 4 states


Yeah, I haven't done those before, so it should be interesting.


But this is LISP, so I should be able to do anything, right? simple_smile


hah indeed. These are fairly straightforward/typical but I don’t htink they are representable with survival/birth


I also want to look into the predator/prey type CAs as well.


The langton’s ant/termite one suggests an “actor model” type of CA too


if this is helpful at all, it is consumed by some nasty C code:


My plan is to attempt to do them all, while abstracting out the commonalities and decomplecting as I go, so that the resulting functions can be recombined in ways that haven't been done before, rather than just doing the same old same old.


Putting it all in one file and making existing functions (like the process function that I love so much) work for all cases, is forcing me to look at these problems from a different point of view that I think will be useful and meaningful. Plus the goal is to use these to generate data to drive the creation of music, so that's different as well.


Gotta take a break. Will look at your code. Any kind of feedback on my stuff is most welcome as well.


Sure thing. I’ll spend some time wrapping my head around it. LMK if I can be help WRT music theory or if somehow my CA work can be of use (though I doubt that part)


(mostly made that project to exercise some C chops and learn how to integrate Scheme)


Yeah, like I said I really know very little about music theory so I'd love to have someone help with that.


Thanks. simple_smile


np, and thank you.


@csmith: The docstring in this file will get you up to speed on L-systems really fast:


That's where I had the code before I moved it into core, so the code is bit out of date, but the docstring still applies.


And I've got a devcard where I use ergo to draw a dragon fractal here:


Basically it shows how to drive a turtle graphic, like this:

(defn dragon-sequence
  "Returns a lazy sequence of vectors."
  (let [axiom [:F :x]
        rules {:x [:x :+ :y :F :+]
               :y [:- :F :x :- :y]}]
    (basic-system axiom rules)))

(def dragon-render-rules {:F [:fwd 20]
                          :+ [:right 90]
                          :- [:left 90]
                          \[ [:save]
                          \] [:restore]
                          :x []
                          :y []})

(defn dragon-render-sequence
  (map #(into [] (comp (replace dragon-render-rules) cat) %) (dragon-sequence)))


All you'd have to do to make music instead is to map some rules that change the render commands into Alda commands instead of turtle graphic commands.


At least that's a starting point.