Yeah, it's worth remembering that at the time a compiler cost $10k+, an OS $1000s/year - you couldn't work on OS or compiler work unless you worked for a big hardware company - a whole lot of interesting work was locked away from most programmers
Wasn’t Cathedral and the Bazaar originally published in 1999? Who was paying thousands of dollars a year for an OS in 199? And I think GCC was already widespread by then, no?
I didn’t start programming until a few years later, but for sure by 2002, it seemed to me a given that compilers were free. It was my impression that stuff like Borland was niche and that serious stuff like Java and C were free.
Not saying you are wrong, just your comment surprised me. Maybe I have a revisionist memory or maybe those intervening 3 years were quite transformational in the industry.
The firm I was at in 1997 was shipping commercial software with GCC. There were expensive compilers, but you weren't required to use them. For Windows builds, I think we were Borland C++, which was hundreds of dollars. Sun had a pretty expensive compiler for Solaris that I remember using for hunting down memory leaks.
Yes but Cathedral and the Bazaar was telling us that the world had changed, gcc was free, linux was a thing etc, mainframes (where compilers cost $10k and you (mostly) couldn't bring your own OS) were being replaced by workstations etc.
Commercial access to Unix source was still many thousands of dollars, the whole SCO debacle was an attempt to stop free OSs from being a thing
Many of us who had grown up from the mainframe era wanted to write compilers, work on OS's etc etc it was a hard thing to do (esp. outside the US) before the late 80s, cheap commodity hardware let a thousand flowers bloom
Apple was giving away a C compiler by 1999 afaik, GCC was well established (but going through the egcs drama?). Visual Studio/Visual C++ didn't get a free version until 2005 though.
But yeah imo you're closer to right than not, though Microsoft licenses were still fairly expensive.
2002 was before the tipping point, IMO. Open-source software existed, but wasn't always taken seriously. Linux was still widely perceived as being a hobbyist OS unsuitable for "real" applications. A lot of the Internet still ran on Windows and commercial UNIX servers.
By 2002 I was at Arbor Networks, shipping security software to tier-1 ISPs, and if we'd shipped it on a commercial Unix (let alone Windows) people would have looked at us like we had 2 heads. The writing was on the wall by end of the first dot com boom.
In 2003 I was somewhere south of Fort Worth, TX, having visited Dinosaur World, and shortly after leaving we stopped at a cafe that had three computers out which you could use. I looked at them while waiting for the coffee and they just seemed off, strange. It wasn't OS 9 nor X, it wasn't Windows... What was it? As I went over to look it hit me - holy cow, those are running that linux thing I've heard about! Their desktops were beautiful, totally different than the others. I knew then I wanted that.
Yeah, but the whole point was about GNU, and not so much UNIX culture, which was been free since the early days, given that AT&T could only charge a symbolic price for the tapes.
I recall stuff like the Intel icc compiler being expensive and desirable, and things like client access licenses, hardware licenses (to allow using non-trivial amounts of RAM and multi-processing) and support plans for proprietary OSes being rather expensive. Consulting a SCO Unix price sheet from that era, a license that allowed 150 users and up to 32GB of RAM was $10k.
Prices also varied around OS features used. Vendors loved to nickel-and-dime you (separate *-user client licenses for file services, print services, remote access, etc), generally to drive you towards bigger packages that seemed like a better deal.
Yes, that is the context in which I first read it (likely around 1999 when it appeared on slashdot), as a senior in high school with no access to the tools used by most professional programmers at the time.
Yes, I'm speaking about my experience as I remember it - not what was objectively possible for someone with the right resources and knowledge at the time :)
Right, I'm not so much pushing back on you as I am establishing a chronology for CATB. Ordinary people were absolutely belting out (what we would now call) open source software by the time it was written.
(That's not the biggest flaw in the essay, of course. It made predictions, some of which turned out to be comically wrong. The true parts of it weren't new, and the new parts of it weren't true.)
You can go to this effort to get it to make the right magic number .... or just find the place where it gets tested and replace the conditional branch with a unconditional branch (or a no-op)
Having said that I once wrote 68k code that was an executable copyright message, and other code that if it discovered it wasn't running on an authorised machine logged to a known port, sent an email, unlinked the binary, queued "sudo reboot", killed the parent process and then exited (all the authorised machines were mine, running a bespoke kernel)
Why patch the binary to get the correct "system identity" value, to match the license/serial-key you've got? Instead patch the serial-check out of the software entirely.
It's worth noting that before the dotcom bubble the rule of thumb was that a startup had to have 5 quarters of profit before going public - the whole dot-com thing of going public on vibes before making any profit was part of why it was a bubble, and also why investors were playing in a whole new sandpit and possibly out of their depth
yup, same for any real time code, new/malloc/free/delete use hidden mutexes and can cause priority inversion as a result - heisenbugs, that audio/video dropout that happens rarely and you can't quite catch - best to code to avoid them
They also can simply fail, if you are out of memory or your heap is hopelessly fragmented. And they take an unpredictable amount of time. That's very bad if you're trying to prove that you satisfy the worst-case timing requirement.
Unix up until at least System III used the structure thing to do the equivalent to unions, before unions were a thing - for example each disk driver had a data structure that began with a common part and then had a per-device part, generic parts of the kernel used a generic structure that only represented the generic data structure, drivers used their own version.
I think part of this is that early Cs didn't have a full type system, there were limits to the types you could describe (the ones you couldn't were mostly a bit esoteric and not very useful) - from memory in the original PCC types were encoded in the compiler as words rather than trees (pdp11 memory was scarce)
Algol60 had call by name, Algol68 doesn't really, it does have "proceduring" which creates a function to call when you pass an expression to a parameter that's a function pointer that has no parameters, you can use that to sort of do something like call by name but the expense is more obvious
ESPOL was (is?) simply a version of the standard Algol compiler that let you do 'system' sorts of things.
The Burroughs large systems architecture didn't really protect you from yourself, system security/integrity depended on only letting code from vetted compilers run (only a compiler could make a code file, and only a privileged person could make a program a compiler) - so the Algol 60 compiler made code that was safe, Espol could make code that wasn't, could do things a normal user couldn't - you kept the espol compiler somewhere safe away from the students ....
(there was a well known hole in this whole thing involving mag tapes)
As mentioned it evolved into NEWP, and you can get all the manuals from Unisys, as they keep selling it.
Given its architecture, it is sold for batch processing systems where security is paramount.
Yes, ESPOL and NEWP, being one of the first systems languages with UNSAFE code blocks, a binary that is compiled having unsafe is tainted and requires administrator configuration before being allowed to execute by the system.
One cannot just compile such code and execute it right away.
reply