学习的动机

As computer scientists, we know that computers are great at aiding in repetitive tasks. However, far too often, we forget that this applies just as much to our use of the computer as it does to the computations we want our programs to perform. We have a vast range of tools available at our fingertips that enable us to be more productive and solve more complex problems when working on any computer-related problem. Yet many of us utilize only a small fraction of those tools; we only know enough magical incantations by rote to get by, and blindly copy-paste commands from the internet when we get stuck.

作为计算机科学家，我们知道计算机在帮助重复性任务方面非常出色。然而，我们常常忘记，这同样适用于我们对计算机的使用，就像它适用于我们希望程序执行的计算一样。我们手头有各种各样的工具，可以让我们在处理任何与计算机相关的问题时更高效，解决更复杂的问题。然而，我们中的许多人只使用了这些工具中的一小部分；我们只能死记硬背足够多的魔法咒语，当我们陷入困境时，我们会盲目地从互联网上复制粘贴命令。

This class is an attempt to address this.

本课程试图解决这个问题。

We want to teach you how to make the most of the tools you know, show you new tools to add to your toolbox, and hopefully instill in you some excitement for exploring (and perhaps building) more tools on your own. This is what we believe to be the missing semester from most Computer Science curricula.

我们想教你如何最大限度地利用你所知道的工具，向你展示新的工具来添加到你的工具箱中，并希望为你自己探索（也许是构建）更多工具注入一些兴奋。

我们认为这是大多数计算机科学课程中缺失的一个学期。

课程结构

The class consists of 11 1-hour lectures, each one centering on a particular topic. The lectures are largely independent, though as the semester goes on we will presume that you are familiar with the content from the earlier lectures. We have lecture notes online, but there will be a lot of content covered in class (e.g. in the form of demos) that may not be in the notes. We will be recording lectures and posting the recordings online.

课程共11堂课，每堂课时长1小时，每堂课围绕一个主题(/2020/)。课程基本上是独立的，但随着学期的进行，我们会假设你已经熟悉了之前课程的内容。我们网上有课堂讲稿，但会有很多课堂上讲过的内容(例如，演示的形式)可能不在课堂讲稿中。我们会录制讲座并将录音发布到网上。

We are trying to cover a lot of ground over the course of just 11 1-hour lectures, so the lectures are fairly dense. To allow you some time to get familiar with the content at your own pace, each lecture includes a set of exercises that guide you through the lecture's key points. After each lecture, we are hosting office hours where we will be present to help answer any questions you might have. If you are attending the class online, you can send us questions at missing-semester@mit.edu.

我们试图在11个1小时的课程中涵盖很多内容，所以课程相当密集。为了让你有时间按照自己的节奏熟悉课程内容，每节课都包括一套指导你通过课程要点的练习。每堂课结束后，我们都会安排办公时间，届时我们将为您解答任何问题。如果你在网上上课，你可以把问题发送到missing-semester@mit.edu.

Due to the limited time we have, we won't be able to cover all the tools in the same level of detail a full-scale class might. Where possible, we will try to point you towards resources for digging further into a tool or topic, but if something particularly strikes your fancy, don't hesitate to reach out to us and ask for pointers!

由于时间有限，我们不可能像一个完整的课程那样详细地介绍所有的工具。在可能的情况下，我们将尝试为您提供进一步挖掘工具或主题的资源，但如果您特别喜欢某个工具或主题，请不要犹豫，联系我们并寻求指导！

Topic 1: The Shell

Shell 是什么?

Computers these days have a variety of interfaces for giving them commands; fanciful graphical user interfaces, voice interfaces, and even AR/VR are everywhere. These are great for 80% of use-cases, but they are often fundamentally restricted in what they allow you to do — you cannot press a button that isn't there or give a voice command that hasn't been programmed. To take full advantage of the tools your computer provides, we have to go old-school and drop down to a textual interface: The Shell.

