
English: 
This episode is supported by Hover.
Hi, I'm Carrie Anne, and welcome to Crash
Course Computer Science!
Computers in the 1940s and early 50s ran one
program at a time.
A programmer would write one at their desk,
for example, on punch cards.
Then, they’d carry it to a room containing
a room-sized computer, and hand it to a dedicated
computer operator.
That person would then feed the program into
the computer when it was next available.
The computer would run it, spit out some output,
and halt.
This very manual process worked OK back when
computers were slow, and running a program
often took hours, days or even weeks.
But, as we discussed last episode, computers
became faster... and faster... and faster
– exponentially so!
Pretty soon, having humans run around and
inserting programs into readers was taking
longer than running the actual programs themselves.
We needed a way for computers to operate themselves,
and so, operating systems were born.
INTRO

Korean: 
이 강의는 Hover 에서 지원됩니다.
안녕하세요, 저는 Carrie Anne입니다. 
컴퓨터 과학 특강에 오신 것을 환영합니다!
1940년대와 50년대 초반의 컴퓨터는
한 번에 한 개의 프로그램을 실행했습니다.
프로그래머는 자신의 책상에서 프로그램을
예를 들어,  펀치 카드에 하나를 쓰듯이 썼습니다.
그런 다음, 그들은 그것을 방 크기의 컴퓨터가 있는 방으로 가져 와서 전용 컴퓨터 운영자에게 건넸습니다.
그런 다음, 그들은 그것을 방 크기의 컴퓨터가 있는 방으로 가져 와서 전용 컴퓨터 운영자에게 건넸습니다.
그 사람은 프로그램을 컴퓨터에 공급합니다.
컴퓨터는 그것을 실행할 것이고, 
약간의 출력을 내뱉고 정지합니다.
이 아주 수동적인 프로세스는 컴퓨터가 느려졌을 때 
다시 돌아가서, 프로그램을 실행하는 데에는 종종
몇 시간, 며칠 또는 몇 주가 걸렸습니다.
그러나 우리가 지난 강의에서 논의한대로, 
컴퓨터는 더 빨라지고 빨라지고 빨라졌습니다.
기하 급수적으로요!
조만간, 인간이 뛰어 다니면서 
판독기들에게 프로그램을 삽입하는 것은
실제 프로그램 자체를 실행하는 것 보다 
오래 걸리게 됩니다.
컴퓨터가 스스로 작동할 수있는 방법이 필요했습니다.
그리하여 운영 체제가 탄생했습니다.
 

French: 
Cet épisode est soutenu par Hover.
Salut, je suis Carrie Anne, et bienvenue à Crash Course Computer Science!
Ordinateurs dans les années 1940 et début des années 50 a couru un programme à la fois.
Un programmeur en écrirait un à son bureau, par exemple, sur des cartes perforées.
Ensuite, ils l'emportaient dans une pièce contenant un ordinateur de la taille d'une pièce, et le remettaient à un
operateur d'ordinateur.
Cette personne enverrait alors le programme dans l'ordinateur quand il serait disponible.
L'ordinateur l'exécute, crache une sortie et s'arrête.
Ce processus très manuel a fonctionné correctement lorsque les ordinateurs étaient lents et exécutant un programme
souvent pris des heures, des jours ou même des semaines.
Mais, comme nous l'avons vu dans le dernier épisode, les ordinateurs sont devenus plus rapides ... et plus rapides ... et plus rapides
- exponentiellement!
Bientôt, avoir des humains courir et insérer des programmes dans les lecteurs prenait
plus longtemps que d'exécuter les programmes eux-mêmes.
Nous avions besoin d'un moyen pour les ordinateurs de fonctionner eux-mêmes, et ainsi, les systèmes d'exploitation sont nés.
 

Chinese: 
(｡･∀･)ﾉﾞ 我是Carrie Anne 欢迎收看 10 分钟速成课：计算机科学
1940,1950年代的电脑每次只能运行一个程序
程序员在办公桌上写程序（比如打孔卡上）
然后把程序带到房间大小的计算机那里
交给专门的电脑操作员
操作员会在下次电脑可用时 把程序放入电脑
然后电脑运行程序
输出结果，然后停机
以前电脑运行缓慢，这种手动做法可以接受
运行一个程序通常要数小时，数天甚至数周时间
然而，正如上集讨论的
电脑变得越来越快，越来越快
指数级增长！
很快，人类手动把程序放入读卡器花的时间
比运行程序还要长
我们需要一种让计算机自动运作的方式
于是“操作系统”诞生了

Chinese: 
操作系统，简称“OS” 其实也是程序
但它拥有操作硬件的特殊权限  使它可以运行并管理其它程序
操作系统通常是开机时第一个启动的
其他所有程序都由“操作系统”启动
操作系统 起源于 1950 年代
那时计算机开始变得强大且流行
第一个操作系统可以手动加载程序
之前计算机一次只能喂入一个程序
现在可以一次多个
当计算机运行完一个程序
它会自动运行下一个程序
这样时间就不会浪费在找下一个程序的纸片
这叫“批处理”
电脑变得更快的同时，也更便宜
因此开始在世界各地涌现
首先便是大学和政府办公室
很快，人们开始分享软件
但有一个问题
在 哈佛马克1型 和 ENIAC 那个时代，计算都是一次性的
程序员只要为那"一台"机器写代码
处理器，读卡器和打印机都是已知且不变的
但随着电脑越来越普遍

English: 
Operating systems, or OS’es for short, are
just programs.
But, special privileges on the hardware let
them run and manage other programs.
They’re typically the first one to start
when a computer is turned on, and all subsequent
programs are launched by the OS.
They got their start in the 1950s, as computers
became more widespread and more powerful.
The very first OSes augmented the mundane,
manual task of loading programs by hand.
Instead of being given one program at a time,
computers could be given batches.
When the computer was done with one, it would automatically and near-instantly start the next.
There was no downtime while someone scurried
around an office to find the next program
to run.
This was called batch processing.
While computers got faster, they also got
cheaper.
So, they were popping up all over the world,
especially in universities and government
offices.
Soon, people started sharing software.
But there was a problem…
In the era of one-off computers, like the
Harvard Mark 1 or ENIAC, programmers only
had to write code for that one single machine.
The processor, punch card readers, and printers
were known and unchanging.

French: 
Les systèmes d'exploitation, ou OS'es pour faire court, sont juste des programmes.
Mais, des privilèges spéciaux sur le matériel permettant d'exécuter et de gérer d'autres programmes.
Ils sont généralement le premier à démarrer quand un ordinateur est allumé, et tous les suivants
les programmes sont lancés par le système d'exploitation.
Ils ont commencé dans les années 1950, à mesure que les ordinateurs devenaient plus répandus et plus puissants.
Les tout premiers OS ont augmenté la tâche manuelle et manuelle de chargement manuel des programmes.
Au lieu de recevoir un programme à la fois, les ordinateurs pourraient recevoir des lots.
Quand l'ordinateur a été fait avec un, il commencerait automatiquement et presque instantanément le suivant.
Il n'y avait pas de temps d'arrêt pendant que quelqu'un se promenait dans un bureau pour trouver le prochain programme
courir.
Cela a été appelé traitement par lots
Alors que les ordinateurs sont plus rapides, ils sont également moins chers
Donc, ils ont surgi partout dans le monde, en particulier dans les universités et le gouvernement
des bureaux.
Bientôt, les gens ont commencé à partager des logiciels.
Mais il y avait un problème…
À l'ère des ordinateurs uniques, comme le Harvard Mark 1 ou ENIAC, les programmeurs seulement
a dû écrire du code pour cette seule machine.
Le processeur, les lecteurs de cartes perforées et les imprimantes étaient connus et immuables.

