Editing 2324: Old Days 2

{{comic
| number    = 2324
| date      = June 24, 2020
| title     = Old Days 2
| image     = old_days_2.png
| titletext = The git vehicle fleet eventually pivoted to selling ice cream, but some holdovers remain. If you flag down an ice cream truck and hand the driver a floppy disk, a few hours later you'll get an invite to a git repo.
}}

==Explanation==
In this sequel to [[1755: Old Days]], which was released more than three and a half years earlier, the conversation continues, as if no time has passed, between (young) [[Cueball]] and (old) [[Hairbun]] about computer programming in the past. As in the first comic in [[:Category:Old Days|this series]], Cueball, having only a faint idea of just how difficult and byzantine programming was "in the old days", asks Hairbun to enlighten him on the specifics. Hairbun promptly seizes the opportunity to screw with his head. 

The new claims:
* The cloud was smaller and called a "Mainframe" and was near Sacramento.
** This is a joke on many {{w|Cloud computing|cloud services}} replacing {{w|mainframe}}s. Both systems were or are used to provide an expansive quantity of computing capability by enabling users to use only some of the available resources, sharing with other users. In those early days, it is true that large mainframes would handle multiple people's jobs at once, using techniques like {{w|time-sharing}} (although they were not necessarily located near {{w|Sacramento}}, the capital of California.). What's more, the basic ideas behind how cloud computing used to go way back. {{w|Multics}} was an early time-sharing system designed to "support a computing utility similar to the telephone and electricity utilities". The idea was similar to the cloud, where anybody could just hook up and get computing service, as well as other services built into the mainframe. For this reason, many of the computer security concepts we have today - such as {{w|Kernel_(operating_system)|kernelized operating systems}} - come from early systems like Multics.
* It was on the state landline.
** In the days of mainframes, remote users often used {{w|landline}}s (i.e. hard-wired telephone connections) to communicate, via {{w|dial-up modem}}s, and so users would have to disconnect for making phone calls. Even in the age of all landlines, there was never such a thing as "the state landline", imagined as an immense shared {{w|Party line (telephony)|party line}} to which the governor would have priority access for making calls.
* No memory protection; instead, people would call around to ask whether anyone else using an address and Microsoft's early foothold in computing was because of {{w|Bill Gates}} lying about his usage of addresses.
** {{w|Memory protection}} protects storage from access by other programs or users. Many computer systems provide hardware and operating systems to support this. Hairbun is correct in that this sort of code was not well-developed early on. She claims that management of the memory was all done manually by agreement of the developers, and the only way to check if editing a particular address in the Mainframe was safe was physically asking all the other developers if they were already using it. In early PCs it was common to use specific memory locations, defined by the operating system or the hardware itself, to communicate with the operating system or perform particular functions such as direct graphical memory addressing rather than code compiling to pass through multiple Hardware Abstraction Layers. Her implication is that Bill Gates took advantage of this honor system to restrict people not working for {{w|Microsoft}} from making changes, allowing the company to take ownership of a lot of code - another fib with a grain of truth in it, based on Microsoft's excessive usage of limited standard-mandated pools. For example, out of 256 possible identifiers for {{w|partition type}} shared between all operating systems running on IBM PC compatible hardware, 65 entries are allocated to miscellaneous variants of FAT and NTFS systems, 38 of them originating from Microsoft itself - including esoteric variants like "Corrupted fault-tolerant FAT16B mirrored master volume."
* "Git" was a van that drove around gathering tapes to copy, and the term "pull request" came from the van physically pulling over when signaled with an air horn.
** {{w|Git}} is a {{w|distributed version control system}}, which manages copies of a coding project to prevent and resolve conflicts from multiple people editing the project at once. It works by having individual contributors {{w|Pull request|pull}} the project onto their device, make their changes, and then push those changes back to be integrated into the master copy. The term "pull request" is primarily used after a user has pushed their new code and is requesting that those changes be integrated into the primary codebase, i.e. that the primary developer would pull those changes into the main branch. Bulk data used to be stored on {{w|magnetic tape}}; in order for version control to exist at this time, there would have to be a master tape that was copied and physically distributed to each contributor, and then the edited tapes would be gathered afterward and conflicts resolved. Hairbun claims that Git provided this service back then using vans. In reality, Git did not exist until 2005, long after digital computers and networked servers became widely accessible and the "early internet" was history. Other systems for providing the same functionality existed for decades before this, with {{w|Source Code Control System}} (SCCS) having been released in 1972. Even this software was implemented primarily for multiple users accessing the same system, rather than users on separate, unconnected ones. Physically carrying storage devices around ({{w|sneakernet}}) has sometimes been used where electronic communication or bandwidth was not available. For example, motorcycle drivers on a regular route, carrying flash drives to remote communities (see {{w|delay-tolerant networking}}). This form of file transfer was also the subject of comic [[949: File Transfer]].
* Before terminals we all used punch cards, which were originally developed to control looms, and so the Mainframe would produce sweaters when code was run.
** Another initial truth going into complete nonsense. It is true that some looms were controlled by {{w|punch card}}s (dating back to 1745), and so were early computer precursors. At the same time {{w|Charles Babbage}} used them around 1830 to control his {{w|Analytical Engine}}. However, Hairbun's statement is that because of this, the ''same'' punch card machines would run both ''simultaneously'', such that feeding a set of cards to compile code would necessarily cause a sweater to be produced by the connected loom, which was then sent to the developer. For one: industrial looms don't produce sweaters, but fabrics (which is often patterned if punch cards are involved). And it's not likely that any punch patterns used in computer coding would be interpretable as a suitable pattern for a sweater. However, there is loom knitting which does produce patterns for sweaters.
* (From the title text) You can still hand in a floppy disk to an ice cream truck and get an invite to a git repo a few hours later.
** Git repo is short for Git {{w|Repository (version control)|repository}}, the place where all the files associated with a project are stored. Hairbun tries to convince Cueball that modern ice cream truck drivers service Git in the same way she says the vans did before and that it's still possible to give them a {{w|floppy disk}} (a magnetic storage device) in order to gain access to a repo. The ice cream industry has no connection to computing.{{Citation needed}}

