16 May
2008
16 May
'08
9:53 p.m.
malnourite(a)gmail.com writes:
-+--- Overview - - -
The Non-DAW comprises a modular system. It would be convenient for
the author and the users alike if the state of Non-DAW's components
and other, entirely separate, programs could be managed together as a
coherent whole. The LASH system appears, at first glance, to support this
kind of arrangement. However, the current LASH API is overly complex and
lacking in what this author considers to be a basic level of functional
maturity. It is this confusion, I believe, which has resulted in the
poor adoption of LASH and its subsequent stagnation.
I think almost everybody dislikes the current API so you got some
followers for sure ;)
-+--- Basic Concerns - - -
Non-DAW, and other complex programs with large state which cannot
be held in RAM all at once, require a few things that LASH doesn't
currently provide. These needs include the following:
1. The need to know the LASH project path the moment it first joins the
LASH session at startup. If this were so it could start a new Non-DAW
project under the LASH project path and new captures would go in their
right place without any intervention by the user. To clarify: there
must be no time when Non-DAW is connected to LASH without knowledge
of the path to the current LASH project directory.
Do you need to know LASH project path or you need to know the directory
path where your project data resides? I think there is nothing wrong
with providing the later.
2. The need to be informed of, or else be able to
query at any time,
the LASH project name. If the LASH project path and the LASH project
name weren't different, we could get away with scanning the path for
the name, but this is unfortunately not the case.
I dont see anything wrong with this, we can have both query function and
signals. In fact we already have some signals to serve in the dbus branch.
Additionally, the following would be required in order
to fully integrate
with LASH (transparently to the user).
1. Ability to initiate new projects, choosing among a list of previously
recorded templates.
planned already
2. Ability to save the current project as a
template.
planned already
3. Ability to initiate a save of the entire LASH
project.
even non-dbus implementation has this AFAIK
4. Ability to choose from a list of LASH projects to
load.
already working. In dbus branch we have GetProjects method instead of
reading audio projects directory on client side.
Some of the above are already possible to some extent
with the current
API, but complicated greatly by the artificial division of the API into
client and control portions.
I think API division is right thing to have. However there should be no
artificial restriction of being both regular and control app. AFAIK it
is in Juuso's plans to remove this artificial restriction.
Non-DAW and Non-Sequencer have the ability to change
to a new project/song
without restarting, but LASH makes no use of this--always restarting
instances of these programs instead of reusing them. Of course,
Non-DAW and Non-Sequencer have extremely short startup times compared
to other programs in their class, but still, I would like to avoid the
distraction of many windows opening and closing at LASH project change
time--it reflects poorly on my and any other programs which can change
songs without crashing.
Maybe crazy idea, but we could have some of lash clients to export dbus
object to be controlled without restarting. And to make things even more
crazy, this matches my prefered "launch LASH apps only through lashd"
scenario. With apps being registered in database. So far we use existing
desktop entries infrastructure for launching apps through lashd. We
could use autolaunched dbus services too. Juuso, what you think?
I would also like to see the preferred behavior of
new/save/load
operations in all clients specified by LASH so as to avoid confusion
and potential data loss. Should any LASH client be permitted to save
or load to/from disk /it's own state/ without informing LASH? This may
seem harmless when the program state consists of a single file--as it
is assumed that a copy of that file will be saved by the program in the
LASH project directory whenever a LASH save is next performed. But now
the user has two (differing) copies of his file--and he isn't sure which
one he really edited--or where it is on disk. The problem becomes even
more serious when the program state includes a directory filled with
gigabytes of audio sources...
I agree. These things need to be documented.
Is it really advisable for LASH clients to operate on
their state,
which is supposedly under the control of LASH, as if it was theirs
alone--without informing LASH of their activities? I don't necessarily
know the answer to this question, but I do know that LASH needs to make
a recommendation of some kind regarding the expected behavior--whatever
it may be.
IMHO we should give recomendation but I'm against trying to force
things. We should the users participate in evolution instead of us
trying to enforce things as Gods of Code ;)
-+--- Additional Thoughts - - -
There are also many things which LASH /could/ do to enhance the
integration experience, but doesn't.
These include, but are by no means limited to, the following:
* Templating and layering functionality.
already planned
* Project grouping (eg. all songs for an album) for
easy management
of hundreds of projects. Please use subdirectories and/or symlinks
for this and not some XML junk.
already planned
* Global Undo/Redo functionality (simply sends a
message to all clients
asking them to undo/redo and possibly providing feedback), additionally,
we can envision storing state diffs on disk for clients with no native
undo capability--something akin having the state in a git repo could
be used, reloading a reconstruction of prior state upon an 'undo'
request)--this is only viable if LASH can reuse program instances.
not that i dislike the idea, but i prefer to defer such functionality
for later incarnation of LASH. Unless someone is really motivated to
work on this now.
* Looser integration with/no direct dependance on
JACK.
For LASH client or for lashd? I personally consider LASH tightly coupled
with JACK in the terms of user workflow. Thus I assume lashd and LASH
apps interacting directly with JACK. However, with jackdbus approach,
only LASH apps have direct dependance of JACK (i.e. are linked against
libjack). lashd uses jackdbus instead. LASH control app probably does
not interact with JACK server at all. The only possible exception I know
so far is to get JACK settings preset from JACK multiconfig object. But
I consider that separate module, not directly coupled with JACK itself.
I'll use this thread to announce the LADI project to this mailing
list. I maintain some documentation in my wiki:
http://nedko.arnaudov.name/wiki/moin.cgi/LADI
The above page has link to the "D-Bus interactions between components in
LADI system" diagram:
http://nedko.arnaudov.name/soft/ladi/ladi-dbus-interactions.png
There is also page dedicated to LASH in LADI system (LASH + D-Bus):
http://nedko.arnaudov.name/wiki/moin.cgi/lashdbus
--
Nedko Arnaudov <GnuPG KeyID: DE1716B0>