Korean: 
운영체제 또는 짧게 OS는 단지 프로그램과 같습니다.
그러나 하드웨어에 대한 특별한 권한으로,
다른 프로그램을 실행하고 관리할 수 있습니다.
OS는 일반적으로 컴퓨터 전원을 처음 켰을 때 
시작하는 프로그램이며
모든 후속 프로그램은 OS에 의해 시작됩니다.
OS는 컴퓨터가 더욱 광범위하고 강력해진 1950년대에 시작되었습니다.
최초의 OS는 수작업으로 프로그램을 로드하는 
일상적인 수동 작업을 보강했습니다.
한 번에 하나의 프로그램을 받는 대신,
컴퓨터가 일괄적으로 배치할 수 있었습니다.
컴퓨터가 하나를 완료하면 
자동으로 거의 즉시 다음을 시작합니다.
누군가가 사무실에서 다음 프로그램을 찾느라 고생하는 
동안 가동 중단 시간은 없었습니다.
누군가가 사무실에서 다음 프로그램을 찾느라 고생하는 
동안 가동 중단 시간은 없었습니다.
이를 일괄 처리라고 합니다.
컴퓨터가 더 빨라지는 동안, 가격은 내려갔습니다.
그래서, 그들은 전 세계에 곳곳에,
특히 대학과 관공서에서 나타났습니다.
그래서, 그들은 전 세계에 곳곳에,
특히 대학과 관공서에서 나타났습니다.
곧 사람들은 소프트웨어를 공유하기 시작했습니다.
그러나 문제가 있었습니다.
Havard Mark 1이나 ENIAC과 같은 
유일성 컴퓨터의 시대에는
프로그래머들만이 하나의 기계에 대한 
코드를 써야만 했습니다.
프로세서, 펀치 카드 판독기 및 프린터
는 이미 알려져 있었고 변함이 없었습니다.

English: 
But as computers became more widespread, their
configurations were not always identical,
like computers might have the same CPU, but
not the same printer.
This was a huge pain for programmers.
Not only did they have to worry about writing
their program, but also how to interface with
each and every model of printer, and all devices
connected to a computer, what are called peripherals.
Interfacing with early peripherals was very
low level, requiring programmers to know intimate
hardware details about each device.
On top of that, programmers rarely had access to every model of a peripheral to test their code on.
So, they had to write code as best they could,
often just by reading manuals, and hope it
worked when shared.
Things weren’t exactly plug-and-play back
then… more plug-and-pray.
This was clearly terrible, so to make it easier
for programmers, Operating Systems stepped
in as intermediaries between software programs
and hardware peripherals.
More specifically, they provided a software
abstraction, through APIs, called device drivers.
These allow programmers to talk to common
input and output hardware, or I/O for short,
using standardized mechanisms.

Chinese: 
计算机的配置并不总是相同的
比如，计算机可能有相同的 CPU，但有不同的打印机
这对程序员来说很痛苦
他们不仅要担心怎么写程序
还要担心程序怎么和不同型号的打印机交互，
以及计算机上连着的其他设备，统称“外部设备”
与早期的外部设备交互是非常底层的
要求程序员了解每台设备的详细硬件细节
最重要的是，程序员很少能拿到所有设备来测试代码
所以他们一般通过阅读手册来写代码
然后祈祷能正常运行
现在是"即插即用"，以前是"祈祷能用"
这非常可怕
所以为了程序员写软件更容易
操作系统充当软件和硬件之间的媒介
更具体地说，操作系统提供 API 来抽象硬件
叫“设备驱动程序”
使得程序员可以用标准化机制  和输入输出硬件（I/O）交互
比如，程序员只需调用 print(highscore)

French: 
Mais à mesure que les ordinateurs devenaient plus répandus, leurs configurations n'étaient pas toujours identiques,
comme les ordinateurs peuvent avoir le même processeur, mais pas la même imprimante.
Ce fut une énorme douleur pour les programmeurs.
Non seulement ils ont dû s'inquiéter de l'écriture de leur programme, mais aussi de la façon de s'interfacer avec
chaque modèle d'imprimante, et tous les périphériques connectés à un ordinateur, ce qu'on appelle des périphériques.
L'interfaçage avec les premiers périphériques était de très bas niveau, ce qui obligeait les programmeurs à connaître l'intimité
détails matériels sur chaque périphérique.
En plus de cela, les programmeurs avaient rarement accès à tous les modèles d'un périphérique pour tester leur code.
Ainsi, ils ont dû écrire le code du mieux qu'ils le pouvaient, souvent juste en lisant des manuels, et espèrent qu'il
travaillé lorsqu'il est partagé.
Les choses n'étaient pas exactement plug-and-play à l'époque ... plus plug-and-pray.
C'était clairement terrible, donc pour faciliter la tâche aux programmeurs, les systèmes d'exploitation
en tant qu'intermédiaires entre les logiciels et les périphériques matériels.
Plus précisément, ils ont fourni une abstraction logicielle, via des API, appelés drivers de périphériques.
Ceux-ci permettent aux programmeurs de parler au matériel d'entrée et de sortie commun, ou E / S pour faire court,
en utilisant des mécanismes standardisés.

Korean: 
그러나 컴퓨터가 널리 보급되면서, 그들의
구성이 항상 동일하지는 않았습니다.
마치 컴퓨터들의 CPU는 같지만 
프린터와 같지 않은 것처럼요.
이는 프로그래머에게 커다란 고통이었습니다.
그들은 프로그램 작성에 대해 걱정할뿐만 아니라 
모든 모델의 프린터를 포함한
컴퓨터에 연결된 주변 장치들과의
접속하는 방법 또한 걱정했습니다.
초기 주변장치와의 접속은 낮은 수준이어서,
프로그래머는 각 장치에 대한 
하드웨어 세부 정보를 알아야 했습니다.
게다가 프로그래머가 주변 장치의 모든 모델에 접근하여 코드를 테스트하는 경우는 거의 없었습니다.
그래서 그들은 종종 설명서만 읽으면 되도록 최선을 다해 코드를 작성해야 했고 공유할 때 효과가 있길 바랐습니다.
그래서 그들은 종종 설명서만 읽으면 되도록 최선을 다해 코드를 작성해야 했고 공유할 때 효과가 있길 바랐습니다.
그 당시에는 정확히 플러그 앤 플레이가 아니 었습니다. 그것보단, 더 많이 꽂고 기도했습니다.(농담)
이는 분명히 끔찍한 일이었으므로
프로그래머들이 쉽게 사용하도록
운영 체제는 소프트웨어 프로그램과 하드웨어 주변 장치의 중개자로서의 단계를 밟았습니다.
보다 구체적으로, 그들은 장치 구동기라고 불리는 API를 통해 소프트웨어 추상화를 제공했습니다.
이를 통해 프로그래머는 표준화된 메커니즘을 사용하여
입출력 하드웨어 또는 줄여서 I/O와 대화할 수 있습니다.
이를 통해 프로그래머는 표준화된 메커니즘을 사용하여
입출력 하드웨어 또는 줄여서 I/O와 대화할 수 있습니다.

Chinese: 
而把结果输到纸上的具体细节，由操作系统来处理
到 1950 年代的尾声，电脑已经非常快了
处理器经常闲着，等待慢的机械设备（如打印机和读卡器）
程序在I/O上阻塞着
而昂贵的处理器则在度假
就是放松啥也不做
50年代后期，英国曼彻斯特大学
开始研发世界上第一台超级计算机，Atlas
他们知道机器会超级快
所以需要一种方式来最大限度的利用它
他们的解决方案是一个叫 Atlas Supervisor 的程序，于1962年完成
这个操作系统不仅像早期的批处理系统那样  能自动加载程序
也可以在单个 CPU 上同时运行几个程序
它通过巧妙的调度来做到这一点
假设有一个游戏在 Atlas 上运行
然后我们调用一个函数“print(highscore)”
它会让 Atlas 打印一个名为“highscore”的变量的值
告诉朋友我们是冠军
print 函数调用需要一点时间，相当于数千个时钟周期

French: 
Par exemple, les programmeurs peuvent appeler une fonction comme "highscore d'impression", et l'OS
faites le gros travail pour l'obtenir sur papier.
À la fin des années 1950, les ordinateurs étaient devenus si rapides qu'ils attendaient souvent
choses mécaniques lentes, comme les imprimantes et les lecteurs de cartes perforées.
Alors que les programmes étaient bloqués sur les E / S, le processeur cher était juste chillin '... pas comme
un méchant ... tu sais, juste relaxant.
À la fin des années 50, l'Université de Manchester, au Royaume-Uni, a commencé à travailler sur un supercalculateur
appelé Atlas, l'un des premiers au monde.
Ils savaient que ça allait être rapide, donc ils avaient besoin d'un moyen d'utiliser au maximum
la machine chère.
Leur solution était un programme appelé le superviseur de l'Atlas, terminé en 1962.
Ce système d'exploitation non seulement chargé les programmes automatiquement, comme les systèmes de lots précédents,
mais pourrait également exécuter plusieurs en même temps sur son processeur unique.
Il l'a fait grâce à un emploi du temps intelligent.
Disons que nous avons un programme de jeu sur Atlas, et nous appelons la fonction "imprimer
highscore "qui indique à Atlas d'imprimer la valeur d'une variable nommée" highscore "
sur papier pour montrer à nos amis que nous sommes le champion ultime des tiddlywinks virtuels.
Cet appel de fonction va prendre un certain temps, l'équivalent de milliers de cycles d'horloge,

