Re #1, my strategy is to make `task ready` my "home base" of sorts. `task ready` shows you only tasks that aren't blocked or scheduled for the future. In other words, tasks that are ready to be done ASAP.
My daily flow is to try and clear my plate, i.e. reach "Inbox Zero" with my `task ready` view. Every task in that view needs to either be completed or rescheduled for a time that I think I have a chance at completing it.
As for projects with tasks that block other tasks (e.g. write chapter 1 is "next," and it is the blocker for anything else, like writing chapter 2), you can tell Taskwarrior to hide them from your `task ready` view by using the `depends` property. For example, if "write chapter 1" is task 42, then I might add a task like `task add 'write chapter 2' depends:42`. Until I mark task 42 (writing chapter 1) as done, "write chapter 2" won't show up in my `task ready` view and I'm free not to think about it.
I just deployed a new version of Alda earlier this afternoon (alda 0.4.5) -- it should update for you the next time you run Alda. This new version has better default behavior for logging, i.e. not dumping a bunch of debug logs onto your screen :)
1. I do have plans to implement start and end points for playback, either in the form of minute/second markings or the already-implemented "markers" you can place in an Alda score. I agree this is a crucial feature -- it will be very useful when working on one small part of a large score. Eventually you should be able to do something like: "alda play --file my-score.alda --start 0:30 --end chorus"
2. Not yet -- I'm hoping we'll implement a way to generate LilyPond ( http://lilypond.org ) typeset scores from Alda code.
3. My philosophy on bar lines (and the reason why Alda ignores them as if they were comments) is that they're essentially "invisible to the ears," and so they don't serve much purpose except as a way to visually organize your score file. However, in order to generate sheet music (e.g. by generating LilyPond code), we will probably end up making them significant to the parser after all. I can see how it might be useful to think of your score in terms of measures, e.g. "play a few eighth notes, then rest until the end of the measure," so I'm certainly open to the idea of implementing measures.
Also in regards to the parent's interest in having a keybind to autoplay alda files, there is https://github.com/lsegal/atom-runner and with a short snippet in your config you'll have `alt-r` recognize alda files and play them!
For the language-alda package, I'm working on integrating autocomplete support for instruments, markers and attributes. I think I can also add support for atom-runner directly through the language package too.
Between playing around with the langauge and getting tooling support in Atom, my whole Sunday was completely swallowed up! :P
Not yet -- I've had this feature on my mind for a long time, though. It's pretty high up on the to-do list.
This is far from ideal, but as a workaround, you could set up a sound recording program like Audacity to record system audio output and play your score.
Hopefully in the near future you'll be able to do something like "alda play --file my-score.alda --output my-file.wav" or something to that effect.
I think this is a key thing to notice about Alda. It doesn't attempt to provide abstractions for things like keys, scales, or even measures and time signatures. It's more like writing Markdown: you already know what you want to write; it just gives you a way to represent it in a compact way and turn it into something you can hear back without having to reason too much about what you've written. I want Alda to be as close as possible to a sheet of staff paper that you can write notes on. MML is a very similar language in this regard. The idea is that it's up to the composer to write down the exact notes he/she wants, exactly how he/she wants them.
I realize this is disappointing if you're looking for something with more abstractions, but on the bright side, I think there are some great languages out there that do exactly that. If you haven't already, have a look at Music-Suite ( http://music-suite.github.io/docs/ref ) and Overtone ( http://overtone.github.io ), along with the Leipzig library, which adds functional programming abstractions for use with Overtone ( https://github.com/ctford/leipzig )