现在的计算机有各种各样的界面来给它们发命令；奇特的图形用户界面、语音界面，甚至AR/VR无处不在。对于80%的用例来说，这些都是很好的，但它们通常在允许你做的事情上受到根本性的限制——你不能按下不在那里的按钮，也不能发出未编程的语音命令。为了充分利用您的计算机提供的工具，我们必须走老路，转而使用文本界面：Shell。

Nearly all platforms you can get your hand on has a shell in one form or another, and many of them have several shells for you to choose from. While they may vary in the details, at their core they are all roughly the same: they allow you to run programs, give them input, and inspect their output in a semi-structured way.

几乎所有您可以接触到的平台都有一种或另一种形式的shell，其中许多平台都有几种shell供您选择。虽然它们在细节上可能有所不同，但它们的核心都大致相同:它们允许您以半结构化的方式运行程序、向它们提供输入并检查它们的输出。

In this lecture, we will focus on the Bourne Again SHell, or "bash" for short. This is one of the most widely used shells, and its syntax is similar to what you will see in many other shells. To open a shell prompt (where you can type commands), you first need a terminal. Your device probably shipped with one installed, or you can install one fairly easily.

在这一讲中，我们将关注Bourne Again SHell，或简称为“bash”。这是使用最广泛的shell之一，它的语法与您将在许多其他shell中看到的类似。要打开shell_prompt(可以在其中键入命令)，首先需要一个terminal_。您的设备可能附带安装了一个，或者您可以相当容易地安装一个。

使用Shell

When you launch your terminal, you will see a prompt that often looks a little like this:

当你启动你的终端，你会看到一个提示符_通常看起来像这样:
missing:~$ 

This is the main textual interface to the shell. It tells you that you are on the machine missing and that your "current working directory", or where you currently are, is ~ (short for "home"). The $ tells you that you are not the root user (more on that later). At this prompt you can type a command, which will then be interpreted by the shell. The most basic command is to execute a program:

这是shell的主要文本接口。它告诉你你在机器上“失踪”，你的“当前工作目录”或你当前所在的位置是“~”（home的缩写）。“$”告诉您不是root用户（稍后将详细介绍）。在这个提示下，您可以键入一个_命令u，然后shell将对其进行解释。最基本的命令是执行一个程序：
missing:~$ date
Fri 10 Jan 2020 11:49:31 AM EST
missing:~$ 

Here, we executed the date program, which (perhaps unsurprisingly) prints the current date and time. The shell then asks us for another command to execute. We can also execute a command with arguments:

在这里，我们执行了“date”程序，它（也许并不意外）打印当前的日期和时间。然后，shell请求我们执行另一个命令。我们还可以执行带有_参数的命令：
missing:~$ echo hello
hello

In this case, we told the shell to execute the program echo with the argument hello. The echo program simply prints out its arguments. The shell parses the command by splitting it by whitespace, and then runs the program indicated by the first word, supplying each subsequent word as an argument that the program can access. If you want to provide an argument that contains spaces or other special characters (e.g., a directory named "My Photos"), you can either quote the argument with ' or " ("My Photos"), or escape just the relevant characters with \ (My\ Photos).

在这个例子中，我们告诉shell用参数' hello '执行程序' echo '。' echo '程序简单地输出它的参数。 shell通过使用空格分隔命令来解析该命令，然后运行由第一个单词指示的程序，将后面的每个单词作为程序可以访问的参数提供。如果你想提供一个包含空格或其他特殊字符的参数(例如，一个名为"My Photos"的目录)，你可以用" ' '或' ' ' ' '引用参数(' My Photos ')，或者用' \ ' (' My\ Photos ')转义相关字符。

But how does the shell know how to find the date or echo programs? Well, the shell is a programming environment, just like Python or Ruby, and so it has variables, conditionals, loops, and functions (next lecture!). When you run commands in your shell, you are really writing a small bit of code that your shell interprets. If the shell is asked to execute a command that doesn't match one of its programming keywords, it consults an environment variable called $PATH that lists which directories the shell should search for programs when it is given a command:

但是shell如何知道如何找到“date”或“echo”程序呢?好吧，shell是一种编程环境，就像Python或Ruby一样，所以它有变量、条件、循环和函数(下一讲!)当您在shell中运行命令时，实际上是编写了一小段由shell解释的代码。如果shell被要求执行一个不匹配其编程关键字之一的命令，它会咨询一个名为' $PATH '的_environment变量，该变量列出了shell在执行命令时应该搜索的目录:

missing:~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
missing:~$ which echo
/bin/echo
missing:~$ /bin/echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

When we run the echo command, the shell sees that it should execute the program echo, and then searches through the :-separated list of directories in $PATH for a file by that name. When it finds it, it runs it (assuming the file is executable; more on that later). We can find out which file is executed for a given program name using the which program. We can also bypass $PATH entirely by giving the path to the file we want to execute.

当我们运行'echo'命令时，shell看到它应该执行程序'echo'，然后在“￥PATH”中以“：”分隔的目录列表中搜索该名称的文件。当它找到它时，它会运行它（假设该文件是可执行的，稍后会详细介绍）。我们可以使用'which'来找出为给定程序名执行的文件。我们也可以通过给想要执行的文件指定路径来完全绕过“$PATH”。

Shell定位文件

A path on the shell is a delimited list of directories; separated by / on Linux and macOS and \ on Windows. On Linux and macOS, the path / is the "root" of the file system, under which all directories and files lie, whereas on Windows there is one root for each disk partition (e.g., C:\). We will generally assume that you are using a Linux filesystem in this class. A path that starts with / is called an absolute path. Any other path is a relative path. Relative paths are relative to the current working directory, which we can see with the pwd command and change with the cd command. In a path, . refers to the current directory, and .. to its parent directory:

shell中的路径是目录的分隔列表;在Linux和macOS上用' / '分隔，在Windows上用' \ '分隔。在Linux和macOS上，路径' / '是文件系统的"根"，所有的目录和文件都在下面，而在Windows上每个磁盘分区都有一个根(例如，' C:\ ')。我们通常假设您在这个类中使用的是Linux文件系统。以“/”开头的路径称为absolute path。任何其他路径都是相对路径。相对路径是相对于当前工作目录的，我们可以在' pwd '（print working directory）命令中看到，在' cd '命令中可以更改当前目录。在一个路径上，. 代表当前目录，..代表它的父目录。

cd - 可以返回上一个工作目录。

missing:~$ pwd
/home/missing
missing:~$ cd /home
missing:/home$ pwd
/home
missing:/home$ cd ..
missing:/$ pwd
/
missing:/$ cd ./home
missing:/home$ pwd
/home
missing:/home$ cd missing
missing:~$ pwd
/home/missing
missing:~$ ../../bin/echo hello
hello

Notice that our shell prompt kept us informed about what our current working directory was. You can configure your prompt to show you all sorts of useful information, which we will cover in a later lecture.

注意，我们的shell提示符让我们知道当前的工作目录是什么。您可以配置提示符来显示各种有用的信息，我们将在后面的课程中介绍这些信息。

In general, when we run a program, it will operate in the current directory unless we tell it otherwise. For example, it will usually search for files there, and create new files there if it needs to.

一般来说，当我们运行一个程序时，它将在当前目录下运行，除非我们告诉它。例如，如果需要，通常会在那里搜索新文件。

To see what lives in a given directory, we use the ls command:

要查看给定目录中的内容，我们使用'ls'命令：
missing:~$ ls
missing:~$ cd ..
missing:/home$ ls
missing
missing:/home$ cd ..
missing:/$ ls
bin
boot
dev
etc
home
...

Unless a directory is given as its first argument, ls will print the contents of the current directory. Most commands accept flags and options (flags with values) that start with - to modify their behavior. Usually, running a program with the -h or --help flag will print some help text that tells you what flags and options are available. For example, ls --help tells us:

除非给出一个目录作为其第一个参数，ls将打印当前目录的内容。大多数命令都接受以“-”开头的标志和选项（带有值的标志）来修改其行为。通常，运行带有“-h”或“---help”标志的程序会打印一些帮助文本，告诉您哪些标志和选项可用。例如，“ls--help”告诉我们：

  -l                         use a long listing format

missing:~$ ls -l /home
drwxr-xr-x 1 missing  users  4096 Jun 15  2019 missing

This gives us a bunch more information about each file or directory present. First, the d at the beginning of the line tells us that missing is a directory. Then follow three groups of three characters (rwx). These indicate what permissions the owner of the file (missing), the owning group (users), and everyone else respectively have on the relevant item. A - indicates that the given principal does not have the given permission. Above, only the owner is allowed to modify (w) the missing directory (i.e., add/remove files in it). To enter a directory, a user must have "search" (represented by "execute": x) permissions on that directory (and its parents). To list its contents, a user must have read (r) permissions on that directory. For files, the permissions are as you would expect. Notice that nearly all the files in /bin have the x permission set for the last group, "everyone else", so that anyone can execute those programs.

“ls -l”这为我们提供了关于每个文件或目录的更多信息。首先，该行开头的d告诉我们，missing是一个目录。然后跟随三组字符(rwx)。它们表示文件所有者(missing)、拥有组(users)和其他所有人分别对相关项目拥有哪些权限。A -表示给定的主体没有给定的权限。在上面，只有所有者被允许修改(w)缺失的目录(即，在其中添加/删除文件)。要进入一个目录，用户必须有"search"(用"execute"表示): X)对该目录(及其父目录)的权限。要列出目录的内容，用户必须对该目录具有读(r)权限。对于文件，权限如您所料。请注意，几乎/bin中的所有文件都为最后一个组(“其他人”)设置了x权限，因此任何人都可以执行这些程序。

文件的读写执行rwx权限和目录的读写执行rwx权限不一样。

文件权限： r：读权限，指文件的具体内容，比如说文本文件里面写了些什么。这里“读”的内容不包括文件的属性，比如大小、修改日期、权限等。因为那不属于文件内容。 w：写权限，编辑，修改或者新增文件的内容，但是不含删除该文件。(由父目录的w权限决定) x：执行权限。但拥有了文件的执行权限并不意味着一定可以执行文件，还得看是否拥有父目录的x权限总之，对于文件的r、w、x来说，主要都是针对“文件的内容”，与文件名的存在与否没有关系。因为文件记录的是实际的数据(相对于目录)。 目录的权限： 相对于文件是记录的实际数据，目录主要记录的内容是文件名列表。 r(read contents in directory)：读取目录结构列表。比如ls、find之类。可查看文件名，文件的属性就不一定可以看了，还得得看目录的x权限。 w(modify contents of directory)：修改目录结构列表的权限。包括：新建文件、目录，删除文件、目录(而且无视其权限)，重命名文件、目录，移动文件、目录。比如一个普通用户拥有一个目录的w权限(同时也要拥有目录的x权限)，即便是该目录下有root的文件，也可以照删不误 x(access directory)：意为用户是否可以进入该目录，以此目录作为工作目录。不具有某一目录的x权限，就无法切换到该目录下，该目录下的任何文件也不能被查看、修改、执行、删除。(最多只能看到文件名，前提是有父目录的r权限)。

Some other handy programs to know about at this point are mv (to rename/move a file), cp (to copy a file), and mkdir (to make a new directory).

此时需要了解的其他一些方便的程序包括' mv '(重命名/移动文件)、' cp '(复制文件)和' mkdir '(创建新目录)。

If you ever want more information about a program's arguments, inputs, outputs, or how it works in general, give the man program a try. It takes as an argument the name of a program, and shows you its manual page. Press q to exit.