Korean: 
예를 들어 프로그래머는 "print highscore"와 같은 함수를 호출 할 수 있습니다.
그러면 OS는 그것을 종이 위에 올려 놓기 위해 
무거운 이송작업을 수행할 것입니다.
1950 년대 말, 컴퓨터는
너무 빨라져, 그들은 종종 유휴 상태였습니다.
프린터와 펀치 카드 리더기 같은 느린 기계들을 
기다리는 경우가 많았습니다.
프로그램이 I/O에서 차단되는 동안, 
값비싼 프로세서는 단지 쉬고 있었습니다.
악당이 아니라.. 알다시피 그냥 쉬고 있었죠.
50년대 후반 영국의 맨체스터 대학에서는 
아틀라스라는 슈퍼 컴퓨터로 작업을 시작했습니다.
세계 최초의 슈퍼 컴퓨터입니다.
그들은 그것이 빨리 사악해질 것이라는 것을 알았고, 그 비싼 기계를 최대한 활용할 수 있는 방법이 필요했습니다.
그들은 그것이 빨리 사악해질 것이라는 것을 알았고, 그 비싼 기계를 최대한 활용할 수 있는 방법이 필요했습니다.
그들의 해결책은 1962년에 끝난 Atlas Supervisor라고 
불리는 프로그램이었습니다.
이 운영 체제는 프로그램을 자동으로 로드했을 뿐 아니라 초기의 일괄 처리 시스템처럼
동시에 여러개의 프로그램을 단일 CPU에서 
실행할 수도 있습니다.
그것은 영리한 스케줄링을 통해 작업했습니다.
Atlas에서 게임을 실행한다고 가정 해 봅시다. Print(highscore)라는 함수를 호출하여
Atlas에게 highscore라는 변수를 
종이에 인쇄하도록 지시합니다.
친구들에게 우리가 가상 tiddlywinks(어린이용 표적게임)의 궁극적인 챔피언이 누구인지 볼 수 있도록 합시다.
그 함수 호출은 수천 클락 사이클에
해당하는 시간이 걸릴 것입니다.

English: 
For example, programmers could call a function
like “print highscore”, and the OS would
do the heavy lifting to get it onto paper.
By the end of the 1950s, computers had gotten
so fast, they were often idle waiting for
slow mechanical things, like printers and
punch card readers.
While programs were blocked on I/O, the expensive
processor was just chillin’... not like
a villain… you know, just relaxing.
In the late 50’s, the University of Manchester,
in the UK, started work on a supercomputer
called Atlas, one of the first in the world.
They knew it was going to be wicked fast,
so they needed a way to make maximal use of
the expensive machine.
Their solution was a program called the Atlas
Supervisor, finished in 1962.
This operating system not only loaded programs
automatically, like earlier batch systems,
but could also run several at the same time
on its single CPU.
It did this through clever scheduling.
Let’s say we have a game program running
on Atlas, and we call the function “print
highscore” which instructs Atlas to print
the value of a variable named “highscore”
onto paper to show our friends that we’re
the ultimate champion of virtual tiddlywinks.
That function call is going to take a while,
the equivalent of thousands of clock cycles,

French: 
parce que les imprimantes mécaniques sont lentes par rapport aux processeurs électroniques.
Ainsi, au lieu d'attendre la fin des E / S, Atlas met plutôt notre programme en veille, puis
sélectionne et exécute un autre programme en attente et prêt à fonctionner.
Finalement, l'imprimante rapportera à Atlas qu'elle a fini d'imprimer la valeur
de "highscore".
Atlas marque ensuite notre programme comme prêt à partir, et à un moment donné, il sera programmé pour
réexécutez sur la CPU et continuez sur la ligne de code suivante en suivant la commande print
De cette façon, Atlas pourrait avoir un programme exécutant des calculs sur le CPU, tandis qu'un autre
était l'impression de données, et encore une autre lecture des données à partir d'une bande de perforation.
Les ingénieurs d'Atlas ont doublé cette idée et ont équipé leur ordinateur de 4 papiers.
lecteurs de bande, 4 poinçons de bande de papier et jusqu'à 8 lecteurs de bande magnétique.
Cela a permis à de nombreux programmes d'être en cours en même temps, partageant le temps sur un seul processeur.
Cette capacité, activée par le système d'exploitation, est appelée multitâche.
Cependant, il y a un gros problème à avoir de nombreux programmes fonctionnant simultanément sur un seul ordinateur.
Chacun aura besoin de mémoire, et nous ne pouvons pas perdre les données de ce programme quand
nous passons à un autre programme.
La solution consiste à allouer à chaque programme son propre bloc de mémoire.

English: 
because mechanical printers are slow in comparison
to electronic CPUs.
So instead of waiting for the I/O to finish,
Atlas instead puts our program to sleep, then
selects and runs another program that’s
waiting and ready to run.
Eventually, the printer will report back to
Atlas that it finished printing the value
of “highscore”.
Atlas then marks our program as ready to go,
and at some point, it will be scheduled to
run again on the CPU, and continue onto the
next line of code following the print statement.
In this way, Atlas could have one program
running calculations on the CPU, while another
was printing out data, and yet another reading
in data from a punch tape.
Atlas’ engineers doubled down on this idea,
and outfitted their computer with 4 paper
tape readers, 4 paper tape punches, and up
to 8 magnetic tape drives.
This allowed many programs to be in progress
all at once, sharing time on a single CPU.
This ability, enabled by the Operating System,
is called multitasking.
There’s one big catch to having many programs running simultaneously on a single computer, though.
Each one is going to need some memory, and
we can’t lose that program’s data when
we switch to another program.
The solution is to allocate each program its
own block of memory.

Chinese: 
因为机械打印机 比电子 CPU 慢
所以与其等待 输入/输出设备 完成操作
Atlas 会把程序休眠
然后运行另一个等待运行的程序
最终，打印机会告诉 Atlas 打印已完成
Atlas 会标记程序可以继续运行
在某个时刻，会被安排给 CPU 继续运行
并继续 print 语句之后的下一行代码
这样 Atlas 可以在 CPU 上运行一个程序
同时另一个程序在打印数据
同时另一个程序在读数据
Atlas 的工程师加强了这个做法
配了4台纸带读取器，4台纸带打孔机
以及多达8个磁带驱动器
使得多个程序可以同时运行
在单个 CPU 上共享时间
操作系统的这种能力叫“多任务处理”
同时运行多个程序有一个问题
每个程序都要占用一些内存
当切换到另一个程序时，我们不能丢失数据
解决的办法是 为每个程序分配专属的内存块

