Many folks have at one point or another asked themselves how a computer really understands what it is that we’re telling it to do. Programmers around the world will type up a storm of obscure-looking syntax on a non-traditional-looking text editor with an oddly designed color scheme, and in some way, shape, or form… ta-dah! An application, a website, a piece of software now exists in the flesh.

许多人在某一点或另一点都问自己，计算机如何真正理解我们告诉它要做什么。 全世界的程序员都将在外观非传统的文本编辑器上以一种奇怪的设计配色方案，以某种方式，以形状或形式来输入一堆晦涩难懂的语法…… ta-dah ！ 一个应用程序，一个网站，一个软件现在已经存在。

But how was some seemingly arbitrary mumbo-jumbo able to effectively and functionally communicate with the computer?

但是，一些看似随意的大型组合如何能够与计算机进行有效和功能上的通信？

The aim of this article is to answer just that in layman’s terms. I’ve actively chosen to abstain from using overly technical jargon as this piece is intended to read as smoothly as Tennessee whisky (even if you have little-to-no technical experience). This naturally comes at a cost of omitting details and intricacies that exist in this elaborate process, but for the purpose of this article I believe that it is an appropriate trade-off to make.

本文的目的是仅用外行的方式回答。 我已积极选择避免使用过于专业的术语，因为它旨在像田纳西威士忌一样流畅地阅读(即使您几乎没有技术经验也是如此)。 这自然会以忽略此复杂过程中存在的细节和错综复杂为代价，但是出于本文的目的，我认为这是一个适当的权衡。

To start off, let’s have a look at the stack of concepts below:

首先，让我们看一下下面的概念堆栈：

5. High-Level Languages

5. 高级语言

4. Low(er)-Level Languages

4. 低级语言

3. Assembly Code

3. 汇编代码

2. Machine Code

2. 机器码

1. Electricity & Hardware

   电气与硬件

To begin understanding how we communicate with computers, we’ll explore each one of these components from the bottom up! By the time we reach the top of the stack, the content and verbiage will be in much more familiar territory for most of us who either hear about or deal with modern-day technologies on a regular basis. However, before we get there, let’s take a few minutes to think about what underpins the tech we’ve grown to know and love.

为了开始理解我们如何与计算机通信，我们将从头开始探索这些组件中的每一个！ 到我们到达顶峰时，对于大多数定期了解或处理现代技术的我们大多数人来说，内容和语言将变得更加熟悉。 但是，在到达那里之前，让我们花几分钟的时间考虑一下我们已经成长为了解和喜爱的技术的基础。

(1/5)电气与硬件 ： ((1/5) Electricity & Hardware:)

Let’s really take it from the start. Our exploration will begin from understanding that a computer is built on a series of chips and pins that are configured in a way to recognize whether or not any given piece of foundational hardware has power coming to it or not.

让我们从一开始就真正地接受它。 我们的探索将始于理解计算机是建立在一系列芯片和引脚上的，这些芯片和引脚的配置方式可以识别出任何给定的基础硬件是否具备强大的功能。

One of these underlying pieces of hardware is what we call a bit.

One的硬件的这些基本件就是我们所说的一点 。

Through coming up with clever ways to group these bits together, including building them into logic gates and other concepts that are beyond the scope of this article, we essentially create the hardware of a computer.

通过提出将这些位组合在一起的巧妙方法，包括将它们构建到逻辑门和超出本文范围的其他概念，我们实质上创建了计算机的硬件。

(If you’re interested in learning more about this, I would highly suggest But How Do It Know by John Clark Scott as your go-to book on basic computer principles. It does an incredible job at explaining the above concept in its full glory, while using terms even a 5-year-old would understand.)

(如果您有兴趣学习更多有关此的知识，我强烈建议John Clark Scott撰写的But How Do It Know作为您的基本计算机原理书籍。它在出色地解释上述概念方面做得非常出色。 ，即使使用5岁的孩子也能理解。)

The key takeaway in this section is as follows: any given bit can only exist in two states. These states include either receiving power, or not receiving power. That’s all.

本节的主要内容如下：任何给定的位只能以两种状态存在。 这些状态包括接收功率或不接收功率。 就这样。

