Hacker News Reader

Comment by nickpsecurity | Hacker News Reader

Trying to take your categories and find where they started.

Re isolation. From high-assurance security, I believe the first, secure kernel that was general-purpose was this one:

http://csrc.nist.gov/publications/history/schi75.pdf

Types. Guess that would be ALGOL.

LLVM. BCPL seems to have gotten the idea started with a two-pass compiler that went from complicated stuff to byte-code (O-code) then to assembly. That got ported to PDP-11 in form of B & then C. Wirth further developed it & popularized it with P-code in Pascal/P. Helped non-compiler experts port it to 70 architecture in 2 years whereas compiler experts could target something easy. Did it at hardware level with Modula-2 & M-code assembly. So, either Richards of BCPL or Wirth of P-code get credit for such a concept. Maybe both.

re packaging. I got nothing. Anyone know what the first package managers were that had something inspiring modern functionality? Those ahead of their time.

View on HN

I believe the first package manager was "pkg" in System V (early 80s).

The modern notion of package-manager-with-builtin-download-and-uprades only came in the mid-to-late 90s, when internet bandwidth grew enough to make that feasible.

The first one of these might've been FreeBSD ports.

Appreciate feedback on pkg. Far as other thing, I was hesitant to say that given mainframes or minicomputers connected over leased lines might have had something built-in or from 3rd parties. Some tool to easily package and push stuff from HQ to branch offices, warehouses, stores, etc. Just speculating. Strange if nobody automated the process.

Not so strange. It was way less common to push out software the way we do now. Software releases were generally pretty major events. Leased lines were often slow and very expensive. Even into the mid-eighties getting a software distribution or update via magnetic tape was the most common method. Even for software from user groups and other non-commercial sources were distributed on tape. (Source: I did Unix and Tandem programming the early 80s.)

So if we look at methods of tape distribution, even the very first edition of Unix in ~1971 had tap (an early ancestor of tar) [1] which saved & restored filenames, mtimes, modes, and owner info. You could argue that a tp/tar archive is a primitive packaging system.

[1] http://man.cat-v.org/unix-1st/1/tap

The other instance I can think of is the shar format [2] that was used to distribute software over Usenet from the early 1980s. Shar was basically a fancy text file that you piped through a shell (yeah, I know). Because binary compatibility was rare, most shar files resulted in a directory of source code, which you'd then compile -- basically, like a 'modern' tarball.

[2] https://en.wikipedia.org/wiki/Shar

"even the very first edition of Unix in ~1971 had tap (an early ancestor of tar) [1] which saved & restored filenames, mtimes, modes, and owner info. You could argue that a tp/tar archive is a primitive packaging system"

I'd definitely count that as an early packaging system if it had all that metadata with it. So, that pushes it back to 1971 unless a non-UNIX machine had an equivalent before that. Likely a business mainframe or academic machine.

I tried to dig it up. I think the terms "version control" and "package management" overlap a lot in how people classify their software or do the histories. They're different with some overlap but it's all muddied up. Interestingly, I found no history in Google of package management from early to modern stuff. There's an interesting project right there for some CompSci student interested in computer archaeology. :)

I did find VC history where the first thing to track software seemed to be SCCC on UNIX:

https://en.wikipedia.org/wiki/Source_Code_Control_System

The rest, from CVS to mainframe stuff to Apollo Aegis's, all showed up around mid-1980's in similar time frame per Wikipedia descriptions. pkg seems strong contender for first, package manager if even version control of source didn't hit others until after its creation.

There were versioning file systems in the 1960s (MIT's ITS among them, and I think Univac's EXEC 8, though I can't find a reference) [1]. Often, new writes to a file bumped a version (or cycle) count in the file system. I don't know, but I wouldn't be surprised if there were tools to do diffing and patching much like modern VCS systems.

[1] https://en.wikipedia.org/wiki/Versioning_file_system

Reply on news.ycombinator.com