rm删除命令，只能单次删除一个文件，若要删除一个文件夹，需要加上-r (recursive)来删除文件夹。

rmdir只能删除空文件夹。

如果你想了解更多关于程序的参数、输入、输出或它一般如何工作的信息，可以试试这个“man”程序。它接受一个程序的名称作为参数，并显示它的manual page。按“q”退出。
missing:~$ man ls

通过流连接程序

In the shell, programs have two primary "streams" associated with them: their input stream and their output stream. When the program tries to read input, it reads from the input stream, and when it prints something, it prints to its output stream. Normally, a program's input and output are both your terminal. That is, your keyboard as input and your screen as output. However, we can also rewire those streams!

在shell中，程序有两个与之关联的主要“流”：

它们的输入流和输出流。当程序试图读取输入时，它从输入流中读取，当它打印某些内容时，它打印到输出流中。通常，程序的输入和输出都是终端。也就是说，键盘作为输入，屏幕作为输出。然而，我们也可以重新连接这些流！

The simplest form of redirection is < file and > file. These let you rewire the input and output streams of a program to a file respectively:

最简单的重定向形式是“<file”和“>file”。通过这些功能，您可以将程序的输入流和输出流分别重新连接到文件：
missing:~$ echo hello > hello.txt
missing:~$ cat hello.txt
hello
missing:~$ cat < hello.txt
hello
missing:~$ cat < hello.txt > hello2.txt
missing:~$ cat hello2.txt
hello

Demonstrated in the example above, cat is a program that concatenates files. When given file names as arguments, it prints the contents of each of the files in sequence to its output stream. But when cat is not given any arguments, it prints contents from its input stream to its output stream (like in the third example above).

在上面的例子中，cat是一个连接文件的程序。当给定文件名作为参数时，它会将每个文件的内容按顺序打印到其输出流中。但当cat没有任何参数时，它会将内容从输入流打印到输出流（如上面的第三个示例所示）。

You can also use >> to append to a file. Where this kind of input/output redirection really shines is in the use of pipes. The | operator lets you "chain" programs such that the output of one is the input of another:

您也可以使用' >> '追加到文件。这种输入/输出重定向的真正亮点在于pipes的使用。' | '操作符可以让你“链”程序，这样一个程序的输出就是另一个程序的输入:
missing:~$ ls -l / | tail -n1
drwxr-xr-x 1 root  root  4096 Jun 20  2019 var
missing:~$ curl --head --silent google.com | grep --ignore-case content-length | cut --delimiter=' ' -f2
219

We will go into a lot more detail about how to take advantage of pipes in the lecture on data wrangling.

关于如何利用管道，我们将在关于数据争论的那一讲中详细讨论。

一个强大的工具

On most Unix-like systems, one user is special: the "root" user. You may have seen it in the file listings above. The root user is above (almost) all access restrictions, and can create, read, update, and delete any file in the system. You will not usually log into your system as the root user though, since it's too easy to accidentally break something. Instead, you will be using the sudo command. As its name implies, it lets you "do" something "as su" (short for "super user", or "root"). When you get permission denied errors, it is usually because you need to do something as root. Though make sure you first double-check that you really wanted to do it that way!

在大多数类unix系统中，有一个用户是特殊的:“root”用户。您可能已经在上面的文件清单中看到过它。根用户几乎可以超越所有的访问限制，可以创建、读取、更新和删除系统中的任何文件。不过，您通常不会以根用户身份登录系统，因为很容易意外地破坏某些东西。相反，您将使用' sudo '命令。顾名思义，它允许您以su(“super user超级用户”或“root”的缩写)的身份“做”一些事情。当您获得权限被拒绝的错误时，通常是因为您需要作为根用户执行某些操作。不过，一定要先确认你真的想这样做!

One thing you need to be root in order to do is writing to the sysfs file system mounted under /sys. sysfs exposes a number of kernel parameters as files, so that you can easily reconfigure the kernel on the fly without specialized tools. Note that sysfs does not exist on Windows or macOS.

