You are not logged in.

#1 2006-05-20 16:24:42

TPJ
Member
From: Gliwice, Poland
Registered: 2005-12-21
Posts: 33

An unusual framework

The problem

Everyone has to install some software sometimes. There are also cases, when many different pieces of software must be installed, a pieces, that are meant to work together in some way. Some of such a pieces of software are dependent on another pieces, some are independent. From now on I will call such a pieces of software a bunch of software.

Of course you can always use a package manager in such a case. But this is a problem with such a solution: there must be the proper packages for a given distro, for every piece of software in the bunch.

There are also cases, when you are a developer/packager, and you have to prepare a package (as a part of a bunch) meant for the beta-testers of your project. You might want to make such a package as easy to install (and use), as possible - for its end-user. Preparing such a package might help you get more beta-testers (as well as make your project more popular). But this is one essential problem with preparing such a package: since you don't know what the distro, that a beta-tester/end-user uses is, you should prepare package for all the available package managers, for all the available distros... This is, of course, impossible.

Besides, there are cases, when it's necessary to test many different installations of such a bunch (i.e. it might be necessary to test installations with different features enabled/disabled). In such a cases not only many packages should be prepared, for various distros, but also many different packages for a given distro should be made.

I think it would be too difficult to prepare such a packages.

My case is Python interpreter, some third-party Python modules, and some third-party Python software that I use for software development.


The solution

The only solution I can think of is a script, written in some very popular language (a one, that you could assume to be available on almost every distro, e.g. shell, Tcl, Python or Perl), that would be able to download all the needed sources, configure them (with the features, compiler flags, etc. defined by its user), build them, and then install them wherever its user would want the software to be installed. All of this provided that all the configuring/building tools are available, of course.

Since such a script would be able to download and install all the parts of a bunch (provided that all the necessary build tool would be available), and it would be written in some widely-used scripting language, one could say, that it would be a "distro-independent" solution to the problem.

A script would have more functionality, than most of the modern package managers: it would allow its users to enable/disable options, to set compiler flags, to install various parts of a bunch independently of each other, and to install them where its user would want them to be installed. It would be also possible to patch the downloaded sources before building any software - it all would depend on the script, on its functionality, made by the script's developer.

This "wonderful" script should be easy to use, even for an inexperienced user; it should has some GUI/TUI, and it should allow its user to do everything with the software, that can be done: installing/updating/uninstalling. A simple yet powerful tool.


Why not use the Autopackage or ZeroInstall? Because you have to install them first; the scripting languages like shells, Tcl, Python or Perl are installed on most of *nices today. So such a script would run on most of modern distros, without installation of any extra packages first.


I have already started to write such a script: I called it "Python Builder". But soon I realised one thing. If one day I decided to write, say, "Perl Builder", or "Open Office Builder", I would end up writing a very similar script.

So the idea of writing a framework for writing such a scripts was born.


With such a framework it would be possible to easy create scripts with the following features:
- choosing the pieces of software to install (from all the pieces in the bunch)
- choosing where all of them should be installed to
- automatically downloading all the needed sources, patches, etc.; patching the sources, if necessary
- managing the bunch: installing/uninstalling/updating all the pieces in a given installation
- choosing the features and the compilation options for all the pieces individually
- working independent (well... mostly) on a distro
- nice GUI/TUI for end-user

The idea exists, however I haven't started doing anything yet. I'd like to know what do you think about it. Isn't it reinventing the wheel, or rediscovering America? Wouldn't it be easier to use some of the already available tools? And what tools, then?

I haven't found any tools for such a purpose (and all the needed functionality) so far, but - I think - that's what this forum is for. Either you know such a tools, or such a project would be a needed tool (at least for myself) and it would be worth to work on such a framework.

Anyway, what do you think about it?

Offline

#2 2006-05-20 18:41:38

stavrosg
Member
From: Rhodes, Greece
Registered: 2005-05-01
Posts: 330
Website

Re: An unusual framework

If I read correct, gnome does that with garnome:
See http://www.gnome.org/projects/garnome/

My opinion is that nothing is better than a simple-yet-powerful package manager (like pacman wink)

Offline

#3 2006-05-20 23:13:20

test1000
Member
Registered: 2005-04-03
Posts: 834

Re: An unusual framework

autopackage installs itself when you download and installs an autopackage.


KISS = "It can scarcely be denied that the supreme goal of all theory is to make the irreducible basic elements as simple and as few as possible without having to surrender the adequate representation of a single datum of experience." - Albert Einstein

Offline

Board footer

Powered by FluxBB