The Day Return Became Enter (2023)

I wouldn’t doubt it, the way some Mac keys are completely unintuitive.

I modern Word you can use Ctrl + Enter to create a page break.

On my 16" M1 MacBook Pro both Return and Fn+Return edit the filename... does it work differently on yours?

In line printers, a line feed moves the paper forward one line. A carriage return moves the print head back to the start of a line. You can do interesting things by making them separate commands, like bold text (overstrike) or underlining, so they were independent commands for talking to a line printer.

ASCII standardized on a character set containing control codes for line printers, so it included CR and LF separately. It's a bit weird that some terminals changed the semantics of those control codes, but I guess things never stay static in time.

And Fn+Return can be used for Enter if the keyboard doesn't have a Num Pad, for the few Applications that use it.

Wow, throwback to running MacScheme (I think) on the university's Macs in a computer lab in the mid-90s. It interpreted main keyboard Return differently from numpad Enter, which to me (coming from the Amiga) was very confusing.

If I recall correctly, only Return caused an evaluation attempt, while Enter merely added a line break for readability.

oh, thanks for the fact check. I guess it's obvious which computing ecosystem I never touch :)

Do it!

https://youtu.be/K4eScf6TMaM

If you have an "Internet" keyboard, you already have a "Forward" key.

Shibbit!

Allons-y!

Going to a new line is "line feed", hence the combo CR/LF.

Carriage return moved the paper (on typewriters before the IBM Ball) and moved the print head (the "ball" on an IBM typewriter, or the actual print head on TTYs and DECWriter equivalents) back to column 0.

Line Feed moved the paper up one line, Form Feed moved the paper up by a "form length" or, in the case of chain printers, to the particular position on the chain that was synchronized with the perforations on the paper itself.

The carriage return physical device on the typewriter combined moving the carriage (which could be done by hand) and the rolling of the paper up one line (which could also be done by hand) into one convenient motion.

On Windows you can rename with F2, and on macOS, Command-Down will work like enter does on Windows (I think of it like going down a directory, since up does the opposite, though it also will launch a file).

That doesn't quite fit the regular usage of the word. When someone asks you a question, you don't "return", but rather "respond" or "reply" or perhaps "submit" your response.

The "ding" is a bell that is mechanically activated when the carriage gets close to the end of the writeable area (in many typewriters, this is a moveable stop to account for variable paper width).

So when one types, the bell alerts the typist to the need to return the carriage; typically you get quite a few characters after the bell, either to finish your word, or hyphenate.

Which makes it ding-slide rather than slide-ding :)

I remember back in the early 90's installing an extension on every Mac in the school computer lab that made typewriter sounds on every keypress, including that "zzzzzzipDING!" sound when hitting return (or was it "DINGzzzzip"?)

It was hilarious for a few minutes, then got old really quick, so it didn't last the day. The Oscar extension stuck around for months though ("I love it because it's trash!"). Computers were just so much fun back then...

My experience is with IBM AT and OS 2 which had a Return and a numpad with an Enter. The AT and Model M keyboard at least were part of a very popular and influential generation or two of "PC".

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

EDIT: Holy cow, those Model M pictures are so nostalgic.

No, I definitely remember it behaving differently if I pressed "return" (right of "#" on the keyboard) vs "enter" (on the numpad).

EDIT: In the US I guess that's right of "'"? Below backspace, above the right shift.

The reason I remember is it took me quite a while to actually run the damn thing :P

A carriage is a wagon that transports people, not "things", a carriage are also usually wheeled, just like wagons.

In this case, one reason why "wagon return" might have made more sense is because there is a wagon that holds the platen of the typewriter.

Carriage is another word for wagon (german Wagen, swedish vagn)

It makes sense because it's the same word in Swedish, the distinction doesn't exist.

In some industries, latches (which the article called "teeth") are called "dogs".

So that's a full-circle kind of comment you've got there.

It's a latch.

My child is.

Comma Separated files would likely exist because they're human readable, whereas FS/GS/RS/CR/LF are not visible.

There is "pipe delimited" which used "|" (ASCII 124 decimal) to separate fields, which actually makes way more sense, because that character is rarely used in normal text.

It's also a good separator when a human is reading the file.

RS separates logical "lines" or there is "Group Separator", but for internal line separators in a multi-line text field, the CR and LF characters could be used, because they have "standard" meanings for text:

CR: move next character position to position 1 horizontally LF: move next character position to vertically below current character position, potentially inserting SP characters.

So a combination of CR/LF, or LF/CR would have the effect of "New Line".

Why? The use of TTYs for computing interfaces is very different to using them as teletypes on comms links.

I thought the control characters for that sort of use were the DC1-4 characters?

RS-485 uses polling but my understanding is that the characters for polling usually involve like "FF" (hex) and some sort of device ID.

I just read a TTY model 28 manual about the stunt box and I didn't see anything specific about FS/GS/RS there.

How were messages delimited in the polled multidrop environment?

Here's a pdf of a blank prop Western Union telegram form. Have you got others? https://www.hplhs.org/resources.php

I think the issue is that people don't make their own lives harder, but sometimes they make the lives of other people harder (often unintentionally). In my experience, the CRLF files I run into tend to come from developers who are only working in Windows and either aren't aware of the issue or don't particularly care to do anything about it. It isn't something I run into often when cloning a git repo, but having recently started dabbling in the world of mod development for games, there's a lot of stuff out there that seemingly has never been touched by someone who's used Linux before. To be clear, I don't blame anyone for this, since people working on things for free in their spare time shouldn't have to worry about anything other than what interests them, but it's a bit amusing to me that I sometimes have less to configure to run an .exe on Linux than I do to start editing the source for it in a way that makes it easy for me to merge any new changes that happen upstream.