你需要做的一件事是写' sysfs '文件系统挂载在' /sys '下。' sysfs '将许多内核参数公开为文件，这样你就可以在不需要特殊工具的情况下轻松地重新配置内核。**注意Windows和macOS上不存在sysfs

For example, the brightness of your laptop's screen is exposed through a file called brightness under

例如，你笔记本电脑屏幕的亮度会通过一个名为“亮度”的文件暴露出来
/sys/class/backlight

By writing a value into that file, we can change the screen brightness. Your first instinct might be to do something like:

通过在文件中写入一个值，我们可以改变屏幕亮度。你的第一反应可能是这样的:

$ sudo find -L /sys/class/backlight -maxdepth 2 -name '*brightness*'
/sys/class/backlight/thinkpad_screen/brightness
$ cd /sys/class/backlight/thinkpad_screen
$ sudo echo 3 > brightness
An error occurred while redirecting file 'brightness'
open: Permission denied

This error may come as a surprise. After all, we ran the command with sudo! This is an important thing to know about the shell. Operations like |, >, and < are done by the shell, not by the individual program. echo and friends do not "know" about |. They just read from their input and write to their output, whatever it may be. In the case above, the shell (which is authenticated just as your user) tries to open the brightness file for writing, before setting that as sudo echo's output, but is prevented from doing so since the shell does not run as root. Using this knowledge, we can work around this:

这个错误可能会令人惊讶。毕竟，我们使用' sudo '运行命令!这是关于shell很重要的一点。像' | '、' > '和' < '这样的操作由shell完成，而不是由单个程序完成。' echo '和朋友不知道' | '。他们只是从输入中读取，然后写入输出，不管它是什么。在上面的例子中，shell_(就像你的用户一样经过身份验证)试图打开亮度文件进行写入，在设置为' sudo echo ' '的输出之前，但是由于shell不是作为根用户运行，所以被阻止这样做。利用这些知识，我们可以解决这个问题:
$ echo 3 | sudo tee brightness

Since the tee program is the one to open the /sys file for writing, and it is running as root, the permissions all work out. You can control all sorts of fun and useful things through /sys, such as the state of various system LEDs (your path might be different):

因为tee程序是打开/sys文件进行写入的程序，并且它以root用户的身份运行，所以权限都是有效的。你可以通过/sys控制各种有趣和有用的东西，比如各种系统led的状态(你的路径可能不同):
$ echo 1 | sudo tee /sys/class/leds/input6::scrolllock/brightness

下一步

At this point you know your way around a shell enough to accomplish basic tasks. You should be able to navigate around to find files of interest and use the basic functionality of most programs. In the next lecture, we will talk about how to perform and automate more complex tasks using the shell and the many handy command-line programs out there.

至此，您已经对shell有了足够的了解，可以完成基本的任务。您应该能够四处导航，找到感兴趣的文件，并使用大多数程序的基本功能。在下一讲中，我们将讨论如何使用shell和许多方便的命令行程序执行和自动化更复杂的任务。

练习

All classes in this course are accompanied by a series of exercises. Some give you a specific task to do, while others are open-ended, like "try using X and Y programs". We highly encourage you to try them out.

We have not written solutions for the exercises. If you are stuck on anything in particular, feel free to send us an email describing what you've tried so far, and we will try to help you out.