This is fundamentally all that computers do. It is the combination of sending power to the right places at the right time that allows us to have graphical interfaces, memory, and all the other fun stuff we think computers simply “understand” or “remember”. Fundamentally, though, every bit either has power running to it, or it does not — that’s it.

从根本上讲，这就是计算机所做的一切 。 正是在正确的时间在正确的位置发送功率的组合，使我们能够拥有图形界面，内存以及我们认为计算机只是“理解”或“记住”的所有其他有趣的东西。 但是，从根本上讲，每一点都有力量运行，或者没有力量运行，仅此而已。

Now the question becomes, what combination of power (and lack of power) do we want to employ? And, moreover, how do we control it and tell the computer what to do with it? That’s where machine code comes in.

现在的问题是，我们要使用什么力量(和缺乏力量)的组合？ 而且，我们如何控制它并告诉计算机如何处理它？ 那就是机器代码的来源。

(2/5)机器代码 ： ((2/5) Machine Code:)

Machine code is a (very) long representation of 1’s and 0’s that tells the CPU (central processing unit, a core physical component that keeps the computer ticking) where & when to draw power, and where & when to shut it off.

机器代码为1(非常)长表示的和0的，它告诉CPU(中央处理单元，其保持计算机滴答的芯的物理部件)其中时汲取电力，并且其中＆当关闭它关。

This code is not typically human-readable! If you tried to open up a text file with machine code on it, it would come out as a load of unprintable characters. However, the key thing to understand here is that this is as close as we get to speaking to the computer hardware — by feeding it appropriate combinations of 1’s and 0’s, we tell it exactly what to do. Have a look at a chunk of machine code here that has been displayed as (readable) 1’s and 0's:

此代码通常不易阅读！ 如果您尝试打开带有机器代码的文本文件，它将作为大量无法打印的字符出现。 然而，要了解这里的关键是，这是尽可能接近我们得到说话的计算机硬件-通过喂养它的1和0的适当组合，我们告诉它该怎么做。 查看此处显示为(可读) 1和0的一部分机器代码：

When people say “computers only understand 1’s and 0’s”, they’re fundamentally referring to the concept of machine code. As we saw in the previous section, strictly speaking this isn’t entirely correct as computers really understand “there is power” and “there is no power”. However, as computer scientists we have chosen the unary value 1 to represent the presence of electricity running to a specific node, and 0 to represent the lack thereof.

当人们说“计算机只能理解1和0 ”时，他们从根本上说的是机器代码的概念。 正如我们在上一节中所看到的，严格来讲，这并不是完全正确的，因为计算机真正理解“有电”和“无电”。 但是，作为计算机科学家，我们选择了一元值1来表示流向特定节点的电的存在，而选择0来表示其缺电的存在。

The choice to use 1’s and 0’s is only somewhat arbitrary, though. Arguably, we could have used A and B, or x and y, but there is a method to the madness in choosing 1 and 0.

不过，使用1和0的选择只是有些随意。 可以说，我们可以使用A和B或x和y ，但是选择1和0有一种疯狂的方法。

The nature of either having power or not having power is a binary relationship — that is, there are two (and only two) possible states, only one of which can be true at any given time. Mathematically we represent the binary number system with only 1 and 0; and given how inherently embedded mathematics is in the computer science realm, 1 and 0 are the only sensible choice that allows us to practically (and mathematically) ensure a congruent and holistic communication system between a computer’s operations and the underlying physics.

拥有权力或不拥有权力的本质是二元关系-也就是说，有两个(只有两个)可能的状态，在任何给定时间只有一个是正确的。 在数学上，我们表示只有1和0的二进制数系统; 考虑到计算机科学领域内在地嵌入数学的本质，因此1和0是唯一明智的选择，它使我们能够(从数学上)切实地确保计算机操作与基础物理学之间的一致性和整体性。

So, that’s all fine and dandy, but as I mentioned earlier, the machine code we may try to look at isn’t even human readable, so how do we possibly bridge the gap between what we type on the computer and the 1’s and 0’s?

