Could someone with an appropriate background analyze the license in-depth?
Looks like it allows you to produce derivative products, which is great, however, it also forbids commercial use, meaning it's at least not at the same level as FSF- and OSI-approved licenses.
What really blows me away is how comparatively little the interface has changed over the years...not to sound dense, but it looks exactly like you'd expect Photoshop to look.
Pascal was the Mac OS programming language. The API had data types Str255 (Pascal string, maximum 255 character, in a 256-byte memory block), Str15 (same, max 15 characters, in a 16 byte block) and the like, and many of the higher-level calls used Pascl calling conventions (lower-level calls used a mish-mash of conventions for speed. For example, low-level file calls used a register to pass pointers to parameter blocks.
The section "Special Case Calling Conventions" lists all special cases. You get such cases as "Parameters are passed to the routine in registers A3 and D7, and output is returned in registers D2, D3, and D4".
"The majority of Lisa programs were written in the Pascal language by Apple with a few programs written in 68000 assembly language. To give an idea of the size of this effort the Lisa operating system was written in around 90,000 lines of Pascal and each Lisa program (eg LisaWrite) contained somewhere around 50,000 lines each."
Like others in this thread, I learned Pascal early on and was befuddled by C for a long time. I wrote some Pascal on my Apple //e, played with Lisa (had access thru work), completely missed the Mac boat, cut my teeth on TurboPascal. Gods, I loved Borland.
Amazingly this looks a lot like Borland's Turbo Pascal (later Borland Pascal, later Borland Delphi, then Embaradero something), which had lots of OO extensions over the years, designed by Andreas Hejlsberg (who went on to make C#).
In the golden age of Delphi, the language was pretty on par with today's Objective-C: Classes, late binding, properties, reference counting, modern strings, etc.
I wonder how much influence there was between the two.
Makes sense. As far as I can see, it was not directly copied from the Mac dialect; there are some differences, like how the Mac code requires methods in the declaration to be declared fully qualified with the full class name ("PROCEDURE TEraseAll.IEraseAll (view: TImageView);").
As other's note: Assembly and Pascal were the original system languages for the Macintosh. As I recall, C was not used until a year or two after the launch of the Mac when Lightspeed C was released. (Lightspeed was later renamed Think C)
Apple did not use C heavily until the OS was re-written in C++ in System 7 in 1991
Which spawned Apple's MPW IDE and their MacApp C++ framework, which ultimately gave way to Metrowerks CodeWarrior and the PowerPlant C++ framework. It's actually pretty amazing that for most of the 90s Apple let Metrowerks own the developer experience.
I always thought that Jobs' greatest triumph in pushing Rhapsody was bringing their developers back to using their own tools (though I suppose Carbon could be considered a short term loss).
Turbo Pascal 3.0 was my first serious programming language (after Apple ][ Basic). 30kb of editor/compiler in one package.
Then used Turbo/Borland Pascal 5.0/5.5 for quite a while, a bit of 6.01, short Delphi, and by that time already moved to C/C++
I moved of a reasonably stupid thing. The MoveFile() function exposed in Borland Pascal was not able to move files between folders. Although I knew some assembly, and Ralph Brown Interrupt List was the greatest thing ever, I did not consider rewriting routines in it (For some reason I was thinking - this language supports this, and this one that... much later I realized - these were just libraries, even if they were builtin ones - CRT). But for that reason I moved to C/C++ - because it had the function... lol.
I loved how .TPU/.DPU files worked, much more efficient than headers.
Now we need to force everyone to move to safer languages.
One thing I like in C++ over C, is that the language + libraries gives me enough freedom to achieve a Pascal like programming safety, thanks to references, STL and stronger type checking than C.
Yes, regardless of what C preachers like to spread, Pascal is also good for application development.
Although the original version lacked a few features, most dialects had them. Turbo Pascal and Mac Pascal were considered the dialects to achieve compatibility with.
Eventually in 1990 there was a revised version of the standard, Extended Pascal which contained such features. However by then the Pascal world searched for Turbo Pascal compatibility on most compilers.
Well I'll be damned; after some more research, it looks like it WAS ported (unofficially) to OSX. That said, I'm not sure it works with the original language anymore.
What would the motivation be for doing this? If for anything other than historical interest, is there anything a 23 year old version of Photoshop has over GIMP?
My implication was that if you're going to share source code, share it in a useful way.
This particular source code is from an extremely old version of Photoshop, there would be no potential commercial harm whatsoever from allowing people to reuse this source code however they want.
I could have lived with the "no commercial use" restriction that's typically used, but to not have a right to redistribute at all severely restricts its utility.
Given that the commercial value of this particular source code drop is effectively zero, I fail to see what Adobe being a billion dollar company has to do with anything. Nor do I see what this has to do with the "OSS" movement of "Free Software" in general, neither of which were mentioned in my original post.
This was provided to a museum for historical purposes. It could also be useful for other research or educational purposes potentially. And one day the copyright will expire.
Except lack of redistribution rights also complicates research and academic study since technically you can't even share any derivative work among colleagues.
Copyrights that may expire long after my death also don't seem like something I should be grateful for.
>This particular source code is from an extremely old version of Photoshop, there would be no potential commercial harm whatsoever from allowing people to reuse this source code however they want.
It's not that easy I guess. Even Photoshop 1 has tons of patents in it's algorithms.
If that is true you could reimplement Photoshop 1.0 with the clean room method [1] and have a perfectly legal clone, which you would then be free to expand.
> I could have lived with the "no commercial use" restriction that's typically used, but to not have a right to redistribute at all severely restricts its utility.
As long the web site stays up, everyone is free to go there and download it for himself/herself.
It means that something like the excellent annotated source reviews by Fabien Sanglard of Quake[1], Quake2[2], Q3[3], etc.. aren't possible.
Nor any ports to attempt ot make it compileable/runnable.
Code isn't supposed to be hung on a wall. If you can't even collaborate to make it work again, it does lose a lot, and waiting ~95 years isn't really a practical alternative.
Will the website stay up that long? Is archive.org allowed to preserve it?
Few and far between. Actually only one that makes any big money: IBM, and they sell services on top of OSS as they did on top of proprietary stuff. Nothing very OSS about them.
On the other side, the road is paved with failed OSS companies that were praised as "really getting it", starting with the archetypal one: VA Linux.
(btw, is my typo that amusing to you? Wait till you find out about cat videos then...)
Think the main challenge would be writing a compatibility layer for the Mac OS APIs circa 1990. It might not be so hard to compile the Pascal source.
Edit: Maybe it could be built as a 32 bit Carbon app for OS X with some modifications. That's all a little before my time, so I'm not sure how much was changed by the time OS X came around.
Surely you have no idea what you're talking about. Pascal is modern, perhaps you are the one that's not up to date. Java? Err.. assuming everybody has a lot of RAM, maybe. JavaScript? Forget about it, unless you can find a compiler producing native executables. Go? Has anything useful ever been written in it?
Even if the core logic were left in Pascal, the assembly language would need porting to x86/x86_64 and the GUI code would need to be ported to a modern GUI library.
I do recognize that Pascal sadly was never strong on UNIX/Mainframe systems, which I imagine is your case.
My move from Turbo Pascal/Delphi to C and C++ happened around the time I needed to target UNIX systems. Given the choice I always take C++ over C, because I can achieve a Pascal like safety.
But I do miss coding Delphi.
If Sun hadn't pushed Java so hard and Borland didn't went schizophrenic with what to do with their products, Delphi would probably still be quite strong nowadays.
Still the best way to code native applications on Windows though.
For anyone interested in retro graphics programs, you should check out Wright Design. I wrote up a post about it and it includes a zip file of the actual program and tutorial files.
I have always secretly hoped that someone would make an FOSS version of this software since I have yet to see anything like it even though it is now more than 15 years old. It seamlessly combined bitmap and vector artwork and was twice as fast as Photoshop in its day. Sad that Adobe was able to kill it off...
It's part of the MacApp framework, which isn't included in this source dump since it's copyright Apple.
http://en.wikipedia.org/wiki/MacApp "MacApp was based on Object Pascal, Apple’s object-oriented extension to Pascal, developed in consultation with Pascal inventor Niklaus Wirth."
Ironic: a rant and rave about how it's important to keep Paint.NET free so it can be maintained and developed by the community unlike the now more-restrictive Paint.NET license by Rick Brewster (author).
Paint.Net has many fewer features then Gimp, but the features it does have are fast, clean and simple to use (for reasonably small files). It's my go to tool on Windows for basic editing tasks.
It's missing fractional selection and per-layer alpha channels. With those two features, it would be almost usable. Without them, most photo editing tasks are highly difficult.
Fractional selection lets you apply adjustments and effects without harsh boundaries between the adjusted part and the unaffected part. Per-layer alpha channels are needed to blend together different layers smoothly. And actually, you could implement the effect of the former with just the latter.
So yeah; Paint.NET needs editable per-layer transparency channels.
Nope, it will require porting. Only the pure Pascal part is portable. The Assembly and MacApp parts are not, and MacApp no longer exists in OS X AFAIK.
https://github.com/mqudsi/photoshop