The title would probably be confusing, but I could not make it better than this. I noticed that most programming languages are limited to the alphanumerical set along with the special characters present in a general keyboard. I wondered if this posed a barrier for developers on what characters they were limited to program in, or if it was intentional from the start that these keys would be the most optimal characters for a program to be coded in by a human and was later adopted as a standard for every user. Basically, are the modern keyboards built around programming languages or are programming languages built around these keyboards?
Pretty much all programming languages in use today have been invented decades after the keyboard.
The keyboard was originally invented for typewriters, but since they don’t interact with anything and are self-contained systems, typewriters don’t need their keys standardized. However, the keyboard converged as HP, Brother et al. brought the typewriter forward, especially near the end when typewriters were keyboards connected to printers.
Early computers weren’t programmed with keyboards at all and used punch cards to be programmed. As you move forwards with the invention of the computer as we know it today, you find out that the modern keyboard was invented to be able to type most characters in use at the time (a classic example is that the @ sign was used by tellers on tills, to mark stuff like 2 units @ $5 per), and actual standards body such as iso and ANSI simply implemented that.
Early personal computers were not powerful enough to compile programs quickly(and compilers were very expensive), so for a while all programming was done either in assembly, which requires very few special characters, or in higher lever languages by people who could pay to get their programs compiled. These higher lever languages, such as B (precursor to C), were often written right on paper by hand, or by typewriter. After this point, home compilers became more and more accessible (the internet basically guaranteed you could get a compiler if needed), and this was the last point in history you could design a language with characters not present on a standard keyboard (you could still have a nonstandard typewriter, or write them by hand for example). After this and the explosion of home computing, people designed their own languages that they were able to use themselves, using their own keyboards.
Worth noting that there exist languages today that you cannot type, pretty much at all. They are however largely considered esolangs (esoteric languages) and most of their use is relegated to the practice of code-golf, in which a programmer tries to accomplish a task using the fewest bytes. Since the characters on a keyboard make up a fraction of all characters available in Unicode or even just ASCII, these languages try to increase the number of things you can do with a single characters by disregarding the fact you can’t type most of them, lowering the amount of bytes one needs to do a task.
An example of this is O5AB1E (pronounced “osable”), which has over 250 single-character commands, such as Δ which “repeats code until ‘a’ doesn’t change”.
An example (that you can’t type) is: yā<ã.Δ¹sŸèOQ
This program gets an input n and a string of numbers, then outputs the first run in the string that sums to n. The program is explained here
I’d just like to take a moment to commend you on an absolutely exquisite answer.
Given time, there is a slim chance I could have covered the same ground and no chance that it would have been as clear and concise.
Well thanks, that really made my day.
An example (that you can’t type) is: yā<ã.Δ¹sŸèOQ
I think the only thing here you can’t type is the superscript. The rest is easily typeable, at least on a Mac or a smartphone.
Well, soft keyboards thend to do that yeah. But nobody is using a smartphone to program.
The point is that nobody is good enough at 05AB1E to type it by hand, everyone just has an idea of what they’re trying to accomplish and copy-pastes commands from the documentation.
I wasn’t talking just touchscreen keyboards. On Mac you just hold option and you can type almost all of those letters. I do understand your point though. Thanks for explaining
@snowe @themoonisacheese I can type ¹ on a smartphone pretty easily
Are you typing the character or using markdown to accomplish that?
@snowe Typing the character. With GBoard it’s switch to numbers+symbols then press and hold a number (in this case 1) to access fractions and superscripts.
Hmm Gboard on iphone doesn’t do that. Strange. I can hold plenty of other letters and numbers (like 0 to get °), but not 1-9.
C supports alternate ways of typing some of its punctuation, for programmers whose keyboards didn’t support them all. For example, if you can’t type
[ ]you can use??( ??)instead. (There are other ones that use angle brackets, but I can’t type them here because Lemmy escapes them incorrectly. Irony.)https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C
The usual example of a programming language using especially unusual characters is APL, where all built-in functions are all represented by single characters, mostly drawn from mathematical notations, Greek alphabet, and so on. For example,
⍋is the “sort” function.APL
From one of the many How to shoot yourself in the foot guides, for APL:
- You shoot yourself in the foot; then spend all day figuring out how to do it in fewer characters.
- You hear a gunshot and there’s a hole in your foot, but you don’t remember enough linear algebra to understand what happened.
- @#&$%&% foot
A fascinating language to look at, Conway’s Game of Life is simply
life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}, but I have zero interest in ever actually learning it ;)There are also keyboards with the proper symbols:
The core of that Life expression works by taking the array of cells and shifting it in the eight different directions, then summing those arrays to get the population counts.
I tried translating this into Python — but I’ve never written
numpycode before, so this is probably less efficient than it could be. But it does work and you can see a glider move through a few generations.The array-shifting logic is in the
populationsfunction, withnp.rollbeing the equivalent of the APL rotate operation (written as⌽and⊖in the original).import numpy as np def alive(popu, cell): return int(popu == 3 or (popu == 4 and cell)) alive = np.frompyfunc(alive, 2, 1) def populations(grid): return np.array( [ np.roll(r1, shift, 1) for shift in [-1, 0, 1] for r1 in (np.roll(grid, shift, 0) for shift in [-1, 0, 1]) ] ).sum(axis=0) def nextgen(grid): return alive(populations(grid), grid) grid = np.array([[0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]) for gens in range(5): print(grid) grid = nextgen(grid) print(grid)Yeah, that looks closer to what I remember from university ;)
It was a noisy co-evolution where both languages and keyboards keep changing to best fit each other.
While the letter layout of our keyboards is heavily influenced by typewriters, the set of symbols on them changed a lot with times, and for some times there was a lot of diversity on them. Our current design is as much a result of languages like MPL never really popularizing as much as the lack of adoption of those languages is a result of the popular keyboard designs.
Yeah. 7-bit ASCII goes back to what, the 60s? But computers still used different encodings and so different keyboards for A While.
Not only do the Languages orient themselves to fit to the keyboard, they pretty much only consider the English keyboard layout.
Rule Britannia mother fuckers!
Modern keyboards are an evolution of the old typewriter that existed before computers as we know them and programming as we know it existed, so I would say keyboard came first
yeah you are right
He’s not completely, though. @marcos had it right about co-evolution – leaving aside any issues of internationalization, the layout of letters came from typewriters, but the layout of punctuation available was different on different computers for a lot of the early history of programming. Some of the more extreme examples were the Space Cadet Keyboard used at MIT, and APL which more or less required you to use an APL-specific keyboard in order to be able to access all the special symbols that are part of APL. Here’s an APL program:
⎕CR 'ProveNonPrime' Z←ProveNonPrime R ⍝Show all factors of an integer R - except 1 and the number itself, ⍝ i.e., prove Non-Prime. String 'prime' is returned for a Prime integer. Z←(0=(⍳R)|R)/⍳R ⍝ Determine all factors for integer R, store into Z Z←(~(Z∊1,R))/Z ⍝ Delete 1 and the number as factors for the number from Z. →(0=⍴Z)/ProveNonPrimeIsPrime ⍝ If result has zero shape, it has no other factors and is therefore prime Z←R,(⊂" factors(except 1) "),(⊂Z),⎕TCNL ⍝ Show the number R, its factors(except 1,itself), and a new line char →0 ⍝ Done with function if non-prime ProveNonPrimeIsPrime: Z←R,(⊂" prime"),⎕TCNL ⍝ function branches here if number was primeThings became much more standardized when the IBM PC’s keyboard became the norm, and were formalized in 1995 with ISO 9995. Then once it stabilized there was a strong incentive for both language designers and keyboard makers to stick with what everyone was used to so they could keep working with the other. But it wasn’t always that way.
Edit: Here’s what things looked like on an IBM 3276:
Fun fact: the standard qwerty layout was made to slow typewriter typing down by putting common keys off the home row and apart from each other. This was done to prevent the little key arm thingies from colliding and jamming when typing quickly.
EDIT: Apparently this is not a fact
The point wasn’t to slow down typists, but to reduce the number of bigrams (two-letter sequences) that would be typed with adjacent keys, since that’s the specific movement that’s most likely to cause the key levers to jam.
Not true. The current layout is the result of years of evolution based on feedback by typists and vendors.
That’s a popular urban legend, but also disputed.
https://repository.kulib.kyoto-u.ac.jp/dspace/bitstream/2433/139379/1/42_161.pdf
Programming languages are build around the standard keyboard. Keyboards had most of the symbols you’re thinking of from their typewriter days. You can see most of the special characters in these small typewriters from the mid 1900s.
https://dealdashreviewed.com/wp-content/uploads/2015/02/typerwriter.jpg
With things like electric Wheel Writer typewriters, adding extra keys and symbols were less of a complexity issue and you started to see a few more extra symbols.
https://www.imagine41.com/wp-content/uploads/2016/07/ibm_wheelwriter_2500_002_1.jpg
Recognize that there never has been a hard standard for layouts and symbols, just the industry copying and converging on systems that became popular.
I won’t consider any keyboard to be designed for programming unless it has dedicated keys for characters like
{}() < >_+| & !*:"without needing to hold shift for them (Lemmy seems to be improperly escaping my less-than sign and ampersand)There’s “programming” layouts, like dvorak-programming that replace the number rows for special characters and you need to shift to get the numbers.
I’m fine with just using a US keyboard (technically the EurKEY layout, but that doesn’t matter for programming), I’ll never understand the people who for example use the German layout, so many more modifiers needed than just shift:
deleted by creator
ALGOL-60 had its own keyboard (sort of): https://retrocomputing.stackexchange.com/questions/16082/was-there-an-input-device-capable-of-entering-all-algol-60-symbols-with-correct
deleted by creator
Some of the “toy” languages used for code-golf can use some very non standard characters. Saying “all programming languages” is going to be very restrictive.
That’s a little pedantic, don’t you think?
Ohh very much so. This wasn’t meant as a criticism of OP’s question. I was just trying to make sure they were aware of all the niche programming languages out there, especially the ones that use some rather exotic character sets.
Fixed ‘all’. I tried to acknowledge that there may be other languages that may not follow this rule, but I seem to have not noticed this mistake.
Have a look at APL
)