因此，这一切都很好，但正如我之前提到的，我们可能尝试查看的机器代码甚至不是人类可读的，因此我们如何弥合计算机上键入的内容与数字1之间的差距。和0的？

Enter assembly code.

输入汇编代码。

(3/5)汇编代码 ： ((3/5) Assembly Code:)

Assembly code is different than machine code in that it is (slightly) more writable and readable by humans. Here’s a snippet of some assembly code:

汇编代码与机器代码的不同之处在于，汇编代码(在某种程度上)更容易被人类书写和阅读。 这是一些汇编代码的片段：

Computers do not understand assembly code. The code itself is a set of instructions telling the computer what to do, but the computer itself can not interpret it as-is.

计算机不理解汇编代码。 代码本身是一组指令，告诉计算机该怎么做，但计算机本身无法按原样解释它。

What this means is that at this point in our multiple levels of abstraction we’ve already reached the point where we do not communicate with the computer directly anymore. Is there a middleman that can help us deal with this?

这意味着在这一点上，在我们的多个抽象级别中，我们已经到了不再与计算机直接通信的地步。 有中间人可以帮助我们解决这个问题吗？

Yes! That middleman is what’s called an “assembler” .

是! 那个中间人就是所谓的“汇编者”。

On a really simple level, when we write our assembly code, we need to run that code through the assembler which effectively “translates” (i.e. assembles) it into machine code.

在非常简单的级别上，当我们编写汇编代码时，我们需要通过汇编器运行该代码，以有效地将其“转换”(即汇编)为机器代码。

The instructions we wrote in assembly language are now in machine code, which the computer can understand. Hoorah!

我们用汇编语言编写的指令现在以机器代码显示，计算机可以理解。 哎呀！

Moreover, this assembly is very efficient in its execution, and (compared to its machine code counterpart) is much more convenient to write in because it uses symbolic representation to tell the processor what to do.

此外，该程序集的执行效率非常高，并且(与其机器代码对应物相比)更易于写入，因为它使用符号表示法告诉处理器要做什么。

(I realize that it still looks like an alien language to most of us, myself included, but it is a step better that 1’s and 0’s… but don’t worry, we can still do better).

(我意识到，对于我们大多数人(包括我自己)来说，它仍然像是一种外来语言，但比1和0更好……但不要担心，我们仍然可以做得更好。)

The concept of translating from one language to another is incredibly important. In fact, it is key to how the average programmer has the ability to get the computer to do what we want it to.

从一种语言翻译成另一种语言的概念非常重要。 实际上，这是普通程序员如何使计算机执行我们想要的功能的关键。

All that said, it is still incredibly uncommon in 2020 for developers to get their hands dirty with assembly language. Let’s take another step closer to familiarity with low-level languages.

话虽这么说，到2020年，对于开发人员来说，用汇编语言弄脏自己的手仍然是非常罕见的。 让我们更进一步地熟悉底层语言。

(4/5)低级语言： ((4/5) Low(er)-Level Languages:)

Technically speaking, machine code and assembly language are what we call Low-Level Languages. We refer to them as such because they are very close to speaking to the hardware of the computer directly.

从技术上讲，机器代码和汇编语言就是我们所谓的低级语言。 我们之所以这样称呼它们，是因为它们非常接近于直接与计算机的硬件对话。

However, the distinction is not crystal clear between what is considered a low-level language, and a high-level language.

然而，在被认为是低级语言和高级语言之间的区别尚不清楚。

There are many languages that tend somewhat toward the lower-side, such as C++, COBOL, and Fortran which serve to take one further step away from the machine code and assembly language we previously discussed. Here’s a visual of some C++ code, for reference:

有许多语言趋向于较低端，例如C ++，COBOL和Fortran，它们与我们之前讨论的机器代码和汇编语言相比又向前迈进了一步。 这是一些C ++代码的可视化，以供参考：

For some of you, we may be beginning to step into the realm of the familiar. These languages are sometimes talked about, and they’re definitely still employed by many coders and organizations. Typically speaking, they are even more readable and writable than assembly language, similar to how assembly language was more readable than machine code.