Korean: 
왜냐하면 기계식 프린터가
전자 CPU에 비해 느리기 때문입니다.
따라서 I/O 가 끝날 때까지 기다리는 대신,
Atlas는 프로그램을 절전 모드로 전환하고
다음 대기중인 실행 할 준비된 다른 프로그램을 
선택하여 실행합니다.
결국 프린터는 Atlas에 "highscore"값의 
인쇄를 마쳤다고 보고합니다.
결국 프린터는 Atlas에 "highscore"값의 
인쇄를 마쳤다고 보고합니다.
Atlas는  프로그램을 실행 준비가 된 것으로 표시하고, 
어느 시점에서 CPU에 다시 실행되도록 예약하고
print 문 다음의 다음 코드 행으로 계속 진행합니다.
이 방법으로 Atlas는 CPU에서 계산을 실행하는 하나의 
프로그램을 가질 수 있습니다.
다른 프로그램이 데이터를 인쇄하고 있었고 또 다른프로그램이 펀치 테이프의 데이터를 판독하고 있는 동안에요.
Atlas의 기술자들은 이 아이디어를 두 배로 늘렸습니다.
4대의 테이프 판독기, 4개의 종이테이프 펀치, 및 
8개의 자기 테이프 드라이브로 컴퓨터를 완성했습니다.
이로 인해 많은 프로그램이 하나의 CPU에서
한꺼번에 진행되어 시간을 공유할 수 있었습니다.
이 기능은 운영 체제에서 가능하며,
멀티 태스킹이라고 부릅니다.
그럼에도 하나의 컴퓨터에서 여러 프로그램을 동시에 실행하는 데에는 큰 걸림돌이 있습니다.
각각 하나는 메모리가 필요할 것이고, 다른 프로그램으로 전환할 때 그 프로그램의 데이터를 잃을 순 없습니다.
각각 하나는 메모리가 필요할 것이고, 다른 프로그램으로 전환할 때 그 프로그램의 데이터를 잃을 순 없습니다.
해결책은 각 프로그램에 자체 메모리 블록을 
할당하는 것입니다.

Chinese: 
举个例子，一台电脑总共有 10000 个内存位置
程序 A 分配到内存地址 0 到 999
而程序 B 分配到内存地址 1000 到 1999，以此类推
如果一个程序请求占用更多内存
那么操作系统会决定是否同意该请求
如果同意，系统会决定分配什么内存块
这种灵活性很好，但会带来一个奇怪的后果
程序 A 可能会分配到非连续的内存块
比如内存地址 0 到 999，以及 2000 到 2999
这只是个简单例子
真正的程序可能会分配到内存中数十个地方
正如你想象的
这对程序员来说非常难处理
也许内存中有一长串销售数据
每天下班时要计算销售总额
但这个列表 存在一堆不连续的内存块里
为了隐藏这种复杂性，操作系统会"虚拟化"内存位置
用虚拟内存，程序可以假定内存总是从地址0开始

English: 
So, for example, let’s say a computer has
10,000 memory locations in total.
Program A might get allocated memory addresses
0 through 999, and Program B might get 1000
through 1999, and so on.
If a program asks for more memory, the operating
system decides if it can grant that request,
and if so, what memory block to allocate next.
This flexibility is great, but introduces
a quirk.
It means that Program A could end up being
allocated non-sequential blocks of memory,
in say addresses 0 through 999, and 2000 through 2999.
And this is just a simple example - a real
program might be allocated dozens of blocks
scattered all over memory.
As you might imagine, this would get really
confusing for programmers to keep track of.
Maybe there’s a long list of sales data
in memory that a program has to total up at
the end of the day, but this list is stored
across a bunch of different blocks of memory.
To hide this complexity, Operating Systems
virtualize memory locations.
With Virtual Memory, programs can assume their
memory always starts at address 0, keeping

French: 
Ainsi, par exemple, disons qu'un ordinateur a 10 000 emplacements de mémoire au total.
Le programme A peut recevoir des adresses de mémoire allouées de 0 à 999, et le programme B peut recevoir 1000
jusqu'en 1999, et ainsi de suite.
Si un programme demande plus de mémoire, le système d'exploitation décide s'il peut accorder cette requête,
et si oui, quel bloc de mémoire allouer ensuite.
Cette flexibilité est grande, mais introduit une bizarrerie.
Cela signifie que le programme A pourrait se voir allouer des blocs de mémoire non séquentiels,
dans les adresses dites 0 à 999 et 2000 à 2999.
Et ce n'est qu'un exemple simple - un vrai programme pourrait être alloué des dizaines de blocs
éparpillé partout dans la mémoire.
Comme vous pouvez l'imaginer, cela deviendrait vraiment déroutant pour les programmeurs.
Peut-être qu'il y a une longue liste de données de ventes en mémoire qu'un programme doit totaliser à
a fin de la journée, mais cette liste est stockée à travers un tas de blocs de mémoire différents.
Pour masquer cette complexité, les systèmes d'exploitation virtualisent les emplacements de mémoire.
Avec la mémoire virtuelle, les programmes peuvent supposer que leur mémoire commence toujours à l'adresse 0, en gardant

Korean: 
예를 들어, 컴퓨터가 만 개의 메모리 위치를 가지고 
있다고 가정해 봅시다.
프로그램 A가 0에서 999까지, 프로그램 B가 1000에서 1999까지 할당된 메모리 주소를 얻을 수 있습니다.
이런식이죠.
프로그램이 더 많은 메모리를 요구하면,
운영체제는 요청을 승인 할 수 있는지 여부를 결정하고,
승인한다면, 다음에 할당할 메모리 블록을 결정합니다.
이러한 유연성은 뛰어나지만 단점을 야기합니다.
프로그램 A가 할당된 비 순차 메모리 블록으로 
끝날 수 있음을 의미합니다.
그말은 프로그램A가 0에서 999까지,
그리고 2000에서 2999까지 라는 것입니다.
이것은 단순한 예제일 뿐이고
실제 프로그램에 수십 개의 블록이 할당 될 수 있습니다.
메모리 전체에 흩어져 있는 것이죠.
여러분이 상상하듯이, 이것은 프로그래머가 
계속 추적하기에 매우 혼란스러울 것입니다.
어쩌면 하루의 끝에서 합쳐져야 할 
판매 데이터의 긴 목록이 있을 수 있지만
이 목록은 다양한 메모리 블록에 걸쳐 저장됩니다.
이 복잡성을 숨기기 위해 운영 체제는
메모리 위치를 가상화합니다.
가상 메모리를 사용하면 프로그램은 메모리가 항상 
주소 0에서 시작되어 단순하고 일관되게 유지한다고

Korean: 
가정할 수 있습니다.
그러나 실제 컴퓨터 메모리의 물리적 위치는 
운영체제에 의해 추상화되고 숨겨져 있습니다.
그러나 실제 컴퓨터 메모리의 물리적 위치는 
운영체제에 의해 추상화되고 숨겨져 있습니다.
새로운 수준의 추상화.
프로그램 B를 예로 들어 보겠습니다. 주소
1000에서 1999의 메모리 블록이 할당되어 있습니다.
프로그램 B를 예로 들어 보겠습니다. 주소
1000에서 1999의 메모리 블록이 할당되어 있습니다.
B가 말할 수 있는 한, 프로그램 B는
0에서 999 사이의 주소를 가진 것으로 나타납니다.
OS와 CPU는 가상-실제 메모리를 다시 자동으로 
매핑하여 처리합니다.
따라서, 프로그램 B가 메모리 위치 42를 요청하면
실제 주소 1042를 읽습니다.
이 메모리 주소의 가상화는 예시의 프로그램 A에서
더욱 유용합니다.
예시에서 프로그램 A는 서로 분리 된 두 개의 
메모리 블록이 할당되어 있습니다.
이것 역시 프로그램 A에게는 보이지 않습니다.
A가 말할 수있는 한, 그것은 2000개의 
연속적인 블록의 주소가 할당되어 있습니다.
프로그램 A가 메모리 주소 999를 읽으면
동시에 물리적 메모리 주소 999로 매핑됩니다.
프로그램 A가 메모리 주소 999를 읽으면
동시에 물리적 메모리 주소 999로 매핑됩니다.

English: 
things simple and consistent.
However, the actual, physical location in
computer memory is hidden and abstracted by
the operating system.
Just a new level of abstraction.
Let’s take our example Program B, which
has been allocated a block of memory from
address 1000 to 1999.
As far as Program B can tell, this appears
to be a block from 0 to 999.
The OS and CPU handle the virtual-to-physical
memory remapping automatically.
So, if Program B requests memory location
42, it really ends up reading address 1042.
This virtualization of memory addresses is
even more useful for Program A, which in our
example, has been allocated two blocks of
memory that are separated from one another.
This too is invisible to Program A.
As far as it can tell, it’s been allocated
a continuous block of 2000 addresses.
When Program A reads memory address 999, that
does coincidentally map to physical memory
address 999.

