POV-Ray : Newsgroups : povray.general : gamma issues 3.8 : Re: gamma issues 3.8 Server Time
19 Apr 2024 13:37:11 EDT (-0400)
  Re: gamma issues 3.8  
From: clipka
Date: 16 Jun 2021 16:26:32
Message: <60ca5e78$1@news.povray.org>
Am 16.06.2021 um 20:14 schrieb ingo:
> When I move I put dates on boxes. Boxes that have not been opened are
> thrown out unopnend after two years unless they have a red sticker.

So, following that logic, should we just throw away all the sample 
scenes altogether? ;)

> Thinking about this and backwards compatibilty, would it be easier to keep
> a few startegic versions of POV-Ray running, executing, compiling for
> current and future compilers and OS's (3.1g, 3.5, 3.7)? This could give a
> dev more freedom to break things and probably to keep the source cleaner?
> It would also kind of solve the old image problem.

For a purely command-line only thingumajig - no graphical output 
whatsoever - that might be feasible. But porting a graphical user 
interface between different OS versions, different operating systems, 
hardware platforms etc. over and over again... that will almost 
inevitably lead to feature rot, as features not easily portable and not 
strictly necessary will be "temporarily" disabled, others not necessary 
on a particular platform will be amputated and not revived when ported 
to a platform that might benefit from it, and so on...

In the end, the UI versions of the old pieces of software will become 
unusable hunks of rotted code, that aren't worthy of keeping alive.

And then some day command-line interfaces may go out of fashion 
entirely, and the command-line-only strain of the software will suffer 
the same fate, too.

Also, each time the programming language standards change, the old code 
will have to be adapted to work with the new standard. Same deal there: 
Code that was originally clean and sane becomes patched up only at the 
edges that openly exhibit issues, while other portions may be forgotten 
and quietly slip out of alignment, until some day the whole thing comes 
crashing down, because at its core, hidden under layers of patches, its 
bones have become brittle. And the libraries our code relies on will 
also be moving targets, which will break stuff every now and then. Which 
is especially problematic when it's something we're using as extensively 
as the boost thread library.

At some point in time, it will probably be easier to just install an 
emulator or virtual machine, and run old binaries that way.

We've been doing something along those lines with POV-Ray v3.7, at least 
as far as the Unix version goes - putting out maintenance releases to 
keep it compatible with whatever comes our way. But we won't be able to 
keep it supported forever, especially on the Windows platform. We'd 
eventually need to write a brand new front-end for it. Which takes time 
and energy, because the front-end interface differs from that of v3.8. 
And eventually v3.7 will succumb to boost rot, because newer versions of 
boost will grow more and more incompatibilities with our code, and 
eventually cease to even support what we're using it for, because that 
portion of boost is effectively outdated already; while the older 
versions of boost will grow more and more incompatibilities with modern 
compilers, and be unavailable for more and more modern target platforms. 
And ripping out boost and replacing it with something else may turn out 
to be more work than it's worth, due to how intensively we were using it 
in v3.7. At that point, v3.7 will go the way of the Dodo.

The good news is that v3.8 will be reasonably close to v3.7 in its 
behavior, and hopefully work as a plug-in replacement. And work for 
ripping out boost (the most extensively used portions anyway) had almost 
finished in v3.8 (in fact it had, but we're reverting back to before 
that for v3.8.0), so it'll be much less susceptible to poorly aging 
libraries, and thus might be a lot easier to keep alive in the long run 
than poor old v3.7.

In fact, it might even be easier to revive any of the older versions 
than to keep v3.7 alive. v3.6.2 and earlier versions didn't use boost at 
all. Of course they also didn't support multithreading.

Well, so much for my crystal ball peek into the future, anyway. Only 
time will tell how much I'm over- or underestimating the troubles involved.

> Dreaming, maybe a future povray parser could just start an other engine
> depending on the #version of the scene file.
> (I have no idea of the complexity of all that)

That won't fly at all. At best, the combo of parser and render engine 
could be exchanged. But even that would require a well-defined interface 
to plug those pieces into a front-end. We don't have such a thing at 
present, and I dare say we never will. Not a stable one, at any rate. 
Which defies the whole idea. Oddly enough, we'll probably continue trying.

Well, actually we currently have _two_ such interfaces: The POVMS 
interface and the VFE. Neither is anywhere close to intuitive though (at 
least *I* haven't gotten a good grasp on either of them yet, and it's 
not like I'm totally new to the source code), and I wouldn't want to 
have to interface to either of them. And neither seems to be 
particularly suited to just exchanging the back-end on the fly.

> Is there anything of a time frame, weeks, months, less than a year and a
> halve? Currently my time is limited but it will change towards the end of
> the year.

Folks at dev team level are itching to get v3.8.0 out as soon as quality 
concerns permit. I'm pretty sure we'll have the first beta before the 
month is over. How quickly things progress from then on depends; my 
estimates vary between anything from another month (when I'm feeling 
excessively optimistic) to half a year (when I'm extrapolating from past 
frustration). It certainly won't take as long as the v3.7.0 beta phase.

Post a reply to this message

Copyright 2003-2023 Persistence of Vision Raytracer Pty. Ltd.