==Transcript==
:[In a slim panel, Cueball and Hairbun are walking together to the right. Hairbun has her palm raised.]
:Cueball: What was the Internet like in the olden days, for a developer?
:Hairbun: Oh, things were very different.

:[Cueball and Hairbun have stopped walking. Zoomed in on Hairbun.]
:Hairbun: The cloud was a lot smaller. It was called a "mainframe" and it was near Sacramento.
:Hairbun: It was on the state landline, so the whole industry paused when the governor had to make a phone call.

:[Zoomed back out. Hairbun has her palm raised.]
:Hairbun: There was no memory protection. If you wanted to write to an address, you would call around to ask whether anyone else was using it.
:Hairbun: Often Bill Gates would say he was, even when he wasn't. That's how Microsoft got its early foothold.
:Cueball: Wow.

:[Same setting as in the first panel with Hairbun gesturing toward Cueball raising one hand  palm up.]
:Hairbun: Early compilers could handle code fine, but comments had to be written in assembly.

:[Zoomed back in Hairbun. Cueball responds off-screen.]
:Hairbun: "Git" was originally a van that circled around gathering data tapes to copy and distribute. We all took turns driving it.
:Hairbun: When you saw it coming you'd blow an air horn to request that it pull over.
:Hairbun: That's where "pull request" came from.
:Cueball (off-screen): Oh, neat!

:[Cueball and Hairbun continue walking to the right. Hairbun has her palm raised.]
:Hairbun: Before terminals, we all used punch cards, which were originally developed to control looms.
:Hairbun: Early mainframes would produce a sweater each time you ran your code.
:Hairbun: Eventually we got them to stop. We had enough sweaters.

{{comic discussion}}

[[Category:Comics featuring Cueball]]
[[Category:Comics featuring Hairbun]]
[[Category:Old Days]]
[[Category:Comics sharing name|Old Days]]
[[Category:Comics featuring real people]]
[[Category:Programming]]
[[Category:Computers]]
[[Category:Version Control]]