At the hardware level, computers don't use English in any way. Programs consist of machine code instructions to the CPU, which perform basic tasks like arithmetic operations (add, multiply, subtract) and flow control , i.e. comparing two numbers, and moving to a certain instruction in the list depending on the outcome of the comparison. It reads the number, does the corresponding operation, and then moves on to the instruction stored next in memory.

Since remembering which number does what is difficult for humans, we created assembly language, which is a set of mnemnonics, usually 3-4 letters. to represent the instructions. Such as (on a PC) ADD and SUB for ADDition and SUBtraction, CMP for a CoMParison and JE (Jump if Equal) to move to a certain instruction depending on the result of the comparison. A program called an assembler then turns assembly language code into machine code, which is fairly straightfoward as they're a nearly 1-to-1 relationship. (some instructions can do several things and have several mnemonics) The 'standard' mnemonics are usually specified by the processor maker and are usually based on English, but the processor itself doesn't 'know' the mnemonics. It is simply built to perform an addition when the instruction number (called an 'opcode') is 4. (if it's a x86 CPU)

Assembly language was still rather unweildly, it requires a lot of lines of code to do very little, making it take time both to write and to read and understand what's going on. So higher-level programming languages were developed from the 1950s and 60s forward, which abstracted the machine instructions into more powerful constructs that would make common jobs that required many machine code instructions short and easy to write. High-level languages have a compiler program instead to turn them into machine code, and it's no longer a 1-to-1 relationship. Now, an early thought was that programming would be easier if programming languages read more like a natural language, hence COBOL (an early high-level language that's still in use today) can have statements like "MULTIPLY X BY 5 GIVING Y.", something more typically represented by most high-level languages today as something like "y = 5*x" In all, COBOL has over 300 'keywords', which are the special terms (like 'MULTIPLY', 'BY' and 'GIVING') in the example which belong to the programming language, and can't be used for names of variables, or it'd confuse the compiler, which is the program whose job it is to convert it into machine code. The keywords in COBOL, and most programming languages, are from English. There is no technical reason for this; they are just strings of letters as far as the compiler program is concerned, and in fact one of the first steps in the compiler's conversion of a program (lexical analysis) to machine code is to replace the keywords with a symbolic 'token' representation.

Like assembly language mnemonics, the only purpose of the keywords themselves are to be easily understood and remembered. Programming languages exist with keywords in other languages, and also ones with symbols only and no actual words as keywords. English is just the most common choice as its the lingua franca of science and engineering. Changing keywords is actually trivial; here's part of the source code for a C language compiler - this bit of code assigns the keywords to their respective tokens. The keywords are the ones within quotes in red, near the top of the file. (int, void, char, and so on) Just change those and you'll have a compiler for a new programming language that's just like C but with differently-named keywords (it probably won't catch on).

Having many keywords, like COBOL did, went out of fashion though, as it results in verbose programs that were actually more difficult to read than a more concise notation ("X GREATER THAN Y" versus "X > Y") So common languages today like Java and C only have about 30-50 keywords, such as 'if', 'while', 'for'), not hundreds.

Anyway, there are tons and tons of books on the history of computing, both popular and more academic in tone. But you might need to be a bit more specific; when we talk about "computer architecture" it's the hardware that we're talking about, while the history of programming languages is somewhat independent of that, since much of the point of high-level languages was to be able to write programs independently of the specifics of the hardware. (with assembly language, the mnemonics and what they do are specific to a processor type or processor family) But the precise naming of keywords (if any) isn't really considered a very important part of programming language design (as long as the names aren't confusing or weird, although there are arguably some very popular languages with some very poor keyword names out there)

Unfortunately a lot of computer history books I know of largely require knowledge of programming or mathematics to understand well (e.g. Priestley's A Science of Operations Machines, Logic and the Invention of Programming, and the various history books from the ACM) On the popular level I can recommend Tracy Kidder's The Soul of a New Machine, which is a nice story and insight into the environment and practice of building minicomputers and their architecture in the late 70s,