对于你们中的某些人，我们可能已开始涉足熟悉的领域。 这些语言有时会被谈论，并且它们肯定仍被许多编码人员和组织所采用。 通常来说，它们比汇编语言更具可读性和可写性，类似于汇编语言比机器代码更具可读性。

When you write code in a lower-level language, the translation process to assembly language is called “compiling”. Compilers are an incredibly important, but also incredibly complex, topic, so I will leave the details to the godfather of compiling, The Dragon Book.

当您使用低级语言编写代码时，到汇编语言的翻译过程称为“编译”。 编译器是一个非常重要但又非常复杂的主题，因此我将把细节留给编译的教父《龙书》 。

Although many developers now use high-level languages (covered next), there are still many benefits to using lower-level languages. One of the main ones is definitely fast performance — the closer you are to communicating to the hardware, the more efficient your programs will run.

尽管现在许多开发人员使用高级语言(下一节介绍)，但是使用低级语言仍然有很多好处。 主要性能之一绝对是快速的性能-您与硬件的通信越近，程序的运行效率就越高。

There are plenty of institutions that haven’t moved on from lower-level technologies because they are unable (and more often unwilling) to do a complete overhaul of their existing systems into less antiquated technologies (I’m looking at you, banks!) There is nothing wrong with low(er)-level languages; in fact, as I mentioned, they are highly efficient.

