Skip to content

Latest commit

 

History

History
318 lines (176 loc) · 15 KB

CHANGELOG.md

File metadata and controls

318 lines (176 loc) · 15 KB
Raw

CHANGELOG

1.0.0-rc10 (2/28/16)

  • Fix parsing bug re: placing an octave change before the slash in a chord instead of after it, e.g. b>/d/f (#192 - thanks to elyisgreat for reporting!)

1.0.0-rc9 (2/21/16)

  • Fix parsing bug re: starting an event sequence with an event sequence. (#187 - Thanks to heikkil for reporting!)
  • Fix similar parsing bug re: starting a cram expression with a cram expression.

1.0.0-rc8 (2/16/16)

  • You can now update to the latest version of Alda from the command line by running alda update. (jgkamat)

  • This will be the last update you have to install manually :)

1.0.0-rc7 (2/12/16)

  • Fixed a bug that was happening when using a cram expression inside of a voice. (#184 -- thanks to jgkamat for reporting!)

1.0.0-rc6 (1/27/16)

  • Fixed a bug where voices were not being parsed correctly in some cases (#177).

1.0.0-rc5 (1/24/16)

  • Added midi-percussion instrument. See the docs for more info.

1.0.0-rc4 (1/21/16)

  • Upgraded to the newly released Clojure 1.8.0 and adjusted the way we compile Alda so that we can utilize the new Clojure 1.8.0 feature direct linking. This improves both performance and startup speed significantly.

1.0.0-rc3 (1/13/16)

  • Support added for running Alda on systems with Java 7, whereas before it was Java 8 only.

1.0.0-rc2 (1/2/16)

  • Alda now uses JSyn for higher precision of note-scheduling by doing it in realtime. This solves a handful of issues, such as #134, #144, and #160. Performance is probably noticeably better now.
  • Running alda new now asks you for confirmation if there are unsaved changes to the score you're about to delete in order to start one.
  • A heaping handful of new Alda client commands:
    • alda info prints useful information about a running Alda server
    • alda list (currently Mac/Linux only) lists Alda servers currently running on your system
    • alda load loads a score from a file (without playing it)
      • prompts you for confirmation if there are unsaved changes to the current score
    • alda save saves the current score to a file
      • prompts you for confirmation if you're saving a new score to an existing file
      • alda new will call this function implicitly if you give it a filename, e.g. alda new -f my-new-score.alda
    • alda edit opens the current score file in your $EDITOR
      • alda edit -e <editor-command-here> opens the score in a different editor

1.0.0-rc1 (12/25/15) 🎄

  • Server/client relationship allows you to run Alda servers in the background and interact with them via a much more lightweight CLI, implemented in Java. Everything is packaged into a single uberjar containing both the server and the client. The client is able to manage/start/stop servers as well as interact with them by handing them Alda code to play, etc.
  • This solves start-up time issues, making your Alda CLI experience much more lightweight and responsive. It still takes a while to start up an Alda server, but now you only have to do it once, and then you can leave the server running in the background, where it will be ready to parse/play code whenever you want, at a moment's notice.
  • Re-implementing the Alda REPL on the client side is a TODO item. In the meantime, you can still access the existing Alda REPL by typing alda repl. This is just as slow to start as it was before, as it still has to start the Clojure run-time, load the MIDI system and initialize a score when you start the REPL. In the near future, however, the Alda REPL will be much more lightweight, as it will be re-implemented in Java, and instead of starting an Alda server every time you use it, you'll be interacting with Alda servers you already have running.
  • Starting with this release, we'll be releasing Unix and Windows executables on GitHub. These are standalone programs; all you need to run them is Java. Boot is no longer a dependency to run Alda, just something we use to build it and create releases. For development builds, running boot build -o directory_name will generate alda.jar, alda, and alda.exe files which can be run directly.
  • In light of the above, the bin/alda Boot script that we were previously using as an entrypoint to the application is no longer needed, and has been removed.
  • Now that we are packaging everything together and not using Boot as a dependency, it is no longer feasible to include a MIDI soundfont with Alda. It is easy to install the FluidR3 soundfont into your Java Virtual Machine, and this is what we recommend doing. We've made this even easier (for Mac & Linux users, at least) by including a script (scripts/install-fluid-r3). Running it will download FluidR3 and replace ~/.gervill/soundbank-emg.sf2 (your JVM's default soundfont) with it. (If you're a Windows user and you know how to install a MIDI soundfont on a Windows system, please let us know!)

0.14.2 (11/13/15)

  • Minor aesthetic fixes to the way errors are reported in the Alda REPL and when using the alda parse task.

0.14.1 (11/13/15)

  • Improved parsing performance, especially noticeable for larger scores. More information here, but the TL;DR version is that we now parse each instrument part individually using separate parsers, and we also make an initial pass of the entire score to strip out comments. This should not be a breaking change; you may notice that it takes less time to parse large scores.

  • As a consequence of the above, there is no longer a single parse tree for an entire score, which means parsing errors are less informative and potentially more difficult to understand. We're viewing this as a worthwhile trade-off for the benefits of improved performance and better flexibility in parsing as Alda's syntax grows more complex.

  • Minor note that will not affect most users: alda.parser/parse-input no longer returns an Instaparse failure object when given invalid Alda code, but instead throws an exception with the Instaparse failure output as a message.

0.14.0 (10/20/15)

  • Custom events can now be scheduled via inline Clojure code.

  • Added electric-bass alias for midi-electric-bass-finger.

0.13.0 (10/16/15)

  • Note lengths can now be optionally specified in seconds (c2s) or milliseconds (c2000ms).

  • Repeats implemented.

0.12.4 (10/15/15)

  • Added :quit to the list of commands available when you type :help.

0.12.3 (10/15/15)

  • There is now a help system in the Alda REPL. Enter :help to see all available commands, or :help <command> for additional information about a command.

0.12.2 (10/13/15)

  • Fix bug re: nested CRAM rhythms. (#124)

0.12.1 (10/8/15)

  • Fix minor bug in Alda REPL where ConsoleReader was trying to expand ! characters like bash does. (#125)

0.12.0 (10/6/15)

0.11.0 (10/5/15)

  • Implemented code block literals, which don't do anything yet, but will pave the way for features like repeats.

  • alda-code function added to the alda.lisp namespace, for use in inline Clojure code. This function takes a string of Alda code, parses and evaluates it in the context of the current score. This is useful because it allows you to build up a string of Alda code programmatically via Clojure, then evaluate it as if it were written in the score to begin with! More info on this in the docs.

0.10.4 (10/5/15)

  • Bugfix (#120), don't allow negative note lengths.

  • Handy alda script task allows you to print the latest alda script to STDOUT, so you can pipe it to wherever you keep it on your $PATH, e.g. alda script > /usr/local/bin/alda.

0.10.3 (10/4/15)

  • Fix edge case regression caused by the 0.10.2.

0.10.2 (10/4/15)

  • Fix bug in playback from/to options where playback would always start at offset 0, instead of whenever the first note in the playback slice comes in.

0.10.1 (10/4/15)

  • Fix bug where playback hangs if no instruments are defined (#114) May have also caused lock-ups in other situations also.

0.10.0 (10/3/15)

  • from and to arguments allow you to play from/to certain time markings (e.g. 1:02 for 1 minute, 2 seconds in) or markers. This works both from the command-line (alda play --from 0:02 --to myMarker) and in the Alda REPL (:play from 0:02 to myMarker). (crisptrutski)

  • Simplify inline Clojure expressions -- now they're just like regular Clojure expressions. No monkey business around splitting on commas and semicolons.

Breaking changes

  • The alda script has changed in order to pave the way for better/simpler inline Clojure code evaluation. This breaks attribute-setting if you're using an alda script from before 0.10.0. You will need to reinstall the latest script to /usr/local/bin or wherever you keep it on your $PATH.

  • This breaks backwards compatibility with "multiple attribute changes," i.e.:

      (volume 50, tempo 100)

    This will now attempt to be read as a Clojure expression (volume 50 tempo 100) (since commas are whitespace in Clojure), which will fail because the volume function expects only one argument.

    To update your scores that contain this syntax, change the above to:

      (do (volume 50) (tempo 100))

    or just:

      (volume 50) (tempo 100)

0.9.0 (10/1/15)

  • Implemented panning via the panning attribute.

0.8.0 (9/30/15)

  • Added the ability to specify a key signature via the key-signature attribute. Accidentals can be left off of notes if they are in the key signature. See the docs for more info on how to use key signatures. (FragLegs/daveyarwood)

  • = after a note is now parsed as a natural, e.g. b= is a B natural. This can be used to override the key signature, as in traditional music notation.

0.7.1 (9/26/15)

  • Fixed a couple of bugs around inline Clojure code. (crisptrutski)

0.7.0 (9/25/15)

New features

  • Alda now supports inline Clojure code! Anything between parentheses is interpreted as a Clojure expression and evaluated within the context of the alda.lisp namespace. To preserve backwards compatibility, attributes still work the same way -- they just happen to be function calls now -- and there is a special reader behavior that will split an S-expression into multiple S-expressions if there is a comma or semicolon, so that there is even backwards compatibility with things like this: (volume 50, tempo! 90) (under the hood, this is read by the Clojure compiler as (do (volume 50) (tempo! 90))).

Breaking changes

  • Alda no longer has a native (* long comment syntax *). This syntax will now be interpreted as a Clojure S-expression, which will fail because it will try to interpret everything inside as Clojure values and multiply them all together :) The "official" way to do long comments in an Alda score now is to via Clojure's comment macro, or you can always just use short comments.

Other changes

  • Bugfix: The Alda REPL :play command was only resetting the current/last offset of all the instruments for playback, causing inconsistent playback with respect to other things like volume and octave. Now it resets all of the instruments' attributes to their initial values, so it is truly like they are starting over from the beginning of the score.

0.6.4 (9/22/15)

  • Bugfix: parsing no longer fails when following a voice group with an instrument call.

0.6.3 (9/19/15)

  • Fixed another regression caused by 0.6.1 -- tying notes across barlines was no longer working because the barlines were evaluating to nil and throwing a wrench in duration calculation.

  • Added a --tree flag to the alda parse task, which prints the intermediate parse tree before being transformed to alda.lisp code.

0.6.2 (9/18/15)

  • Fixed a regression caused by 0.6.1 -- the barline function in alda.lisp.events.barline wasn't actually being loaded into alda.lisp. Also, add debug log that this namespace was loaded into alda.lisp.

0.6.1 (9/17/15)

  • Bar lines are now parsed as events (events that do nothing when evaluated) instead of comments; this is done in preparation for being able to generate visual scores.

0.6.0 (9/11/15)

0.5.4 (9/10/15)

  • Allow quantization > 100% for overlapping notes. (crisptrutski)

0.5.3 (9/10/15)

Exit with error code 1 when parsing fails for alda play and alda parse tasks. (MadcapJake)

0.5.2 (9/9/15)

  • Bugfix: add any pre-buffer time to the synchronous wait time -- keeps scores from ending prematurely when using the alda play task.
  • Grammar improvement: explicit octave-set, octave-up and octave-down tokens instead of one catch-all octave-change token. (crisptrutski)

0.5.1 (9/8/15)

  • Pretty-print the results of the alda parse task.

0.5.0 (9/7/15)

  • New Alda REPL commands:
    • :load loads a score from a file.
    • :map prints the current score (as a Clojure map of data).
    • :score prints the current score (Alda code).

0.4.5 (9/7/15)

  • Turn off debug logging by default. WARN is the new default debug level.
  • Debug level can be explicitly set via the TIMBRE_LEVEL environment variable.

0.4.4 (9/6/15)

  • Bugfix/backwards compatibility: don't use Clojure 1.7 update command.

0.4.3 (9/5/15)

  • Don't print the score when exiting the REPL (preparing for the :score REPL command which will print the score whenever you want.

0.4.2 (9/4/15)

  • help and version tasks moved to the top of help text

0.4.1 (9/4/15)

  • alda help command

0.4.0 (9/3/15)

  • alda executable script
  • version number now stored in alda.version
  • various other improvements/refactorings

0.3.0 (9/1/15)

  • Long comment syntax changed from #{ this } to (* this *).

0.2.1 (8/31/15)

  • alda play task now reports parse errors.

0.2.0 (8/30/15)

  • alda.sound/play! now automatically determines the audio types needed for a score, making alda.sound/set-up! <type> optional.

  • various internal improvements / refactorings

0.1.1 (8/28/15)

  • Minor bugfix, track-volume attribute was not being included in notes due to a typo.

0.1.0 (8/27/15)

  • "Official" first release of Alda. Finally deployed to clojars, after ~3 years of tinkering.