Marcus,
Who is talking about precompiled dependencies? I'm talking about
depenendency sources. I agree that there would be issues with
precomplied dependencies (although I would still argue checking those
in would be btter than nothing) but I think checking in dependency
sources solves those issues.
Also, I think a lot of the things you bring up as "problems" of having
the dependencies checked in, is in fact a problem that exists whether
or not you have the dependencies checked in. It's simply that having
the dependencies checked in makes these existing problems much more
obvious (which is a big sign to me that it is a very good idea)
On 7/11/07, [EMAIL PROTECTED] <[EMAIL PROTECTED]> wrote:
Putting in precompiled dependencies would only make sense, if
a) someone takes care of their maintenance (updates, bug fixes, integration
testing)
It seems like this is always a problem if you want to use a different
version of the dependencies than you used before, regardless of
whether you check dependencies in to svn. i.e. If svn pygame was last
built and tested against sdl 1.2, and sdl 2.0 comes out, you have to
find the updated sdl, integrate and test with the sdl changes.
Heck, if anything, checking in the last blessed sdl source makes these
kinds of problems much easier. For instance, when the bug comes up you
can use svn diff to see exactly how sdl 2.0 changed since 1.2. Also if
a bug comes up in pygame testing after making a build with a new
version of a dependency, and you trying to figure out why, you can
pull the last tested dependency and test with that.
b) they are restricted to some platforms (to be precise: windows (and maybe
MacOS))
The sources are all either cross platform already, or the depend is
particular to certain platforms and not needed for others (in which
case the problem is already solved by pygame build process)
c) multiple distributions are supplied (one with the deps, one without, one
source dist with the deps, one without, etc.)
First, why would you need to have a distro without the dependencies?
the one with them is a super-set of the one without. And even if you
did need one without, what the heck is so hard about making your gzip
or svn command not get the dependency directory contents?
That is an incredibly huge task and as soon as you get into the trouble of
having own installed shared library versions, the whole thing might completely
fail (especially if you link against e.g. a newer distributed shared
library but the library manager resolves your other older one at runtime).
Again, you are blaming a preexisting problem here on having
dependencies checked in. In particular, if you are having pygame build
and link against your own installed shared library versions, then it
means you may be having pygame link and run against a version of the
lib which it was neither designed nor tested for. Also, the problem of
having the library manager resolve to a different version of the lib
at runtime than the compiler resolved to at compile time happens to
people with our current set up (you can find instances of this
happening in the mailing list archive with sdl_image). I can easily
take any system in the world and install a prebuilt shared version x
of some lib, and then install version y's sources - what does that
have to do with checking in dependencies or not?
...But lets say you do want to build against your own shared library
versions, and svn includes the "blessed" source versions of the
dependencies - what's the big deal? I can change a build option, I can
delete the depend sources from svn in my local copy, or I can copy
whatever version I want.
Also, when I install pygame, it comes with the sdl it was built with,
making this whole thing a non-issues. Why wouldn't it be a good thing
to make it easier for me to build the pygame I got myself?
Instead a build script, which takes care of building all the dependencies the
user downloaded and put into some predefined directory, would make more sense.
I think you are being somewhat blind to the issue that that system is
not working well for a number of people. It's not working for me, it's
not working for DR0ID and on the archives of this list you can find a
lot of other people who have said they weren't able to find the
dependencies to build.
A system that requires the users to go find their own dependencies and
run the build script may make more sense to you, but it seems to not
be effective to me.
---
If you see something I am not understanding, or something I don't know
about the linux way to do things that makes checked in dependencies a
problem, please correct me.