French: 
les choses simples et cohérentes.
Cependant, l'emplacement physique réel dans la mémoire de l'ordinateur est caché et résumé par
le système d'exploitation.
Juste un nouveau niveau d'abstraction.
Prenons notre exemple Programme B, à qui a été attribué un bloc de mémoire de
adresse 1000 à 1999.
Pour autant que le programme B puisse le dire, cela semble être un bloc de 0 à 999.
Le système d'exploitation et le processeur gèrent automatiquement le remappage de la mémoire virtuelle vers la mémoire physique.
Ainsi, si le programme B demande l'emplacement de mémoire 42, il finit réellement par lire l'adresse 1042.
Cette virtualisation des adresses mémoire est encore plus utile pour le programme A, qui dans notre
Par exemple, deux blocs de mémoire séparés les uns des autres ont été attribués.
Ceci est également invisible pour le programme A.
Pour autant qu'il peut dire, il a été attribué un bloc continu de 2000 adresses.
Lorsque le programme A lit l'adresse mémoire 999, cela correspond par coïncidence à la mémoire physique
adresse 999.

Chinese: 
简单又一致
而内存的实际物理位置  被操作系统隐藏和抽象
这又是一层新抽象
让我们用程序 B 来举个例子
它被分配了内存地址 1000 到 1999
对程序B而言，它的内存地址是 0 到 999
操作系统和 CPU 会自动处理虚拟内存和物理内存之间的映射
如果程序 B 请求位置 42
实际上是读取地址 1042
内存地址的虚拟化  对程序 A 更加有用
在我们的例子中，A 已经分配了两块隔开的内存
这两块地址，对程序 A 是不可见的
以 A 的视角，是一块有 2000 个位置的连续地址
当程序 A 读取内存地址 999 时
会刚好映射到物理内存地址 999

Chinese: 
但如果程序 A 读下一个值（地址 1000）
会映射到物理内存地址 2000
这种机制允许程序拥有灵活的内存大小
叫“动态内存分配”
这使内存对程序来说是连续的
它简化了一切，为操作系统同时运行多个程序
提供了极大的灵活性
另一个给每个程序分配单独内存的好处
是可以更好地隔离它们
如果一个程序出错，开始写入错误的数据
它只能破坏自己的内存，不会影响到其它的
这个功能叫“内存保护”
这在防止恶意软件（如病毒）也非常有用
例如，我们不希望其他程序有能力
阅读或修改电子邮件那部分内存
利用那种权限
恶意软件可能以你的名义发邮件，甚至窃取个人信息
一点都不好！
Atlas 的内存既"虚拟化"也"受保护"
这是第一台支持这些功能的计算机和操作系统！
到 1970 年代，计算机足够快且便宜

Korean: 
그러나 프로그램 A가 바로 다음 값인 주소1000을 읽으면,
이는 장면 뒤에서
실제 메모리 주소 2000으로 매핑됩니다.
이 메커니즘을 통해 프로그램은 메모리 크기를 
유연하게 할 수 있습니다.
이를 동적 메모리 할당이라고 합니다.
그들에게 연속적인 것처럼 나타납니다.
모든 것을 단순화하고 동시에 여러 프로그램을 실행하는 운영 체제에 엄청난 유연성을 제공합니다.
모든 것을 단순화하고 동시에 여러 프로그램을 실행하는 운영 체제에 엄청난 유연성을 제공합니다.
각 프로그램에 자체 메모리를 할당하는 또 다른 장점은 
서로로부터 더 잘 격리된다는 점입니다.
각 프로그램에 자체 메모리를 할당하는 또 다른 장점은 
서로로부터 더 잘 격리된다는 점입니다.
버그가 있는 프로그램이 잘못되어 
까다로운 표현을 쓰게 되면
다른 프로그램의 메모리가 아닌 
자신의 메모리를 버리는 데에서 그칩니다.
이 기능을 메모리 보호라고합니다.
이는 또한 바이러스와 같은 악의적인 소프트웨어로부터 보호하는 데에 정말 유용합니다.
예를 들어, 우리는 일반적으로 다른 프로그램이 읽거나 수정할 수 있는 기능을 원하지 않습니다.
그러니까, 이메일에 그러한 종류의 엑세스 권한이 있으면 악성소프트웨어가 사용자를 대신하여
전자 메일을 보내고 개인 정보를 도용할 수 있습니다.
좋지 않습니다!
Atlas는 가상 메모리와 보호 메모리를 모두 가졌습니다.
그리고 이러한 기능을 지원하는 
최초의 컴퓨터 및 OS였습니다!
1970년대까지, 컴퓨터는 충분히 빠르고 저렴했습니다.

French: 
Mais si le programme A lit la valeur suivante dans la mémoire, à l'adresse 1000, qui est mappée
dans les coulisses à l'adresse mémoire physique 2000.
Ce mécanisme permet aux programmes d'avoir des tailles de mémoire flexibles, appelées allocation de mémoire dynamique,
qui semblent être continues pour eux.
Il simplifie tout et offre une grande flexibilité au système d'exploitation en cours d'exécution
plusieurs programmes simultanément.
Un autre avantage d'attribuer à chaque programme sa propre mémoire, c'est qu'ils sont mieux isolés
l'un de l'autre.
Donc, si un programme bogué tourne mal, et commence à écrire gobbledygook, il ne peut que jeter ses
propre mémoire, pas celle d'autres programmes
Cette fonctionnalité est appelée Protection de la mémoire.
Ceci est également très utile pour se protéger contre les logiciels malveillants, comme les virus.
Par exemple, nous ne voulons généralement pas que d'autres programmes aient la capacité de lire ou de modifier
La mémoire de, disons, notre e-mail, avec ce genre d'accès, les logiciels malveillants pourraient envoyer des e-mails
en votre nom et peut-être voler des informations personnelles.
Pas bon!
Atlas avait à la fois une mémoire virtuelle et protégée.
C'était le premier ordinateur et système d'exploitation à supporter ces fonctionnalités!
Dans les années 1970, les ordinateurs étaient suffisamment rapides et bon marché.

English: 
But if Program A reads the very next value
in memory, at address 1000, that gets mapped
behind the scenes to physical memory address
2000.
This mechanism allows programs to have flexible
memory sizes, called dynamic memory allocation,
that appear to be continuous to them.
It simplifies everything and offers tremendous
flexibility to the Operating System in running
multiple programs simultaneously.
Another upside of allocating each program
its own memory, is that they’re better isolated
from one another.
So, if a buggy program goes awry, and starts
writing gobbledygook, it can only trash its
own memory, not that of other programs.
This feature is called Memory Protection.
This is also really useful in protecting against
malicious software, like viruses.
For example, we generally don’t want other
programs to have the ability to read or modify
the memory of, let say, our email, with that
kind of access, malware could send emails
on your behalf and maybe steal personal information.
Not good!
Atlas had both virtual and protected memory.
It was the first computer and OS to support
these features!
By the 1970s, computers were sufficiently
fast and cheap.

English: 
Institutions like a university could buy a
computer and let students use it.
It was not only fast enough to run several
programs at once, but also give several users
simultaneous, interactive access.
This was done through a terminal, which is
a keyboard and screen that connects to a big
computer, but doesn’t contain any processing
power itself.
A refrigerator-sized computer might have 50
terminals connected to it, allowing up to
50 users.
Now operating systems had to handle not just
multiple programs, but also multiple users.
So that no one person could gobble up all
of a computer's resources, operating systems
were developed that offered time-sharing.
With time-sharing each individual user was
only allowed to utilize a small fraction of
the computer’s processor, memory, and so
on.
Because computers are so fast, even getting
just 1/50th of its resources was enough for
individuals to complete many tasks.
The most influential of early time-sharing
Operating Systems was Multics, or Multiplexed
Information and Computing Service, released
in 1969.
Multics was the first major operating
system designed to be secure from the outset.