The language runtime will insert/remove CR for you if you open the file in text mode on Windows. You'd be surprised how much stuff cygwin itself actually does for you. If your code isn't too Linux specific try building it under mingw instead and you can see what's actually going on.

> Who in his sane mind uses CRLF even under windows? All my source codes are in UNIX format (aka LF only) and I use it consistent under Windows, Cygwin and UNIX.. Why make your life harder?

Why would you use LF if the focus of the application that you develop is Windows? You make the life harder for these users. :-)

Seriously: your argument typically comes from developers who consider GNU/Linux as a first-class citizen as a development or deployment platform, and Windows only as a second-class citizen (assuming that a Windows port actually exists).

I can accept an argument like "I, as a developer, don't care about Windows and its users, so all my source code is in UNIX format." This is a conscious, though quite political decision.

But an argument like "not using LF makes lifes harder" without a relativization on which premises this claim is build (such as "GNU/Linux and macOS users are much more important for as, and if there exist any users or developers who use Windows, we consider them to be undesired, because they make everybody's lifes harder") is intellectual ignorance.

The ability to do that is a recent development. And numerous programming environments still default to adding CRLF and stripping it off when running on Windows, and all the system tools on Windows generate files with CRLF as line terminators so all software needs to deal with them.

> Who in his sane mind uses CRLF even under windows?

Hopefully nobody is using it for documents, but most text-based internet protocols, including SMTP and HTTP, use CRLF for line endings.

I fully agree, but we're talking history here, before Unix existed.

The confusion about "LF" (Unix) vs "CR" (Apple) vs "CR/LF" (MS/DOS & Windows) is because we didn't have an explicit "Line End" character in 7-bit ASCII.

There was "EOT" (Ctrl-D/ASCII 4/EOF in Unix) , "ETX" (Ctrl-C/ASCII 3), and other characters that were used to mean other I/O, including ones that didn't match the ASCII definition like Ctrl-S/Ctrl-Q to stop/start I/O, and Ctrl-Z to mean EOF (MS/DOS & Windows).

The file editing is an I/O issue, not a character issue.

The I/O drivers could translate as necessary, that's the point of using an explicit character to mean "new line" as opposed to either "carriage return" or "line feed".

Effectively moving away from explicit carriage and paper controls to a character that was explicitly internal to mean to generate whatever carriage/paper controls were needed on output/editing etc.

Text editors should be programmed to support those separators. Would've saved us from CSV.

Back in the last century, Mathematica was like this as well. On Macs, "return" wouldn't run the command you entered, you had to hit "enter" from the numpad. Shift-return may have worked as well, but it's been so long I couldn't say for sure.

Edited: Mixed up Matlab and Mathematica

I think I have about a 50% success rate in typing a multiline message without accidentally sending it early, having to edit / copy and delete the message and finish typing it before the recipient has a chance to read it, confusing both me and them in the process.

yes but you have to type sfhit+enter, while a single "new line key inside the message" would be better for the specific task.

"Next field" is sort of what tabulation means. Moving to the next column of a tabular form.

Need an "indent" key distinct from the "tab" key.

Normally that's fine, because the tab stop points to the next field. That's the whole point of tab stops― you place them at the beginning of fields on a forms. (Yeah, you also need to be on the right line, so a single key press rarely gets you there, but we were working with purely mechanical controls.)

Where it goes off the rails is when we embed a user interface inside another user interface. That's not a problem specific to the tabulator, but also with all novigation functions, like home, forward, and back.

I rarely use web-based email interfaces, but when I do, I accidentally send half-written email messages, because I'm trying to use a block quote or something similarly indented. It's especially bad when the next field is the 'Send' button, and pressing the spacebar sends the message.

That is not an overloading, that is just preserving the behavior of Tab on IBM terminals.

I still call this key “omppu” in Finnish (meaning “apple”) because that’s what everyone called it in the 1990s when it still had the “open apple” legend.

And young people look at me like I’m crazy when I tell them to press “omppu Z”… But it’s a hard habit to break. I don’t even know what the official name of the key is in Finnish.

That's from the Apple IIe keyboard which had "open apple" and "closed apple" straddling the spacebar:

http://xahlee.info/kbd/i/Apple_IIe_keyboard_f91f4.jpg

https://www.applefritter.com/files/styles/95-percent/public/...

The IIgs keyboard had both the "open apple" and "looped square" symbols on that key, with the "closed apple" becoming option:

https://i0.wp.com/www.applerescueofdenver.com/wp-content/upl...

The extended keyboard had both keys on each side of the spacebar:

https://www.reddit.com/media?url=https%3A%2F%2Fi.redd.it%2Fa...

On the Mac, the keys were always officially called command and option, as far as I recall:

https://cdn.shopify.com/s/files/1/0653/6917/8326/products/25...

https://en.wikipedia.org/wiki/Apple_keyboards#Layout_and_fea...

Outside of the US, they have symbols: ⇥ intead of "tab", ⇪ instead of "caps lock", ⏎ instead of "return", etc.

It seems it’s only US English keyboards that apple print the name of the key on.

All ISO layouts plus a few of the other ANSI layouts (like Korean) make use of the symbols