For this course, you need to be using a Unix shell like Bash or ZSH. If you are on Linux or macOS, you don't have to do anything special. If you are on Windows, you need to make sure you are not running cmd.exe or PowerShell; you can use Windows Subsystem for Linux or a Linux virtual machine to use Unix-style command-line tools. To make sure you're running an appropriate shell, you can try the command echo $SHELL. If it says something like /bin/bash or /usr/bin/zsh, that means you're running the right program.
Create a new directory called missing under /tmp.
Look up the touch program. The man program is your friend.
Use touch to create a new file called semester in missing.
Write the following into that file, one line at a time:
```
#!/bin/sh
curl --head --silent https://missing.csail.mit.edu
```
The first line might be tricky to get working. It's helpful to know that # starts a comment in Bash, and ! has a special meaning even within double-quoted (") strings. Bash treats single-quoted strings (') differently: they will do the trick in this case. See the Bash quoting manual page for more information.
Try to execute the file, i.e. type the path to the script (./semester) into your shell and press enter. Understand why it doesn't work by consulting the output of ls (hint: look at the permission bits of the file).
Run the command by explicitly starting the sh interpreter, and giving it the file semester as the first argument, i.e. sh semester. Why does this work, while ./semester didn't?
Look up the chmod program (e.g. use man chmod).
Use chmod to make it possible to run the command ./semester rather than having to type sh semester. How does your shell know that the file is supposed to be interpreted using sh? See this page on the shebang line for more information.
Use | and > to write the "last modified" date output by semester into a file called last-modified.txt in your home directory.
Write a command that reads out your laptop battery's power level or your desktop machine's CPU temperature from /sys. Note: if you're a macOS user, your OS doesn't have sysfs, so you can skip this exercise.

MIT缺失的一课——Lecture1:Shell相关推荐

[MIT公开课(计算机教育中缺失的一课)]2.Shell工具与脚本
(该系列文章大部分内容来源于MIT课程笔记,加入了个人的理解.原笔记中没有的细节和其他的需要理解的内容,公开课地址:https://www.bilibili.com/video/BV14E411J7n ...
[MIT公开课(计算机教育中缺失的一课)]10.大杂烩
(该系列文章大部分内容来源于MIT课程笔记,加入了个人的理解.原笔记中没有的细节和其他的需要理解的内容,公开课地址:https://www.bilibili.com/video/BV14E411J7n ...
[MIT公开课(计算机教育中缺失的一课)]6. 版本控制(git)
(该系列文章大部分内容来源于MIT课程笔记,加入了个人的理解.原笔记中没有的细节和其他的需要理解的内容,公开课地址:https://www.bilibili.com/video/BV14E411J7n ...
计算机教育中缺失的一课 - MIT - L5 - 命令行环境
https://missing.csail.mit.edu/ https://missing-semester-cn.github.io/ https://www.bilibili.com/video ...
计算机教育中缺失的一课 · the missing semester of your cs education
小编作为一个程序猿圈子的过来猿,一直觉得现在很多大学里的计算机课程往往只专注于传授学生关于从操作系统到机器学习这些学院派的课程或主题,而在一些工具的运用及精通方面,往往会留给学生自行摸索. 其实学编程 ...
第二课《shell 编程基础》
编程语言分类: 编译型解释型编译型语言:c.c++.c# 解释型语言: 内置型:shell.perl源码并入了linux kernel,提供内核级单条语句的效率外置型:python.java.j ...
方程组的几何解释 [MIT线代第一课pdf下载]
攻读鉴于之前MIT的线代笔记没有跟新完和很多童鞋希望pdf版本下载学习,这里我把相关资源放到github上并重新更新完,希望对大家学习有所帮助. pdf下载地址与Github地址: https://g ...
计算机教育中缺失的一课，劝学弟学妹们一句，一定要趁早补上，工作后会如有神助！
CSDN 的同学们,大家好,今天我是来补课的. 「上一篇」把命令行.终端.Shell 搞清楚后(还没搞清楚的可以点击蓝字过去看一眼),今天这篇写起来就顺畅多了.哦,极度的舒适! 开门见山地说吧.大学里 ...
【shell附加课】shell脚本调试方案详解
文章目录前言一. shell脚本开发规范二. shell脚本调试技巧 1. 使用echo +exit 命令断点调试 2. 使用bash命令参数调优 3. 使用 set 来调试脚本总结前言最 ...

MIT缺失的一课——Lecture1:Shell