French: 
Des institutions comme une université pourraient acheter un ordinateur et laisser les étudiants l'utiliser.
Ce n'était pas seulement assez rapide pour exécuter plusieurs programmes à la fois, mais aussi donner plusieurs utilisateurs
accès simultané et interactif.
Cela a été fait à travers un terminal, qui est un clavier et un écran qui se connecte à un grand
ordinateur, mais ne contient aucune puissance de traitement elle-même.
Un ordinateur de la taille d'un réfrigérateur peut avoir 50 terminaux connectés, ce qui permet de
50 utilisateurs.
Maintenant, les systèmes d'exploitation devaient gérer non seulement plusieurs programmes, mais aussi plusieurs utilisateurs.
Pour que personne ne puisse engloutir toutes les ressources d'un ordinateur, les systèmes d'exploitation
ont été développés qui ont offert un partage de temps.
Avec le partage de temps, chaque utilisateur individuel n'était autorisé à utiliser qu'une petite fraction de
le processeur de l'ordinateur, la mémoire, etc.
Parce que les ordinateurs sont si rapides, même obtenir seulement 1/50 de ses ressources était suffisant pour
les individus à accomplir de nombreuses tâches.
Le plus influent des systèmes d'exploitation de partage de temps précoce était Multics, ou multiplexe
Information and Computing Service, publié en 1969.
Multics a été le premier système d'exploitation majeur conçu pour être sécurisé dès le départ.

Korean: 
대학교와 같은 기관은 컴퓨터를 구입하여 
학생들이 사용할 수 있게 했습니다.
그것은 여러 프로그램을 한번에 돌리기에
충분히 빠르지도 않았고 ,
동시에 여러 사용자가 
상호작용적 접근을 할 수 없었습니다.
이것은 대형 컴퓨터에 연결되는 키보드 및 화면이지만
그 자체에 처리능력은 포함되지 않아,
터미널을 통해 수행되었습니다.
냉장고 크기의 컴퓨터는 50개의 터미널이 연결되어
50 명의 사용자가 사용가능했습니다.
이제 운영 체제는 여러 프로그램 뿐만 아니라 
여러 사용자를 다룰 수 있게 되었습니다.
아무도 컴퓨터 자원을 먹어치울 수 없도록, 운영 체제는 시간 공유 기능을 제공하도록 개발되었습니다.
아무도 컴퓨터 자원을 먹어치울 수 없도록, 운영 체제는 시간 공유 기능을 제공하도록 개발되었습니다.
개별 사용자는 시간 공유를 통해 컴퓨터 프로세서, 
메모리 등의 일부분만 활용할 수 있었습니다.
개별 사용자는 시간 공유를 통해 컴퓨터 프로세서, 
메모리 등의 일부분만 활용할 수 있었습니다.
컴퓨터가 너무 빠르기 때문에 단지 리소스의 1/50만 차지해도 개인이 많은 작업을 완료하기엔 충분했습니다.
컴퓨터가 너무 빠르기 때문에 단지 리소스의 50/1만 차지해도 개인이 많은 작업을 완료하기엔 충분했습니다.
초기의 가장 영향력 있는 시간 공유 운영 체제는 
1969년에 나온 Multics, 또는
or Multiplexed Information and Computing Service 
입니다.
Multics는 처음부터 안전하도록 설계된 
최초의 운영체제 였습니다.

Chinese: 
大学可以买电脑 让学生用
计算机不仅能同时快速运行多个程序
也能让多个用户同时访问
用户访问计算机是通过“终端”来做的。
"终端"只是一个键盘+屏幕，连接到主计算机
终端本身没有任何处理能力
冰箱大小的电脑可能有50个终端，允许50个用户使用
这时操作系统不但要处理多个程序
还要处理多个用户
所以为了确保不让其中一个人  用光电脑的资源
人们开发了 分时操作系统
每个用户只能使用电脑的一小部分处理器，内存等等
由于电脑如此之快
即使拿到 1/50 的资源也足以完成许多任务
早期分时操作系统最有影响力的是
Multics （即多任务信息与计算系统）
于 1969 年发布
Multics 是第一个从设计时就考虑到安全的操作系统

Korean: 
개발자는 장난스러운 사용자가 그들이 해선 안되는 
데이터에 접근하는 것을 원치 않았습니다.
마치 학생이 자신의 교수 계정에서 기말 시험에 
접근하려고 하는 것과 같이 말이죠.
이와 같은 기능은 Multics가 그당시 많은 양인 1메가바이트 메모리르 사용했고, 실제로 복잡했음을 의미합니다.
이와 같은 기능은 Multics가 그당시 많은 양인 1메가바이트 메모리르 사용했고, 실제로 복잡했음을 의미합니다.
그것은 컴퓨터의 기억의 절반 일 수도 있어요,
 OS를 실행하기 위한것 만으로요!
Multics의 연구원 중 한 명인 Dennis Ritchie
는 이렇게 말했습니다.
"상업적 성공을 거둔 Multics가 
명백히 잘못한 것들 중 하나는,
그것은 어떤 면에서 지나치게 내구성이 강한 것 입니다.
그 안에 너무 많은 것이 있었습니다. "
Dennis와 다른 Multics 연구원인 Ken Thomson은
스스로 파업을 하고 
유닉스라는 새로운 운영 체제를 구축했습니다.
그들은 OS를 두 부분으로 분리하고자 했습니다.
첫 번째는 커널이라고 부르는 I/O를 다루는 기능인 메모리 관리, 멀티 태스킹과 같은 OS의 핵심 기능이었습니다.
첫 번째는 커널이라고 부르는 I/O를 다루는 기능인 메모리 관리, 멀티 태스킹과 같은 OS의 핵심 기능이었습니다.
두 번째 부분은 추가적으로 제공되지만 커널이 아닌 프로그램과 라이브러리같은 유용한 도구들이었습니다.
두 번째 부분은 추가적으로 제공되지만 커널이 아닌 프로그램과 라이브러리같은 유용한 도구들이었습니다.
작고 군살없는 커널을 만드는것은 의도적으로 
일부 기능만 남겨두는 작업이었습니다.
다른 Multics 개발자인 Tom Van Vleck는

Chinese: 
开发人员不希望恶意用户 访问不该访问的数据
比如学生假装成教授，访问期末考试相关文件
导致 Multics 的复杂度超过当时的平均水准
操作系统会占用大约 1 Mb 内存，这在当时来讲很多！
可能是内存的一半，只拿来运行操作系统！
Multics 的研究人员之一 Dennis Ritchie 曾说过
“Multics 获得商业成功的一个明显的问题是
从某种意义上来说，它被过度设计了
里面的功能太多了”
这使得 Dennis 和另一个 Multics 研究员
Ken Thompson 联手打造新的操作系统
叫 Unix
他们想把操作系统分成两部分：
首先是操作系统的核心功能
如内存管理，多任务和输入/输出处理
也就是所谓的“内核”
第二部分是一堆有用的工具
但它们不是内核的一部分（比如程序和运行库）
为了构建紧凑的内核，意味着功能没有那么全面
Multics 的另一个开发者 Tom Van Vleck 回忆说：

English: 
Developers didn’t want mischievous users
accessing data they shouldn't, like students
attempting to access the final exam on their
professor’s account.
Features like this meant Multics was really
complicated for its time, using around 1 Megabit
of memory, which was a lot back then!
That might be half of a computer's memory,
just to run the OS!
Dennis Ritchie, one of the researchers working
on Multics, once said:
“One of the obvious things that went wrong
with Multics as a commercial success was just
that it was sort of over-engineered in a sense.
There was just too much in it.”
T
his lead Dennis, and another Multics researcher,
Ken Thompson, to strike out on their own and build a new, lean operating system… called Unix.
They wanted to separate the OS into two parts:
First was the core functionality of the OS,
things like memory management, multitasking,
and dealing with I/O, which is called the
kernel.
The second part was a wide array of useful
tools that came bundled with, but not part
of the kernel, things like programs and libraries.
Building a compact, lean kernel meant intentionally
leaving some functionality out.
Tom Van Vleck, another Multics developer,
recalled:

French: 
Les développeurs ne voulaient pas que les utilisateurs malveillants accèdent à des données qu'ils ne devraient pas, comme les étudiants
tenter d'accéder à l'examen final sur le compte de leur professeur.
Des fonctionnalités comme celle-ci signifiaient que Multics était vraiment compliqué pour l'époque, utilisant environ 1 Megabit
de la mémoire, qui était beaucoup à l'époque!
Cela pourrait être la moitié de la mémoire d'un ordinateur, juste pour exécuter le système d'exploitation!
Dennis Ritchie, l'un des chercheurs travaillant sur Multics, a déclaré:
"L'une des choses évidentes qui ont mal tourné avec Multics en tant que succès commercial était juste
que c'était en quelque sorte sur-machiné.
Il y en avait juste trop. "
Le chef Dennis et un autre chercheur de Multics,
Ken Thompson, pour se lancer et construire un nouveau système d'exploitation allégé ... appelé Unix.
Ils voulaient séparer le système d'exploitation en deux partie
La première était la fonctionnalité de base de l'OS, des choses comme la gestion de la mémoire, multitâche,
et traitant des E / S, qui s'appelle le noyau.
La deuxième partie était un large éventail d'outils utiles qui sont venus avec, mais pas partie
du noyau, des choses comme les programmes et les bibliothèques.
Construire un noyau compact et léger signifiait intentionnellement laisser certaines fonctionnalités à l'extérieur.
Tom Van Vleck, un autre développeur de Multics, a rappelé:

French: 
"J'ai remarqué à Dennis que facilement la moitié du code que j'écrivais dans Multics était une erreur de récupération
code."
Il a dit: "Nous avons laissé tout cela hors d'Unix.
S'il y a une erreur, nous avons cette routine appelée panique, et quand elle est appelée, la machine
s'écrase, et vous hurlez dans le couloir, 'Hey, redémarrez-le.' ""
Vous avez peut-être entendu parler des paniques du noyau. C'est de là que vient le terme.
C'est littéralement quand le noyau se bloque, n'a aucun recours pour récupérer, et appelle ainsi un
fonction appelée "panique".
A l'origine, tout ce qu'il a fait était d'imprimer le mot "panique", puis entrez
une boucle infinie.
Cette simplicité signifiait qu'Unix pouvait fonctionner sur du matériel moins cher et plus diversifié,
c'est populaire à l'intérieur des Bell Labs, où Dennis et Ken travaillaient.
Comme de plus en plus de développeurs ont commencé à utiliser Unix pour créer et exécuter leurs propres programmes, le nombre de
outils fournis ont augmenté.
Peu de temps après sa sortie en 1971, il a gagné des compilateurs pour différents langages de programmation
et même un traitement de texte, en faisant rapidement l'un des systèmes d'exploitation les plus populaires des années 1970
et 80s.
Au même moment, au début des années 1980, le coût d'un ordinateur de base
point où les individus pourraient se permettre un, appelé un ordinateur personnel ou à la maison.
Ceux-ci étaient beaucoup plus simples que les grands ordinateurs centraux trouvés dans les universités, les entreprises et les gouvernements.

Korean: 
"Dennis에게 Multics에서 작성한 코드의 절반이 오류 복구 코드라는 것을 언급했습니다"라고 회상했습니다.
"Dennis에게 Multics에서 작성한 코드의 절반이 오류 복구 코드라는 것을 언급했습니다"라고 회상했습니다.
그는 "우리는 유닉스에서 모든 것들을 빼버렸습니다."
오류가 발생하면 패닉이라고 하는 루틴을 갖게 됩니다.
이것이 호출 될 때 기계가 충돌하고,
"재부팅하십시오"라고 홀을 질주합니다.
커널 패닉 이라는 말을 들어본 적이 있을 텐데요, 이 단어는 여기에서 비롯되었습니다.
말 그대로 커널이 충돌할 때, 복구할 수단이 없기 때문에 
"패닉"이라는 기능을 호출합니다.
말 그대로 커널이 충돌할 때, 복구할 수단이 없기 때문에 
"패닉"이라는 기능을 호출합니다.
원래는 "panic"이라는 단어를 인쇄하고
무한 루프로 들어가는 작업을 했습니다.
원래는 "panic"이라는 단어를 인쇄하고
무한 루프로 들어가는 작업을 했습니다.
이 단순함은 저렴하고 다양한 하드웨어에서 유닉스가
 돌아갈 수 있다는 것을 의미했고,
Dennis와 Ken이 일하는 
벨 연구소에서 널리 사용되었습니다.
유닉스를 사용하여 자신의 프로그램을 만들고 실행하는 개발자가 많아지면서, 기여되는 도구 수도 증가했습니다.
유닉스를 사용하여 자신의 프로그램을 만들고 실행하는 개발자가 많아지면서, 기여되는 도구 수도 증가했습니다.
1971년에 출시된 직후, 다른 프로그래밍 언어용과 워드프로세서용 컴파일러를 만들었고,
1970년대와 80년대의 가장 인기있는
OS 중 하나가 되었습니다.
1970년대와 80년대의 가장 인기있는
OS 중 하나가 되었습니다.
동시에 1980년대 초반까지, 기본 컴퓨터의 비용은
개인이 구입할 수 있을 정도로 하락했고,
개인 또는 가정용 컴퓨터라고 불렸습니다.
이것들은 대학, 기업 및 정부에서 볼 수 있는 중앙컴퓨터보다 훨씬 더 간단했습니다.

Chinese: 
“我对 Dennis 说，我在 Multics 写的一半代码都是错误恢复代码”
他说:“Unix 不会有这些东西
如果有错误发生，我们就让内核“恐慌”（panic）
当调用它时，机器会崩溃
你得在走廊里大喊，“嘿，重启电脑”
你可能听过 "内核恐慌"（kernel panic）
这就是这个词的来源
内核如果崩溃，没有办法恢复
所以调用一个叫“恐慌”（panic）的函数
起初它所做的只是打印“恐慌”一词，然后进入无限循环
这种简单性意味着 Unix 可以在更便宜和更多样化的硬件上运行
使 Unix 在 Dennis 和 Ken 工作的贝尔实验室大受欢迎
随着越来越多开发人员用 Unix 编写并运行程序
工具的数量日益增长
1971 年发布后不久
它获得了不同编程语言的编译器甚至是文字处理器的支持
迅速成为 1970~80年代最流行的操作系统之一
到了1980年代早期
一台电脑的成本已经降到了个人可以负担的地步
叫“个人或家庭电脑” （PC）
这些电脑比大学，企业和政府内部的大型主机简单得多

English: 
“I remarked to Dennis that easily half the
code I was writing in Multics was error recovery
code."
He said, "We left all that stuff out of Unix.
If there's an error, we have this routine
called panic, and when it is called, the machine
crashes, and you holler down the hall, 'Hey,
reboot it.'"”
You might have heard of kernel panics, This
is where the term came from.
It’s literally when the kernel crashes,
has no recourse to recover, and so calls a
function called “panic”.
Originally, all it did was print the word
“panic” and then enter
an infinite loop.
This simplicity meant that Unix could be run
on cheaper and more diverse hardware, making
it popular inside Bell Labs, where Dennis
and Ken worked.
As more developers started using Unix to build
and run their own programs, the number of
contributed tools grew.
Soon after its release in 1971, it gained
compilers for different programming languages
and even a word processor, quickly making
it one of the most popular OSes of the 1970s
and 80s.
At the same time, by the early 1980s, the
cost of a basic computer had fallen to the
point where individual people could afford
one, called a personal or home computer.
These were much simpler than the big mainframes
found at universities, corporations, and governments.

English: 
So, their operating systems had to be equally
simple.
For example, Microsoft’s Disk Operating
System, or MS-DOS, was just 160 kilobytes,
allowing it to fit, as the name suggests,
onto a single disk.
First released in 1981, it became the most
popular OS for early home computers, even
though it lacked multitasking and protected
memory.
This meant that programs could, and would,
regularly crash the system.
While annoying, it was an acceptable tradeoff,
as users could just turn their own computers
off and on again!
Even early versions of Windows, first released
by Microsoft in 1985 and which dominated the
OS scene throughout the 1990s, lacked strong
memory protection.
When programs misbehaved, you could get the
blue screen of death, a sign that a program
had crashed so badly that it took down the
whole operating system.
Luckily, newer versions of Windows have better protections and usually don't crash that often.
Today, computers run modern operating systems,
like Mac OS X, Windows 10, Linux, iOS and
Android.
Even though the computers we own are most
often used by just a single person, you! their

Chinese: 
因此它们的操作系统必须同样简单
例如，微软的磁盘操作系统（MS-DOS）只有 160 kB
一张磁盘就可以容纳
它于1981年首次发布，成为早期家用电脑最受欢迎的操作系统
虽然它缺少"多任务"和"保护内存"这样功能
意味着程序经常使系统崩溃
虽然很讨厌 但还可以接受
因为用户可以重启电脑
哪怕是微软 1985 年发布的早期 Windows
虽然在90年代占据了主导地位
但却缺乏强大的"内存保护"
当程序行为不当时
就会“蓝屏”
代表程序崩溃的非常严重，把系统也带崩溃了
幸运的是，新版Windows有更好的保护，不会经常崩溃
如今的计算机，运行的是现代操作系统
如Mac OS X，Windows 10，Linux，iOS和Android
大部分都是个人使用
你！