许多机构尚未从低级技术转移过来，因为它们无法(通常不愿将其现有系统完全翻修为陈旧的技术(我在看您，银行！)低级语言没有什么问题； 实际上，正如我提到的那样，它们是高效的。

However, they do tend to be less accessible to those with very little experience, and still aren’t quite as familiar to the average person. For our final step into modern-day coding, let’s take our final step by looking at high-level languages.

但是，对于那些经验很少的人来说，它们确实更容易获得，而且对普通人来说还不那么熟悉。 对于我们进入现代编码的最后一步，让我们通过研究高级语言来迈出最后一步。

(5/5)高级语言： ((5/5) High-Level Language:)

High-level languages, as the name suggests, are the furthest level of abstraction away from directly communicating with the machine (i.e. they are high up). The high-level realm belongs to languages like Python, JavaScript, Swift, Java, Ruby, etc. Although some of these may still be unfamiliar to many of us, they are much more common household terms than x86 Assembly.

顾名思义，高级语言是与直接与机器通信(即高级 )的最抽象的层次。 高级领域属于Python，JavaScript，Swift，Java，Ruby等语言。尽管其中一些对于我们中的许多人可能仍然不熟悉，但与x86 Assembly相比，它们是更常见的家喻户晓的术语。

Many programmers who take their first steps in coding will begin with learning high-level languages. And quite frankly, they may still stay in this realm throughout their careers.

许多迈出编程第一步的程序员将从学习高级语言开始。 坦率地说，他们可能在整个职业生涯中仍然停留在这个领域。

There is absolutely nothing wrong with this. High level languages have allowed us to create some of the world’s most popular software, games, and applications, across all our favourite devices. However, it is important to understand what the benefits and tradeoffs are of high-level languages.

这绝对没有错 。 高级语言使我们能够在所有喜欢的设备上创建一些世界上最受欢迎的软件，游戏和应用程序。 但是，重要的是要了解高级语言的优点和缺点。

The biggest pro of high-level languages is accessibility; they are relatively easy to learn by anybody who has the patience to struggle through the initial learning curve. Thankfully, the higher-level a language is, the closer it tends to be to English! A language like Python can almost be read by somebody with little-to-know programming experience because of how similar it is to our everyday vernacular. Have a look here:

高级语言的最大优点是可访问性。 有耐心在最初的学习曲线中挣扎的任何人都相对容易学习它们。 值得庆幸的是，一门语言越高级，它就越倾向于英语 ！ 像Python这样的语言几乎可以被几乎没有编程经验的人阅读，因为它与我们日常的母语非常相似。 在这里看看：

The biggest con of high-level languages is that to eventually get down to machine code, it takes quite a few steps of work for our transpilers, compilers, and assemblers. This in turn leads to inefficiencies that may limit what can be done with one programming language, but may be feasible with another.

高级语言的最大con是，最终踏踏实实地机器代码，它需要的工作相当多的步骤，我们transpilers，编译器和汇编程序。 反过来，这导致效率低下，这可能会限制使用一种编程语言可以完成的工作，但对于另一种编程语言则可能是可行的。

(The process of translating from a high-level language to a lower-level language is called “transpiling”, which is a subset of “compiling”.)

(从高级语言转换为低级语言的过程称为“翻译”，是“编译”的子集。)

Colloquially, you may hear people saying that a language like C++ is very efficient, where as one like Python is very inefficient. If you’re building a highly graphically and computationally involved program like a video game or a mapping application, Python won’t cut it — C++ is almost exclusively the way to go.

通俗地说，你可能会听到人们说，像C ++语言是非常有效的，那里的人喜欢Python是非常高效 。 如果您要构建一个图形和计算量很大的程序，例如视频游戏或地图应用程序，那么Python就不会削减它-C ++几乎是唯一的选择。

However, data analysis and other simple programs lend themselves very well to Python, which has proven itself an incredible tool across countless situations.

但是，数据分析和其他简单程序很适合Python，它已证明自己是无数种情况下不可思议的工具。

This does not make one programming language better than another, per se. You may choose to learn one over another depending on your use case, or your general previous coding experience. Learning Python would be really manageable, Java would be a touch harder, and C++ would be even less advisable for brand-new beginners.

本身并不能使一种编程语言比另一种编程语言更好。 您可以选择根据自己的使用情况或以前的一般编码经验来学习。 学习Python确实是可管理的，Java会更难，而C ++对于新手来说则更不可取。

In summary, we learned that learning to code is equivalent to learning how to speak a language, and then relying on a series of translations that will break down our syntax into sequentially more obscure symbols, eventually bringing it to 1’s and 0’s, which then direct the computer on which bits to run power to, and which to shut off. If you refer back to that stack at the beginning of the article, and now read it from the top-down, the whole process should make a bit more sense now:

总而言之，我们了解到学习编码等同于学习如何说一种语言，然后依靠一系列翻译来将我们的语法分解为顺序更晦涩的符号，最终将其变成1和0 。 ，然后将计算机定向到要向其供电的电源和要关闭的电源。 如果您在本文开头引用该堆栈，然后从上至下阅读它，那么整个过程现在应该更有意义：

- High level languages get transpiled into lower level languages

-高级语言被翻译成低级语言

- Lower level languages get compiled into assembly language

-低级语言被编译成汇编语言

- Assembly language gets assembled into machine code

-汇编语言被汇编成机器代码

- Machine code tells the hardware where to allocate and direct power

-机器码告诉硬件在哪里分配电源

- The hardware uses combinations of bits operate the power in order to run the programs and applications what we want it to

-硬件使用位组合操作电源，以便运行程序和应用程序所需的功能

I will reiterate though that there is much, much more to this than could be covered in a short article. There are developers and wickedly good computer scientists who actually write the assemblers/compilers we all take for granted, and who help us continue to evolve the field in more ways than we can imagine. To describe their roles and responsibilities is far above my pay grade, but I do hope to be able to speak more to their contributions as I learn about them over the many years to come.

我要重申的是，除了短篇文章所涵盖的内容之外，还有很多其他内容。 有一些开发人员和邪恶的优秀计算机科学家，他们实际上编写了我们都视为理所当然的汇编器/编译器，并帮助我们以超出我们想象的方式继续发展该领域。 描述他们的角色和职责远远超出了我的薪水等级，但是我希望能够在我了解他们的许多年后能更多地谈论他们的贡献。

I hope you enjoyed reading this as much as I enjoyed writing it! As a follow-up to this article, I am considering elaborating on it by explaining how to go about writing your own programming language. Feel free to write me / comment below if this is something you’d be interested in reading, or if you have any other questions and comments about the article :)

希望您和我喜欢写它一样喜欢阅读本文！ 作为本文的后续，我正在考虑通过解释如何编写自己的编程语言来对其进行详细说明。 如果您对此感兴趣，或者对本文有其他疑问和意见，请随时在下方给我写评论。