Re: [rox-devel] injector vs DIY

[<pi...@wg...>]

On Sat, Aug 06, 2005 at 11:18:40PM +0200, Jonatan Liljedahl wrote:
> Maybe the injector system is great stuff for some, but I still prefer to
> download a tarball and install an appdir in my systemwide /ROX-Apps. I
> feel that the point with self contained appdirs gets a little bit lost
> if the appdir is just a wrapper and the real app hides in ~/.cache...

I feel similar about the wrappers, but i like the auto download and
verification stuff.  The concept of defining interface uris is also
quite compelling.  In order to provide some productive criticism, here
are some thoughts...

1. 0install / lazyfs vs injector:

Leave alone the portibility problems for a moment.

The great thing about 0install was, that i did not have to download and
verify stuff and that i did not have to search through web pages to find
software.  It also simplified communication between people, because you
could relieably tell someone over the phoneline, where his app resides.
That is, a plain path that everyone understands at once.

The system works a bit like narrowing the chaos down to a reasonable
rox-apps centric view (people are responsible for this, of course).
Complexity is reduced to just the filesystem interface (which everyone
should understand).  It promised to provide unique (platform
independent), static names for software (the point why communication is
improved).  Every user can then create his or her own personal view with
links.  This way, the true nature is not hidden.

Injector provides static names by means of interface definitions, too.
The big difference is, that with 0install, i just create a link where i
get a wrapper with the injector.
The wrapper unnecessarily hides information and leads to a strange
feeling, because i cannot just "shift-click" the app anymore to see it's
internals.  It also becomes considerably harder, to see what is actually
in use.  The link depicts what is going on straight forward.

Consider someone calling in and asking where to find the FooBar app.
0install: I hover over my apps/FooBar link and get some quite expressive
          tooltip that i cite to the guy and tell him to open the file
	  with rox.
Injector: I open the apps/FooBar menu and click on Version.  Then i
          click on the item in the list, then i click on Interface
          Properties.  This is the point where i can answer and have
          three windows open instead of one.
          And now the guy tells me that he opend the link in his browser
          and it shows some strange stuff... :)

The main difference is that the interface is just nothing you can open
in rox directly.  The wrapper script presents a way more confusing
information and the feeling gets more windowish or overcomplicated,
because i have to use menues and additional windows again, to get to the
point.  You cannot rely on "look inside" anymore if you want to learn
about the application.
I remember that there has been some discussion because the menues were
too complicated some time ago.  The Injector makes it even worse.  It
just feels unroxish.  0install felt very fitting (it has it's problems,
of course).


2. The Injector interface definitions:

A few things that circle my mind...
What i found a bit strange is, that the Interface definition is also the
place (and the only place AFAIK) where the implementations are listed.

Consider the following problem:

Interface: http://example.com/2005/if/posix/sh
Implementation: ...bash
Implementation: ...ash

Or think about bash:
Implements: http://example.com/2005/if/sh/functions
Implements: http://other.example.com/2005/expansion

How would i implement a replacement ROX-Lib?
Are ROX-Lib and ROX-CLib implementing the same interface?

I was wondering, if it wouldn't be more fitting to have the interface
and the implementation be seperated.  Take the icon element for
instance.  Does the interface really define the icon?  I would expect
that the icon that AddApp uses is implementation dependent.  The
interface might provide a default but that is for presenting the
interface meta without actually downloading the implementation.
Actually, the whole thing seems to me like a perfect use case for RDF.

Woohoo, this is long and confunsing again.
Hope you're still awake.

cheers, peter.