Korean: 
그들의 운영 체제는 똑같이 단순하게 있어야 했습니다.
예를 들어, Microsoft의 디스크 운영 체제 또는 
MS-DOS는 160 킬로바이트에 불과했지만,
이름에서 알 수 있듯이, 
하나의 디스크에 맞출 수 있었습니다.
1981년에 처음 출시된 MS-DOS는 초기 가정용 컴퓨터로
가장 널리 사용되었습니다.
비록 멀티 태스킹과 보호된 메모리는 부족했지만요.
이것은 프로그램이, 시스템을 정기적으로 
충돌할 수 있고, 할 것임을 의미합니다.
짜증나는 동안, 사용자에게는 자신의 컴퓨터를 
다시 껐다 켤 수 있는 절충안이 있습니다.
짜증나는 동안, 사용자에게는 자신의 컴퓨터를 
다시 껐다 켤 수 있는 절충안이 있습니다.
마이크로소프트가 1985년에 처음 출시한 윈도우의 
초기 버전은 1990년대 전반에 걸쳐 OS를 지배했지만
이조차 강력한 메모리 보호기능이 없었습니다.
프로그램이 잘못 수행되면 죽음의 블루 스크린이 뜹니다.
전체 운영체제를 중단시킬 정도로 심각하게
다운되었다는 신호와 함께요.
다행히도 Windows의 최신버전은 더 나은 보호 기능을 
제공하며 대개의 경우 충돌을 일으키지 않습니다.
오늘날 컴퓨터는 Mac OS X, Windows 10, Linux, iOS 및 
안드로이드와 같은 최신 운영 체제를 실행합니다.
오늘날 컴퓨터는 Mac OS X, Windows 10, Linux, iOS 및 
안드로이드와 같은 최신 운영 제를 실행합니다.
비록 우리가 가지고 있는 컴퓨터가 
종종 한 사람만 사용하는 경우가 많더라도,

French: 
Ainsi, leurs systèmes d'exploitation devaient être également simples.
Par exemple, le système d'exploitation de disque de Microsoft, ou MS-DOS, était juste 160 kilo-octets,
en lui permettant de s'adapter, comme son nom l'indique, sur un seul disque.
D'abord publié en 1981, il est devenu le système d'exploitation le plus populaire pour les premiers ordinateurs à la maison, même
mais il manquait de multitâche et de mémoire protégée.
Cela signifiait que les programmes pouvaient et allaient régulièrement planter le système.
Bien qu'ennuyeux, c'était un compromis acceptable, car les utilisateurs pouvaient simplement tourner leurs propres ordinateurs
et encore!
Même les premières versions de Windows, d'abord publiées par Microsoft en 1985 et qui ont dominé le
Scène OS tout au long des années 1990, manquait de protection de la mémoire forte.
Lorsque les programmes se sont mal comportés, vous pourriez obtenir l'écran bleu de la mort, un signe qu'un programme
s'était écrasé si mal qu'il a détruit tout le système d'exploitation.
Heureusement, les nouvelles versions de Windows ont de meilleures protections et ne tombent généralement pas si souvent.
Aujourd'hui, les ordinateurs exécutent des systèmes d'exploitation modernes, tels que Mac OS X, Windows 10, Linux, iOS et
Android.
Même si les ordinateurs que nous possédons sont le plus souvent utilisés par une seule personne, vous! leur

English: 
OSes all have multitasking and virtual and
protected memory.
So, they can run many programs at once: you
can watch YouTube in your web browser, edit
a photo in Photoshop, play music in Spotify
and sync Dropbox all at the same time.
This wouldn’t be possible without those
decades of research and development on Operating
Systems, and of course the proper memory to
store those programs.
Which we’ll get to next week.
I’d like to thank Hover for sponsoring this
episode.
Hover is a service that helps you buy and
manage domain names.
Hover has over 400 domain extensions to end
your domain with - including .com and .net.
You can also get unique domains that are more
professional than a generic address.
Here at Crash Course, we'd get the domain
name “mongols.fans” but I think you know
that already.
Once you have your domain, you can set up
your custom email to forward to your existing
email address -- including Outlook or Gmail
or whatever you already use.
With Hover, you can get a custom domain and
email address for 10% off.
Go to Hover.com/crashcourse today to create
your custom domain and help support our show!

French: 
Les systèmes d'exploitation ont tous une mémoire multitâche et une mémoire virtuelle et protégée.
Ainsi, ils peuvent exécuter de nombreux programmes à la fois: vous pouvez regarder YouTube dans votre navigateur Web, modifier
une photo dans Photoshop, jouer de la musique dans Spotify et synchroniser Dropbox tous en même temps.
Cela ne serait pas possible sans ces décennies de recherche et développement sur
Systèmes, et bien sûr la mémoire appropriée pour stocker ces programmes.
Lequel nous aurons à la semaine prochaine.
Je tiens à remercier Hover pour avoir commandité cet épisode.
Hover est un service qui vous aide à acheter et gérer des noms de domaine.
Hover a plus de 400 extensions de domaine pour mettre fin à votre domaine avec .com et .net.
Vous pouvez également obtenir des domaines uniques plus professionnels qu'une adresse générique.
Ici, à Crash Course, nous aurions le nom de domaine "mongols.fans" mais je pense que vous savez
ça déjà.
Une fois que vous avez votre domaine, vous pouvez configurer votre adresse e-mail personnalisée pour la transmettre à votre compte existant
adresse e-mail - y compris Outlook ou Gmail ou tout ce que vous utilisez déjà.
Avec Hover, vous pouvez obtenir un domaine et une adresse e-mail personnalisés pour 10% de réduction.
Allez sur Hover.com/crashcourse aujourd'hui pour créer votre domaine personnalisé et aider à soutenir notre spectacle!

Chinese: 
操作系统也有"多任务"和"虚拟内存/保护内存"的功能
因此可以同时运行多个程序：
一边在浏览器里看 YouTube
一边在 Photoshop 里编辑照片
用 Spotify 放音乐，以及同步 Dropbox
如果没有这几十年操作系统的发展，都是不可能的
当然也要有合适的"存储器"来存放程序
下周会讨论这个

Korean: 
그들의 OS는 모두 멀티 태스킹 및 가상 및
보호 된 메모리룰 갖추고 있습니다.
따라서 한 번에 많은 프로그램을 실행할 수 있습니다. 
웹브라우저에서 유튜브를 보면서,
포토샵으로 사진을 편집하고, Spotify에서 음악 재생을 하며 Dropbox를 동시에 동기화 할 수 있습니다.
이는 운영체제에 대한 수십년간의 연구 및 이러한 프로그램을 저장 할 적당한 메모리가 없인 불가능합니다.
이는 운영체제에 대한 수십년간의 연구 및 이러한 프로그램을 저장 할 적당한 메모리가 없인 불가능합니다.
이것은 다음주에 또 하겠습니다.
이 에피소드를 후원 해준 Hover에게 감사 드립니다.
호버 (Hover)는 도메인의 구매와 관리에
 도움이되는 서비스입니다.
Hover에는 ".com 및 .net"을 포함한 여러분의 400개 이상의 도메인 확장명이 있습니다.
일반적인 주소보다 더 많은 전문적인
고유한 도메인을 얻을 수도 있습니다.
여기 Crash Course에서  "mongols.fans"라는 
도메인을 얻을 수 있습니다.
하지만 여러분은 이미 아는 것 같습니다.
한번 도메인을 만들면 기존 이메일로 전달할 맞춤 이메일 주소를 설정할 수 있습니다.
Outlook 또는 Gmail을 포함하여 여러분이 이미 사용하고 있는 것으로요.
호버를 사용하면 맞춤 도메인과
이메일 주소를 10 % 할인받을 수 있습니다.
Hover.com/crashcourse로 이동하여 귀하의 맞춤 도메인을 생성하고, 우리의 프로그램을 후원해주세요.
