
Korean: 
안녕하세요, 전 Carrie Anne이고,
컴퓨터 과학 특강에 온 것을 환영해요.
지난 에피소드에서,
논리 게이트를 사용하여 산술 및 논리 연산을 할 수 있는 간단한 ALU를 만들어 봤습니다.
ALU의 'A'는 산술(Arithmetic)이고, 
'L'은 논리(Logic)입니다.
하지만 계산한 결과가 버려진다면 아무 소용이 없지요.
계산 결과가 어떻게든 저장되어야지 
유용하게 쓰일 수 있습니다.
여러 연산이 연속해서 수행될 수도 있고요.
그래서 컴퓨터 메모리가 필요합니다.
게임기에서 긴 RPG 게임을 하던 도중이나,
데스크탑에서 어려운 레벨의 지뢰찾기 게임에 
집중하고 있는데,
여러분의 개가 다가오다가 
전원 코드를  벽에서 뽑아버린다면,
여러분이 하던 것들이 모두 날라갔을 때의 
고통을 알고 있을 거에요.
애도를 표합니다.
이런 일이 일어나는 이유는 
콘솔 게임기, 노트북이나 컴퓨터가
Random Access Memory (RAM)을
 사용하기 때문입니다.
RAM은 전원이 켜져 있을 때만 
게임 상태 같은 것을 저장할 수 있습니다.
지속성 메모리 (Persistent Memory)라고 불리는 다른
유형의 메모리는 전력 공급없이도 살아남을 수 있습니다.
이건 다른 데에 사용되니까, 
 다른 강의에서 메모리의 지속성에 대해 이야기 할게요.
오늘 우리는 작은것부터 시작할거에요.

iw: 
הי, אני קארי אן וברוכים הבאים לקראש קורס במדעי המחשב.
אז בפרק שעבר, באמצעות שערים לוגיים בלבד, בנינו ALU פשוט המבצע חישובים אריטמטיים
ופעולות לוגיות כמו ה- 'A' וה- 'L'.
אבל כמובן שאין טעם לחשב תוצאה רק כדי לזרוק אותה,
זה יכול להיות שימושי לאחסן את הערך הזה איפשהו, ואפילו להריץ כמה פעולות ברצף.
כאן נכנס הזיכרון של המחשב לתמונה!
אם אי פעם הייתם באמצע משחק RPG ארוך בקונסולה שלכם, או שאיכשהו
הצלחתם ברמה הקשה בשולה המוקשים במחשב שלכם, והכלב שלכם הגיע ומשך
את כבל החשמל החוצה, אתם מכירים את הצער שבאיבוד ההתקדמות שלכם.
תנחומים.
אבל הסיבה לאובדן שלכם היא שהקונסולה, המחשב הנייד והנייח שלכם
משתמשים בזיכרון בגישה רנדומלית, או RAM, שמאחסן דברים כמו רמות במשחק- כל עוד
החשמל ממשיך לזרום.
סוג אחר של זיכרון, הנקרא זיכרון מתמיד, יכול להחזיק ללא חשמל, והוא משמש
לדברים אחרים; אנחנו נדבר על הזיכרון המתמיד באחד הפרקים הבאים.

Spanish: 
Hola, soy Carrie Anne y bienvenidos a Crash Course Ciencias de la Computación.
Así que en el último episodio, usando solo compuertas lógicas, construimos una ALU simple, que realiza operaciones aritméticas
y operaciones lógicas, de ahí la 'A' y la 'L'.
Pero, por supuesto, no tiene mucho sentido calcular un resultado solo para no usarlo
Sería útil almacenar ese valor de alguna manera, y tal vez incluso ejecutar varias operaciones seguidas
¡Aquí es donde entra la memoria de la computadora!
Si alguna vez estuvistes en el medio de una larga campaña de rol en tu consola, o avanzando
a un nivel difícil en Buscaminas en tu escritorio, y tu perro se acercó, tropezó
y sacó el cable de alimentación de la pared, ya sabes la agonía de perder todo tu progreso.
Condolencias.
Pero la razón de su pérdida es que su consola, su computadora portátil y sus computadoras hacen
uso de la "Memoria de Acceso Aleatorio", o "RAM", que almacena cosas como el estado del juego, siempre que
el poder permanece encendido.
Otro tipo de memoria, llamada "Memoria Persistente", puede sobrevivir sin energía, y es
usado para diferentes cosas. Hablaremos sobre la persistencia de la memoria en un episodio posterior.

English: 
Hi, I’m Carrie Anne and welcome to Crash
Course Computer Science.
So last episode, using just logic gates, we
built a simple ALU, which performs arithmetic
and logic operations, hence the ‘A’ and
the ‘L’.
But of course, there’s not much point in
calculating a result only to throw it away
- it would be useful to store that value somehow, and maybe even run several operations in a row.
That's where computer memory comes in!
If you've ever been in the middle of a long
RPG campaign on your console, or slogging
through a difficult level on Minesweeper on
your desktop, and your dog came by, tripped
and pulled the power cord out of the wall,
you know the agony of losing all your progress.
Condolences.
But the reason for your loss is that your
console, your laptop and your computers make
use of Random Access Memory, or RAM, which
stores things like game state - as long as
the power stays on.
Another type of memory, called persistent
memory, can survive without power, and it’s
used for different things; We'll talk about
the persistence of memory in a later episode.

Chinese: 
嗨，我是 Carrie Anne，欢迎收看十分钟速成课：计算机科学
上集，我们用逻辑门做了个简单 ALU
它能执行算术 ( Arithmetic ) 和逻辑 ( Logic ) 运算，是 ALU 里 “A”和“L” 的由来
当然，如果算出来之后扔掉就没什么意义了
得找个方法存起来
可能还要进行多个连续操作
这就用到计算机内存了
如果你在主机上打过一场长时间的对局
或在困难模式“扫雷”中受难
然后狗跑过来，被电源线绊倒把插头拔了出来
你知道失去进度的痛苦
真同情你:(
你损失数据的原因是，电脑用的是"随机存取存储器"，简称为"RAM"
它存比如游戏状态这种东西 (只有电源开启时才能存)
另一种存储 (memory) 叫持久存储，电源关闭时数据也不会丢失
它用于存不同的东西;
我们之后会讨论存储 (memory) 的持续性问题.
今天我们从简单的开始

Korean: 
말그대로, 
 한 비트 정보를 저장할 수 있는 회로를 만드는 것부터요.
그리고 나서 크기를 키워서
우리 만의 메모리 모듈을 만들겁니다.
그런 다음 이 메모리를 ALU와 합치고, 
최종적으로 우리만의 CPU를 만들거에요.
 
지금까지 배웠던 모든 논리 회로는 오직 한 방향으로만 
진행했습니다. 항상 앞으로만 갔지요.
지난 강의에서 얘기했던 
8비트 리플 가산기처럼 말이죠.
하지만 우리는 스스로 되돌아 오는 (loop back) 회로도
 만들 수 있습니다.
일반적인 OR게이트를 살펴보죠.
출력을 되돌려서 한 쪽 입력에 끌어다 넣고
무슨 일이 일어나는지 봅시다.
먼저, 모든 입력을 0으로 합니다.
0 OR 0는 0이니까, 
이 회로는 항상 0을 출력하겠네요.
만약 입력 A를 1로 바꾼다면
1 OR 0은 1, 그래서 출력은 1이 됩니다
짧은 시간 후에,  입력 B로 신호가 돌아와서,
OR게이트의 모든 입력이 1이 됩니다.
1 OR 1 역시 1이니까, 출력에 변화가 없죠

Spanish: 
Hoy empezaremos pequeño, literalmente construyendo un circuito que pueda almacenar un...
solo... bit de información.
Después de eso, ampliaremos y construiremos nuestro propio módulo de memoria, y combinaremos
¡con nuestra ALU la próxima vez, cuando finalmente construyamos nuestra propia CPU!
 
Todos los circuitos lógicos que hemos discutido hasta ahora van en una dirección, siempre fluyendo hacia adelante,
como nuestros sumadores con propagación de acarreo de 8 bits del último episodio.
Pero también podemos crear circuitos que vuelvan sobre sí mismos.
Tratemos de tomar una puerta OR ordinaria y retroalimentar la salida a una de sus entradas
y mira lo que pasa.
Primero, establezcamos ambas entradas en 0.
Entonces 0 o (OR) 0 es 0, 
por lo que este circuito siempre emite 0.
Si tuviéramos que cambiar la entrada A a 1.
1 o (OR) 0 es 1, por lo que ahora 
la salida de la puerta OR es 1.
Una fracción de segundo más tarde, vuelve a la entrada B, por lo que la puerta OR (o) ve que
sus dos entradas son ahora 1.
1 OR 1 sigue siendo 1, por lo que no hay cambio en la salida.

English: 
Today, we’re going to start small - literally by building a circuit that can store one..
single.. bit of information.
After that, we’ll scale up, and build our
very own memory module, and we’ll combine
it with our ALU next time, when we finally
build our very own CPU!
INTRO
All of the logic circuits we've discussed
so far go in one direction - always flowing
forward - like our 8-bit ripple adder from
last episode.
But we can also create circuits that loop
back on themselves.
Let’s try taking an ordinary OR gate, and
feed the output back into one of its inputs
and see what happens.
First, let’s set both inputs to 0.
So 0 OR 0 is 0, and so this circuit always
outputs 0.
If we were to flip input A to 1.
1 OR 0 is 1, so now the output of the OR gate
is 1.
A fraction of a second later, that loops back
around into input B, so the OR gate sees that
both of its inputs are now 1.
1 OR 1 is still 1, so there is no change in
output.

iw: 
היום, אנחנו הולכים להתחיל בקטן- בפירוש. בכך שנבנה מעגל שיכול להכיל ביט
יחיד.. של מידע.
אחר כך, אנחנו נעלה רמה, ונבנה את מודול הזיכרון האישי שלנו, ונחבר זאת
עם ה- ALU שלנו בפעם הבאה, כשנבנה סוף סוף את ה- CPU האישי שלנו!
מוזיקת פתיחה
כל המעגלים הלוגיים שדיברנו עליהם עד עכשיו הולכים לכיוון אחד- תמיד קדימה-
כמו תוסף ה- 8-ביט שלנו מהפרק הקודם.
אבל אנחנו יכולים גם ליצור מעגלים שפעולתם היא סיבובית כלפי עצמם.
בואו ננסה לקחת שער OR פשוט, ולחבר את הפלט בחזרה לאחד הקלטים שלו
ונראה מה קורה.
קודם כל, בואו נגיד ששני הקלטים הם 0,
אז 0 או 0, כך שהמעגל הזה תמיד יפלוט 0.
אם נהפוך את הקלט A ל- 1.
ה- OR 0 הוא 1, ולכן הפלט של שער OR 1 יהיה 1.
חלקיק השנייה אחר כך, המעגל הסיבובי הזה חוזר לקלט B, כך ששער ה- OR רואה
ששני הקלטים שלו הם 1 עכשיו.
ה- OR 1 הוא עדיין 1, כך שאין שינוי בפלט של 1.

Chinese: 
- 做一个只能存 1 个 bit 的电路（Bit 就是 0 或 1）
之后再扩大，做我们自己的内存模块
下次会和 ALU 结合起来，*最终*完成我们的CPU！
我们至今说过的电路都是单向的
- 总是向前流动 -
就像上集的 8 位“脉动进位加法器”
但我们也可以做回向电路，把输出连回到输入。
让我们拿一个 OR 门，将输出传回输入
看看会发生什么
首先，两个输入都设为 0
“0 OR 0”是 0，所以电路输出0
如果将 A 变成1
“1 OR 0”为 1，所以输出 1
一转眼的功夫，输出回到 B
OR 门看到两个输入都是 1
“1 OR 1”仍然为1，所以输出不变

Chinese: 
如果将 A 变成 0，OR 门依然输出 1
现在我们有个电路能记录“1”
然而有个小问题：这个变化是永久的！
无论怎么试，都没法从 1 变回 0
现在看一个相同电路，不过这次用 AND 门。
A 和 B 都设为 1
“1 AND 1”的输出永远是 1
如果之后 A 设为 0，由于是 AND 门，输出会变成 0
这个电路能记录 0，和之前那个相反
就像之前，无论 A 设什么值，电路始终输出 0
现在我们有了能记录 1 和 0 的电路
为了做出有用的存储 (memory)，我们将两个电路合起来，变成
“AND-OR 锁存器”
它有两个输入，
 “设置”( SET ) 输入，将输出变成 1
 "复位" ( RESET )输入，将输出变成 0
它有两个输入，
 "设置"( SET ) 输入，将输出变成 1
 "复位" ( RESET )输入，将输出变成 0
如果“设置”和“复位”都是 0，电路会输出最后放入的内容
也就是说，它存住了 1 bit 的信息！
这就是存储！

English: 
If we flip input A back to 0, the OR gate
still outputs 1.
So now we've got a circuit that records a
“1” for us.
Except, we've got a teensy tiny problem - this
change is permanent!
No matter how hard we try, there’s no way
to get this circuit to flip back from a 1
to a 0.
Now let’s look at this same circuit, but
with an AND gate instead.
We'll start inputs A and B both at 1.
1 AND 1 outputs 1 forever.
But, if we then flip input A to 0, because
it’s an AND gate, the output will go to 0.
So this circuit records a 0, the opposite
of our other circuit.
Like before, no matter what input we apply
to input A afterwards, the circuit will always output 0.
Now we’ve got circuits that can record both
0s and 1s.
The key to making this a useful piece of memory
is to combine our two circuits into what is
called the AND-OR Latch.
It has two inputs, a "set" input, which sets
the output to a 1, and a "reset" input, which
resets the output to a 0.
If set and reset are both 0, the circuit just
outputs whatever was last put in it.
In other words, it remembers a single bit
of information!
Memory!

iw: 
אם נהפוך את הקלט A בחזרה ל- 0, שער ה- OR עדיין יפלוט 1.
אז עכשיו יש לנו מעגל שרשם "1" עבורנו.
אבל, יש לנו עדיין בעיה קטנה- זה משנה את הקבוע שלנו!
לא משנה כמה תנסו, אין דרך לגרום למעגל הזה להתהפך חזרה מ- 1
ל- 0.
עכשיו בואו נסתכל על אותו המעגל, אבל עם שער AND במקום.
אנחנו נתחיל בכך שקלטים A ו- B יהיו 1.
ה- AND 1 יפלוט 1, תמיד 1.
אבל, אם נהפוך את הקלט A ל- 0, מכיוון שהוא שער AND, הפלט יהפוך ל- 0.
אז המעגל הזה ירשום 0, ההפך מהמעגל השני שלנו.
כמו קודם, זה לא משנה איזה קלט יעבור דרך A אחר כך, המעגל תמיד יפלוט 0.
עכשיו יש לנו מעגלים שיכולים לרשום גם מספרי 0 וגם 1.
המפתח להפיכת פיסת הזיכרון הזאת לשימושית הוא בשילוב של שני מעגלים למה
שמכונה בריח AND-OR.
יש לו שני קלטים, קלט "מתג", המכוון את הפלט ל- 1, וקלט "אתחול",
שהופך את הפלט ל- 0.
אם גם המתג וגם האתחול על 0, המעגל פשוט פולט את כל מה שהוכנס בו קודם.
במילים אחרות, הוא זוכר ביט אחד של מידע!
זיכרון!

Korean: 
이젠 입력 A를  0으로 뒤집어도, 
OR게이트는 여전히 1을 출력합니다.
따라서 "1"을 기록하는 회로를 얻은 겁니다
다만, 아주 조그만 문제가 있습니다.
이후에 다시 바뀌지 않는다는 거에요..
아무리 노력해도 1에서 0으로로 바꿀 방법이 없습니다.
아무리 노력해도 1에서 0으로로 바꿀 방법이 없습니다.
이번엔 AND게이트를 가지고 같은 회로를 살펴보죠.
입력 A와 B가 모두 1일 때부터 시작합시다.
1 AND 1은 1을 영원히 출력합니다.
하지만 A를 0으로 바꾸면, AND게이트기 때문에 
출력이 0으로 바뀔 겁니다.
그래서 이 회로는 0을 기록합니다. 
아까랑 반대로요.
전처럼, 이후에 A가 뭐가 됐든 출력은 항상 0이 됩니다.
이제 우리는 0과 1을 기록할 수 있는 회로를 얻었습니다.
이것을 쓸만한 메모리 조각으로 만드는 비결은
 두 회로를 합치는 겁니다.
이것을 AND-OR 래치(자물쇠 또는 걸쇠의 의미)
라고 합니다.
이 래치는 2개의 입력을 갖고 있습니다. 
출력을 1로 만드는 "set"입력과,
출력을 0으로 만드는 "reset" 입력입니다.
모든 입력이 0이 된다면, 
회로는 마지막에 넣은 것을 출력합니다.
다시 말하면, 한 비트의 정보를 기억하는거죠!
메모리!!

Spanish: 
Si volvemos la entrada A a 0, la puerta OR todavía sale 1.
Entonces ahora tenemos un circuito que registra un "1" para nosotros.
Excepto, tenemos un pequeño problema: ¡este cambio es permanente!
No importa cuánto lo intentemos, no hay forma de hacer que este circuito retroceda desde un 1
a un 0.
Ahora veamos este mismo circuito, pero con una puerta AND en su lugar.
Comenzaremos las entradas A y B ambas en 1.
1 y (AND) 1 sale 1 para siempre.
Pero, si volvemos la entrada A a 0, porque es una puerta AND, la salida irá a 0.
Entonces este circuito registra un 0, el opuesto de nuestro otro circuito.
Al igual que antes, no importa qué entrada apliquemos a la entrada A después, el circuito siempre emitirá 0.
Ahora tenemos circuitos que pueden registrar tanto 0s como 1s.
La clave para hacer de esto una pieza útil de memoria es combinar nuestros dos circuitos en lo que es
llamado Pestillo AND-OR (y-o).
Tiene dos entradas, una entrada "SET", que establece la salida a un 1, y una entrada "RESET", que
restablece la salida a un 0.
Si set y reset son ambos 0, el circuito simplemente genera lo que fue puesto por última vez en él.
En otras palabras, ¡recuerda un solo bit de información!
¡Memoria!

Spanish: 
Esto se llama "latch (pestillo o registro)" porque "registra" un valor particular y se mantiene de esa manera.
La acción de poner datos en la memoria se llama escritura, mientras que sacar los datos
se llama lectura.
Bien, ¡entonces tenemos una forma de almacenar un solo bit de información!
¡Estupendo!
Desafortunadamente, tener dos cables diferentes para la entrada (set y reset) es un poco confuso.
Para hacer esto un poco más fácil de usar, realmente queremos un solo cable para ingresar datos, que
podemos establecer en 0 o 1 para almacenar el valor.
Además, vamos a necesitar un cable que permita que la memoria esté disponible
para escribir o "bloquear", lo que se denomina línea de habilitación de escritura.
Al agregar algunas compuertas lógicas adicionales, podemos construir este circuito, que se denomina Gated Latch (pestillo con cierre)
ya que la "puerta" se puede abrir o cerrar.
Ahora este circuito comienza a ponerse un poco complicado.
No queremos tener que lidiar con todas las puertas lógicas individuales ... así como antes, vamos
a subir un nivel de abstracción, y poner todo nuestro circuito de Gated Latch en una caja.
Una caja que almacena un bit
¡Probemos nuestro nuevo componente!
Comencemos todo a 0.

English: 
This is called a “latch” because it “latches
onto” a particular value and stays that way.
The action of putting data into memory is
called writing, whereas getting the data out
is called reading.
Ok, so we’ve got a way to store a single
bit of information!
Great!
Unfortunately, having two different wires
for input – set and reset – is a bit confusing.
To make this a little easier to use, we really
want a single wire to input data, that we
can set to either 0 or 1 to store the value.
Additionally, we are going to need a wire
that enables the memory to be either available
for writing or “locked” down --which is
called the write enable line.
By adding a few extra logic gates, we can
build this circuit, which is called a Gated Latch
since the “gate” can be opened or
closed.
Now this circuit is starting to get a little
complicated.
We don’t want to have to deal with all the
individual logic gates... so as before, we’re
going to bump up a level of abstraction, and
put our whole Gated Latch circuit in a box
-- a box that stores one bit.
Let’s test out our new component!
Let’s start everything at 0.

Chinese: 
之所以叫“锁存”，是因为它“锁定”一个特定值并保持状态
将数据放入叫“写入” ，将数据输出叫“读取”
好，现在我们终于有办法存一个 bit 了！
超棒！
麻烦的是，用两条线来输入，也就是 SET 和 RESET，有点难理解
为了更容易用，我们希望只有一条输入线
将它设为 0 或 1 来存储值
还需要一根线来“启用”(enable) 内存
启用时允许写入，没启用时“锁定”
- 这条线叫“允许写入线”
加一些额外逻辑门，可以做出这个电路
这个电路叫"门锁"（Gated Latch），因为门可以打开和关上。
现在这个电路开始有点复杂了
我们不想关心单独的逻辑门
就像之前，我们提升一层抽象
把“门锁”放到盒子里 (一个能存单个 bit 的盒子)
让我们来测一下新组件！
所有都从 0 开始
如果将 "数据线"   从 0 换到 1    或   从 1 换到 0

iw: 
זה נקרא "בריח" מכיוון שהוא "ננעל" על ערך מסויים ונשאר בו.
הפעולה של הכנסת מידע לתוך זיכרון נקראת כתיבה, והפעולה של הוצאת המידע
נקראת קריאה.
טוב, אז יש לנו דרך לאחסן ביט אחד של מידע!
מעולה!
לרוע המזל, זה שיש לנו שני חוטים לקלט- מתג ואתחול- זה קצת מבלבל.
כדי לעשות את זה קל יותר לשימוש, אנחנו נצטרך רק חוט אחד של מידע, שאותו
נוכל לכוון ל- 0 או ל- 1 כדי לשמור ערך.
בנוסף לכך, אנחנו נצטרך גם חוט המאפשר לזיכרון להיות זמין
לכתיבה או "נעול"- מה שמגדיר את האפשרות לכתוב או לא.
ע"י הוספה של כמה שערים לוגיים נוספים, נוכל לבנות מעגל שיקרא שער בריח
מאחר וה- "שער" יכול להיות פתוח או סגור.
אז המעגל הזה מתחיל להפוך לקצת מסובך.
אנחנו לא רוצים להתמודד עם כל השערים הלוגיים היחידים... אז כמו קודם, אנחנו
הולכים לעלות בשכבת הייצוג, ולשים את כל שער הבריח שלנו בקופסה-
קופסה המאחסנת ביט אחד.
בואו ננסה את הרכיב החדש שלנו!
בואו נתחיל הכל מ- 0.

Korean: 
이것을 래치(자물쇠 또는 걸쇠)라고 하는데,
특정한 값을 "붙잡아서" 유지하는 성질 때문이에요.
메모리에 데이터를 넣는 동작을
 "쓰기, writing"이라고 하고,
반대로 데이터를 받아오는 동작을
 "읽기 reading"이라고 합니다.
좋아요. 우리는 한 비트의 정보를
저장하는 법을 알았습니다
엄청나군요!
아쉽게도, set과 reset 두 개의 입력이 있어서 혼동되지요.
좀더 사용하기 쉽게,
데이터를 입력하는 선 하나만 있으면 좋을텐데요.
0과 1만 설정하면 그 값을 저장할 수 있도록요.
추가로 메모리 쓰기를 가능하게 하거나 
그럴 수 없게 잠궈버릴 수 있는 신호가 필요합니다.
이 걸 write enable 선이라고 하지요.
논리 게이트 몇 개 추가해서 
원하는 회로를 만들 수 있습니다.
이 것을 Gated Latch라고 합니다.
"문(gate)"을 열거나 닫을 수 있다는 뜻이지요.
이제 회로가 좀 복잡해지기 시작하네요
각 논리회로를 일일이 다루기 싫으니
예전에 한 것처럼 추상화 수준을 높히고,
Gated Latch 전체를 한 상자로 만들어버립시다.
하나의 비트를 저장하는 상자로요
자, 새로운 부품을 테스트해보죠!
모두 0으로 만들고 시작해봅시다.

Korean: 
0에서 1로, 1에서 0으로 데이터 선을 바꿔도 
아무 일도 일어나지 않고 출력은  0을 유지합니다.
write enable 선이 꺼져 있기 때문이죠.
이건 메모리가 바뀌는 것을 막는 것입니다.
write enable 선을 1로 바꾸어 "Gate"를 "열어"줍시다.
이제 래치에 값 1을 저장하도록 
데이터 선에 1을 넣을 수 있게 되었네요.
어떻게 1이 출력되는지 주목하세요.
성공!
이제 출력이 1로 유지 되도록 enable 선을 끕시다.
다시 한번 데이터 선의 값을 원하는 데로 바꿔 보면,
그래도 출력은 같은 값을 유지합니다.
값이 메모리에 저장된 겁니다
이제 enable 선을 다시 켜고, 
데이터 선을 사용해서 래치를 0으로 세팅해봅시다.
됐네요
enable 선을 끄고, 출력은 0입니다.
제대로 작동하죠.
물론 컴퓨터 메모리가 한 비트만 저장할 수 있다면 
그건 정말로 쓸모가 없죠.
프로거(80년대 PC 게임)를 돌리기에도
절대로 충분하지 않습니다.
아니면 아무것도 못돌리든가요.
래치를 딱 한개만 사용하라는 법은 없지요.
래치 8개를 옆으로 나란히 두면, 
8비트 숫자 같은 8비트의 정보를 저장할 수 있게 됩니다.
이렇게 작동하는 래치 그룹을
 "레지스터(register)"라고 부릅니다.
숫자 한 개를 저장할 수 있죠.
그리고 레지스터의 비트 수는
 "너비(width)"라고 부릅니다.

Spanish: 
Si alternamos el cable de datos de 0 a 1 o de 1 a 0, no ocurre nada, la salida permanece en 0.
Esto se debe a que el cable de habilitación de escritura está desactivado, lo que evita cualquier cambio en la memoria.
Entonces, debemos "abrir" la "puerta" girando el cable de habilitación de escritura a 1.
Ahora podemos poner un 1 en la línea de datos para guardar el valor 1 en nuestro Latch (pestillo).
Observe cómo el resultado ahora es 1.
¡Éxito!
Podemos desactivar la línea de habilitación, y la salida permanece como 1.
Una vez más, podemos alternar el valor en la línea de datos todo lo que queremos, pero la salida se
permanecer igual.
El valor se guarda en la memoria.
Ahora activemos nuevamente la línea de habilitación utilizando nuestra línea de datos para establecer el Latch (pestillo) en 0.
Hecho.
Habilite la línea desactivada, y la salida es 0.
¡Y funciona!
Ahora, por supuesto, la memoria de la computadora que solo almacena un bit de información no es muy
útil, definitivamente no es suficiente para ejecutar Frogger.
O cualquier cosa, realmente.
Pero no estamos limitados a usar solo un latch (pestillo).
Si colocamos 8 Latches (pestillos) uno al lado del otro, podemos almacenar 8 bits de información, como un número de 8 bits.
Un grupo de latches (pestillos) que funcionan de esta manera se llama registro, que guarda un solo número,
y el número de bits en un registro se llama su ancho.

English: 
If we toggle the Data wire from 0 to 1 or
1 to 0, nothing happens - the output stays at 0.
That’s because the write enable wire is
off, which prevents any change to the memory.
So we need to “open” the “gate” by
turning the write enable wire to 1.
Now we can put a 1 on the data line to save
the value 1 to our latch.
Notice how the output is now 1.
Success!
We can turn off the enable line and the output
stays as 1.
Once again, we can toggle the value on the
data line all we want, but the output will
stay the same.
The value is saved in memory.
Now let’s turn the enable line on again
use our data line to set the latch to 0.
Done.
Enable line off, and the output is 0.
And it works!
Now, of course, computer memory that only
stores one bit of information isn’t very
useful -- definitely not enough to run Frogger.
Or anything, really.
But we’re not limited to using only one
latch.
If we put 8 latches side-by-side, we can store
8 bits of information like an 8-bit number.
A group of latches operating like this is
called a register, which holds a single number,
and the number of bits in a register is called
its width.

iw: 
אם נכוון את חוט המידע מ- 0 ל- 1 או 1 ל- 0, שום דבר לא יקרה- הפלט יישאר על 0.
זאת מכיוון שהחוט המאפשר את הכתיבה לא מחובר, מה שמונע כל אפשרות לשינוי בזיכרון.
אז נצטרך "לפתוח" את "השער" בכך שנסובב את חוט הכתיבה ל- 1.
עכשיו אנחנו יכולים לשים 1 בשורת המידע כדי לשמור את הערך 1 בבריח שלנו.
שימו לב איך הפלט הוא 1 עכשיו.
הצלחנו!
אנחנו יכולים לכבות את שורת האפשרות לכתיבה והפלט יישאר 1.
שוב פעם, אנחנו יכולים לכוון את הערך של שורת המידע איך שנרצה, אבל הפלט
יישאר זהה.
הערך נשמר בזיכרון.
עכשיו בואו נדליק את שורת האיפשור שוב בכך שנשתמש בשורת המידע כדי לכוון את הבריח ל- 0.
בוצע.
שורת האפשור סגורה, והפלט הוא 0
וזה עובד!
עכשיו, כמובן, זיכרון של מחשב שיכול להכיל רק ביט אחד מידע לא ממש
שימושי- בהחלט לא מספיק כדי להריץ מתג.
או כל דבר, בעצם.
אבל אנחנו לא מוגבלים לשימוש בבריח אחד בלבד.
אם נשים 8 בריחים אחד ליד השני, נוכל לאחסן 8 ביטים של מידע, כמו מספר 8-ביט.
קבוצה של בריחים הפועלים בדרך הזאת נקראת אוגר, ומכילה מספר יחיד,
ומספר הביטים באוגר נקרא הרוחב שלו.

Chinese: 
什么也不会发生 - 输出依然是 0
因为“允许写入线”是关闭的（0），来防止内容变化
所以需要给 “允许写入线” 输入 1 ，来“打开”门
现在可以在“数据线”上放 1，将 1 存起来。
注意输出现在是 1 了。
成功了！
现在可以关掉 “允许写入线”，输出会保持 1
现在，我们可以给“数据线”随便输什么
但输出不会变
值存起来了
现在再次打开“允许写入线”，用“数据线”将锁存器设为0
完成
“允许写入线”关闭，输出 0
成功了！
当然，只能存 1 bit 没什么大用
- 肯定玩不了游戏
或做其它事情
但我们没限制只能用一个锁存器
如果我们并排放 8 个锁存器，可以存 8 位信息，比如一个 8 bit 数字
一组这样的锁存器叫“寄存器”
寄存器能存多少个 Bit 叫“位宽”
早期电脑用 8 位寄存器，然后是 16 位，32 位

Spanish: 
Las primeras computadoras tenían registros de 8 bits, luego 16, 32, y hoy en día, muchas computadoras tienen registros
de 64 bits de ancho
Para escribir en nuestro registro, primero debemos habilitar todos los latches (pestillos).
Podemos hacer esto con un solo cable que se conecta a todas sus entradas habilitadas, que establecemos en 1.
Luego enviamos nuestros datos usando los 8 cables de datos, y luego establecemos de nuevo la habilitación en 0, y
el valor de 8 bits ahora se guarda en la memoria.
Poner latches (pestillos) uno al lado del otro funciona bien para una "pequeña" cantidad de bits.
Un registro de 64 bits necesitaría 64 cables que se conectan a los pines de datos, y 64 cables que se ejecutan a
las salidas.
Por suerte, solo necesitamos 1 cable para habilitar todos los latches (pestillos), pero eso sigue siendo 129 cables.
¡Para 256 bits, terminamos con 513 cables!
¡La solución es una matriz!
En esta matriz, no organizamos nuestros latches en una fila, los ponemos en una cuadrícula.
Para 256 bits, necesitamos una cuadrícula de 16 por 16 latches con 16 filas y columnas de cables.
Para activar cualquier latch (pestillo), debemos activar la fila correspondiente Y el cable de la columna.
Vamos a acercarnos y ver cómo funciona esto.

English: 
Early computers had 8-bit registers, then
16, 32, and today, many computers have registers
that are 64-bits wide.
To write to our register, we first have to
enable all of the latches.
We can do this with a single wire that connects to all of their enable inputs, which we set to 1.
We then send our data in using the 8 data
wires, and then set enable back to 0, and
the 8 bit value is now saved in memory.
Putting latches side-by-side works ok for
a small-ish number of bits.
A 64-bit register would need 64 wires running
to the data pins, and 64 wires running to
the outputs.
Luckily we only need 1 wire to enable all
the latches, but that’s still 129 wires.
For 256 bits, we end up with 513 wires!
The solution is a matrix!
In this matrix, we don’t arrange our latches
in a row, we put them in a grid.
For 256 bits, we need a 16 by 16 grid of latches
with 16 rows and columns of wires.
To activate any one latch, we must turn on
the corresponding row AND column wire.
Let’s zoom in and see how this works.

Korean: 
초기의 컴퓨터는 8 비트 레지스터를 가지고 있었고
16, 32 순으로 커져, 요즘 대부분의 컴퓨터는 레지스터가
64 비트의 너비를 가집니다
레지스터에 쓰기 위해, 
먼저 모든 래치를 켜야 합니다.
선 하나를 모든 래치의 enable 입력에 연결하고
 1로 세팅합시다.
그런 뒤에 8개의 데이터 선을 이용하여 데이터를 보내고 
enable을 다시 0으로 되돌립니다
그러면 8 비트 값은 메모리에 저장됩니다.
래치를 나란히 놓아서 적은 수의 비트를 처리하는 것은 
문제가 없습니다.
64 비트 레지스터는 64개의 데이터 입력을 위한 선들과 64개의 출력을 위한 선이 필요하겠지요.
64 비트 레지스터는 64개의 데이터 입력을 위한 선들과 64개의 출력을 위한 선이 필요하겠지요.
다행히 모든 래치의 enable 선은 1개만 있어도 됩니다. 
그래도 선 129개가 필요하지요.(1+64+64)
256 비트 레지스터는 선이 513개나 필요합니다.
해결 방법은 매트릭스(행렬)를 사용하는 겁니다.
매트릭스에서는 래치를 일렬로 배열하지 않고 
격자로 배열합니다.
256비트 레지스터를 위해서는 16개의 행과 
16개 열로 된 16x16개 격자로 구성합니다.
래치 하나를 활성화 하려면 
해당하는 행과 열을 같이 켜줘야 합니다.
확대해서 어떻게 동작하는지 보지요.

iw: 
למחשבים מוקדמים היו אוגרים של 8-ביט, אז 16, 32, והיום, להרבה מחשבים יש
אוגר ברוחב של 64-ביט.
כדי לכתוב לאוגר שלנו, אנחנו קודם צריכים לאפשר את הכתיבה בכל הבריחים.
אנחנו יכולים לעשות זאת עם חוט יחיד המחובר לכל חיבורי האיפשור שלהם, אלו שמכוונים ל- 1.
אחר כך נשלח את המידע פנימה בעזרת חוטי ה- 8 ביט, ואז נחזיר את האיפשור חזרה ל- 0, וכך
ערך ה- 8 ביט יהיה שמור עכשיו בזיכרון שלנו.
העיקרון של לשים בריחים אחד ליד השני עובד טוב במספר קטן של ביטים.
אבל אוגר של 64-ביט יזדקק ל- 64 חוטים שיעבירו את המידע לרכיבי המידע, עוד 64 שיצאו
לפלטים.
למזלנו אנחנו זקוקים רק לחוט 1 כדי לאפשר את כל הבריחים, אך זה עדיין 129 חוטים.
עבור 256 ביטים, נזדקק לעד 513 חוטים!
הפיתרון הוא מטריצה!
במטריצה הזאת, אנחנו לא מסדרים את הבריחים שלנו בשורה, אלא שמים אותם בתבנית.
עבור 256 ביטים נזדקק לתבנית של 16 על 16 של בריחים הכוללת 16 שורות וטורים של חוטים.
כדי להפעיל כל בריח יחיד, נצטרך להדליק את השורה והטור המתייחסים אליו.
בואו נסתכל מקרוב יותר ונראה איך זה עובד.

Chinese: 
如今许多计算机都有 64 位宽的寄存器
写入寄存器之前，首先要启用里面所有锁存器
我们可以用一根线连接所有“允许输入线”，然后设为 1
然后用 8 条数据线发数据，然后将“允许写入线”设回 0
现在 8 bit 的值就存起来了
对于很少的 bit，并排放锁存器勉强够用。
64 位寄存器要 64 根数据线，64 根连到输出端
幸运的是，我们只要 1 根线启用所有锁存器，但加起来也有 129 条线了
存 256 个 bit，要 513 条线！
解决方法是用矩阵！
在矩阵中，我们不并列排放锁存器
而是做成网格
存 256 位，我们需要用 16x16 的锁存器，有 16X16 的线。
要启用某个锁存器，就打开相应的 行线和列线
让我们放大看看它是如何工作的

iw: 
אנחנו רוצים רק שהבריח שבצומת של שני החוטים הפעילים יופעל,
אבל כל שאר הבריחים צריכים להישאר מכובים.
בשביל זה, אנחנו יכולים להשתמש בשער AND הנאמן שלנו!
שער ה- AND יפלוט 1 רק במידה וגם חוט השורה וגם חוט הטור הם 1.
אז אנחנו יכולים להשתמש בסימן הזה כדי לבחור בריח אחד בלבד.
פעולת השורה/טור הזאת מחברת את כל הבריחים שלנו לחוט יחיד, משותף לאיפשור.
בכדי להפוך בריח לאפשרי לכתיבה, חוט השורה, חוט הטור,
וחוט מאפשר הכתיבה חייבים להיות על 1.
זה חייב להיות נכון עבור בריח אחד בכל נקודת זמן.
זה אומר שאנחנו יכולים להשתמש בחוט מידע יחיד ומשותף.
מכיוון שרק בריח אחד יהיה במצב המאפשר כתיבה, רק אחד ישמור את המידע.
שאר הבריחים פשוט יתעלמו מהערכים על חוט המידע מכיוון שהם
לא מאופשרים לכתיבה.
אנחנו יכולים להשתמש באותו הטריק עם חוט המאפשר קריאה כדי שנוכל לקרוא את המידע אחר כך, בכדי לקחת
את המידע מהבריח הייחודי.
זה אומר בסך הכל, עבור 256 ביטים של זיכרון, נזדקק רק ל- 35 חוטים- 1 חוט מידע, 1 חוט מאפשר כתיבה,
1 חוט המאפשר קריאה, ו- 16 שורות וטורים לפי הבחירה הזאת.

Spanish: 
Solo queremos habilitar el latch (pestillo) en la intersección de los dos cables activos,
pero todos los otros latches (pestillos) deben permanecer desactivados.
¡Para esto, podemos usar nuestra confiable puerta AND!
La puerta AND generará un 1 solo si los cables de fila y columna son ambos 1.
De modo que podemos usar esta señal para seleccionar de forma exclusiva un único latch.
Esta configuración de fila / columna conecta todos nuestros latches (pestillos) con un único cable compartido habilitado para escritura.
Para que un latch se convierta en habilitado para escritura, el cable de fila, el cable de columna y el cable habilitador de escritura
debe ser 1.
Eso solo debería ser cierto para un solo latch (pestillo) en cualquier momento dado.
Esto significa que podemos usar un único cable compartido para los datos.
Debido a que solo un latch estará siempre habilitado para la escritura, solo uno guardará los datos.
El resto de los latches simplemente ignorarán los valores en el cable de datos porque no están
habilitados para la escritura.
Podemos usar el mismo truco con un cable de habilitación de lectura para leer los datos más tarde, para obtener los datos
de un latch (pestillo) específico.
Esto significa que en total, para 256 bits de memoria, solo necesitamos 35 cables: 1 cable de datos, 1 cable de habilitación
de escritura, 1 cable de habilitación de lectura y 16 filas y columnas para la selección.

Chinese: 
我们只想打开交叉处那个锁存器的“允许写入线”
但所有其他锁存器保持禁用
我们可以用 AND 门！
只有 行线和列线 均为 1 ，AND 门才输出 1
所以可以用它来选择单个锁存器
这种行/列配置方法，用一根共享的“允许写入线”连接所有锁存器
为了使锁存器变为“允许写入”的状态
行线，列线和“允许写入线”都必须为 1
每次只会有 1 个锁存器会这样。
意味着可以只用一根“数据线”连所有锁存器来传数据
因为只有一个锁存器会启用，只有那个锁存器会存数据
其他锁存器会忽略数据线上的值，因为它们没有“允许写入”
我们可以用类似“允许写入线”的技巧来读数据
从一个特定锁存器获取数据
这意味着总共 256 位的存储
只需要 35 根线 -  1条“数据线”，1条“允许写入线”，1条“允许读取线”
然后16行16列的线用于选择锁存器（16x16 = 32, 32+3 = 35）

Korean: 
enable된 두 선의 교점에 있는 래치만 동작시키고,
나머지는 동작하지 않도록 해야지요.
그러기 위해서, 믿음직한 AND 게이트를 사용합니다.
AND 게이트는 열과 행이 모두 1이 되어야 1을 출력해서,
단 하나의 래치만 선택할 수 있는 신호로
 사용할 수가 있는 것이지요.
이렇게 행/열을 설치하기 때문에 모든 래치에 
write enable을 선 하나로 공통으로 연결할 수 있습니다.
하나의 래치가 쓰기 가능해지려면, 행, 열, 그리고
 write enable 선이 모두 1이 되어야만 합니다.
하나의 래치가 쓰기 가능해지려면, 행, 열, 그리고 write enable 선이 모두 1이 되어야만 합니다.
그래서 주어진 시간에 오직 하나의 래치만 작동합니다.
이 얘기는 데이터에 단일 공유 회선을
사용한다는걸 의미해요.
오직 한 개의 래치만 쓰기가 가능해지고, 
데이터를 저장할 수 있기 때문이죠.
나머지 래치들은 단순히 데이터 선의 값들을 
무시해버립니다.
그것들은 쓰기가 가능하지 않으니까요.
같은 방법으로 하나의 read enable 선을 사용해서 
하나의 래치를 콕 찍어서 데이터를 읽어올 수 있습니다.
같은 방법으로 하나의 read enable 선을 사용해서 하나의 래치를 콕 찍어서 데이터를 읽어올 수 있습니다.
정리하면, 256비트 메모리를 위해서
총 35개의 선만 사용하면 됩니다.
데이터 선 1개, write enable 1개, read enable 1개,
래치 선택을 위한 16개 행 선과 16개의 열 선.

English: 
We only want the latch at the intersection
of the two active wires to be enabled,
but all of the other latches should stay disabled.
For this, we can use our trusty AND gate!
The AND gate will output a 1 only if the row
and the column wires are both 1.
So we can use this signal to uniquely select
a single latch.
This row/column setup connects all our latches
with a single, shared, write enable wire.
In order for a latch to become write enabled,
the row wire, the column wire, and the write
enable wire must all be 1.
That should only ever be true for one single
latch at any given time.
This means we can use a single, shared wire
for data.
Because only one latch will ever be write
enabled, only one will ever save the data
-- the rest of the latches will simply ignore
values on the data wire because they are not
write enabled.
We can use the same trick with a read enable
wire to read the data later, to get the data
out of one specific latch.
This means in total, for 256 bits of memory,
we only need 35 wires - 1 data wire, 1 write
enable wire, 1 read enable wire, and 16 rows
and columns for the selection.

iw: 
זה חסכון משמעותי בחוטים!
אבל אנחנו זקוקים לדרך להבדיל בין כל צומת.
אנחנו יכולים לחשוב על זה כמו עיר, כשאתם אולי תרצו לפגוש מישהו/י בשדרה ה- 12
והרחוב ה- 8 -- זוהי כתובת המגדירה צומת.
לבריח שהרגע שמרנו בביט האחד שלנו יש כתובת של שורה 12 וטור 8.
מאחר שהכמות המקסימלית היא 16 שורות, אנחנו נשמור את כתובת השורה כמספר של 4 ביט.
12 בבינארי זה 1100.
אנחנו יכולים לעשות את אותו הדבר עבור כתובת הטור: 8 זה 1000 בבינארי.
אז הכתובת של הבריח הייחודי בו בדיוק השתמשנו יכולה להיכתב כ- 11001000.
כדי לעבור מכתובת למשהו שבוחר את השורה או הטור הנכונים, נזדקק לרכיב
מיוחד הנקרא מולטיפלקסר- זהו רכיב מחשב עם שם די נחמד
לפחות בהשוואה ל- ALU.
מולטיפלקסרים מגיעים בכמה מידות שונות, אבל מכיוון שיש לנו 16 שורות, אנחנו זקוקים למולטיפלקסר
של 1 עד 16.
זה עובד בצורה הזאת.
אתם מאכילים אותו במספר של 4 ביט, והוא מחבר את קו הקלט לקו הפלט המתייחס אליו.

Korean: 
엄청나게 선의 수를 줄일 수가 있지요.
각 교차점을 정확하게 지정할 수 있는 방법이 필요합니다.
여러분이 12th avenue,
 8th street에서 누군가를 만난다고 해보죠.
12th avenue 그리고 8th street.
이게 교차로를 나타내는 주소 입니다.
12번째 행, 8번째 열의 주소에 있는 래치에 
하나의 비트를 저장했다고 합시다.
최대 16개 행이 있으니까, 행 주소를 4비트로 표현합니다.
12는 이진수로 1100입니다.
열 주소도 마찬가지입니다. 8은 이진수로 1000이죠.
이렇게 특정 래치를 나타내는 주소를
11001000이라고 쓸 수 있습니다.
특정한 행이나 열을 선택한 주소로 변환하기 위해서는
멀티플렉서라고 하는 특별한 부품이 필요합니다. 
꽤 멋진 이름을 가진 컴퓨터 부품이죠.
적어도 ALU에 비교하면요.
멀티플렉서는 어떤 크기도 가능하지만,
 여기서는 행이 16개니까,
1 to 16 멀티플렉서가 필요합니다.
이렇게 작동합니다.
4비트 숫자를 입력하고, 입력선을 
그에 해당하는 출력 선에 연결합니다.

Spanish: 
¡Eso es un importante ahorro de cables!
Pero necesitamos una forma de especificar de manera única cada intersección.
Podemos pensar en esto como una ciudad, donde es posible que desee conocer a alguien en la avenida 12
y la calle 8: esa es una dirección que define una intersección.
El pestillo (latch) en el que acabamos de guardar nuestro bit tiene una dirección de la fila 12 y la columna 8.
Como hay un máximo de 16 filas, almacenamos la dirección de la fila en un número de 4 bits.
12 es 1100 en binario.
Podemos hacer lo mismo para la dirección de columna: 8 es 1000 en binario.
Entonces, la dirección del latch particular que acabamos de usar se puede escribir como 11001000.
Para convertir una dirección en algo que selecciona la fila o columna correcta, necesitamos
un componente especial llamado multiplexor, que es el componente de la computadora con un nombre
genial al menos en comparación con la ALU.
Los multiplexores vienen en todos los tamaños diferentes, pero debido a que tenemos 16 filas, necesitamos un multiplexor de
1 a 16.
Funciona así.
Le das un número de 4 bits y conecta la línea de entrada a una línea de salida correspondiente.

Chinese: 
这省了好多线！
但我们需要一种方法来 唯一指定 交叉路口
我们可以想成一个城市
你可能想在第 12 大道和第 8 街和某人碰面
- 这是一个定义交叉点的地址
我们刚刚存了一个 bit 的地址是“12行 8列”
由于最多 16 行，用 4 个二进制 bit 就够了（1111 是 15，0~15，16个数字）
“12”用二进制表示为“1100”
我们可以对列地址做同样的事：“8”用二进制表示为“1000”
所以刚才说的地址可写作“11001000”
为了将地址转成  行和列
我们需要一个部件叫 “多路复用器”
- 这个名字起码比 ALU 酷一点
多路复用器有不同大小
因为我们有 16 行，我们需要 1 到 16 多路复用器
它的工作方式是
你输入一个 4 bit 数字，它会把那根线连到相应的输出线

English: 
That’s significant wire savings!
But we need a way to uniquely specify each
intersection.
We can think of this like a city, where you
might want to meet someone at 12th avenue
and 8th street -- that's an address that defines
an intersection.
The latch we just saved our one bit into has
an address of row 12 and column 8.
Since there is a maximum of 16 rows, we store the row address in a 4 bit number.
12 is 1100 in binary.
We can do the same for the column address: 8 is 1000 in binary.
So the address for the particular latch we
just used can be written as 11001000.
To convert from an address into something
that selects the right row or column, we need
a special component called a multiplexer -- which
is the computer component with a pretty cool
name at least compared to the ALU.
Multiplexers come in all different sizes,
but because we have 16 rows, we need a 1 to
16 multiplexer.
It works like this.
You feed it a 4 bit number, and it connects
the input line to a corresponding output line.

Spanish: 
Entonces, si introducimos 0000, seleccionará la primera columna para nosotros.
Si pasamos en 0001, se selecciona la siguiente columna, y así sucesivamente.
Necesitamos un multiplexor para manejar nuestras filas y otro multiplexor para manejar las columnas.
Ok, está comenzando a complicarse nuevamente, así que hagamos que nuestra memoria de 256 bits sea su propio componente.
¡Una vez más un nuevo nivel de abstracción!
Se necesita una dirección de 8 bits para la entrada: los 4 bits para la columna y 4 para la fila.
También necesitamos cables de habilitación de escritura y lectura.
Y, por último, necesitamos un cable de datos, que se puede utilizar para leer o escribir datos.
Desafortunadamente, incluso 256 bits de memoria no son suficientes para ejecutar la mayoría de cosas, por lo que necesitamos
¡ampliar aún más!
Vamos a ponerlos en una fila.
Al igual que con los registros.
Haremos una fila de 8 de ellos, para que podamos almacenar un número de 8 bits, también conocido como byte.
Para hacer esto, alimentamos la misma "dirección" en los 8 componentes de nuestra memoria de 256 bits.

English: 
So if we pass in 0000, it will select the
very first column for us.
If we pass in 0001, the next column is selected,
and so on.
We need one multiplexer to handle our rows
and another multiplexer to handle the columns.
Ok, it’s starting to get complicated again,
so let’s make our 256-bit memory its own component.
Once again a new level of abstraction!
It takes an 8-bit address for input - the
4 bits for the column and 4 for the row.
We also need write and read enable wires.
And finally, we need just one data wire, which
can be used to read or write data.
Unfortunately, even 256-bits of memory isn’t
enough to run much of anything, so we need
to scale up even more!
We’re going to put them in a row.
Just like with the registers.
We’ll make a row of 8 of them, so we can
store an 8 bit number - also known as a byte.
To do this, we feed the exact same address
into all 8 of our 256-bit memory components

Chinese: 
如果输入 0000，它会选择第一列
如果输入 0001，则选择下一列，依此类推
一个多路复用器处理行(row)，另一个多路复用器处理列(column)
好吧，开始有点复杂了
那么把 256 位内存当成一个组件来看好了
我们又升了一层抽象！
# 媲美蒙古人的动画
它需要一个 8 bit 地址：4 bit 代表哪一列，4 bit 代表哪一行
我们还需要“允许写入线”和“允许读取线”
最后，还需要一条数据线，用于读/写数据
不幸的是， 256 位的内存也没法做什么事
所以我们需要扩大规模
把它们并排放置
就像寄存器一样
一行8个，可以存一个 8 bit 数字，也叫一个字节（byte）
为了存一个 8 bit 数字，我们同时给 8 个 256 位内存一样的地址

iw: 
אז אם נכניס 0000, זה יבחר את הטור הראשון עבורנו.
אם נכניס 0001, הטור הבא ייבחר וכך הלאה.
אנחנו זקוקים למולטיפלקסר אחד כדי לטפל בשורות ועוד אחד כדי לטפל בטורים.
טוב, זה שוב מתחיל להסתבך, אז בוא נהפוך את זיכרון ה- 256-ביט שלנו לרכיב בפני עצמו.
שוב פעם, עוד רמת ייצוג!
זה דורש נקודת 8-ביט לקלט- 4 ביטים לטור ו- 4 לשורה.
אנחנו גם זקוקים לחוטים מאפשרים לכתיבה וקריאה.
ולבסוף, אנחנו זקוקים רק לחוט מידע אחד, שיכול לשמש כדי לקרוא או לכתוב מידע.
לרוע המזל, אפילו 256-ביטים של זיכרון לא מספיקים כדי להריץ הרבה משום דבר, אז
אנחנו צריכים לעלות אפילו יותר!
אנחנו הולכים לשים אותם בשורה.
בדיוק כמו עם האוגרים.
אנחנו נעשה שורה חדשה של 8 מהם, כך שנוכל לשמור מספר של 8 ביט- שידוע גם כבייט.
כדי לעשות זאת, אנחנו מכניסים את אותו הערך לכל ה- 8 מרכיבי הזיכרון 256-ביט שלנו.

Korean: 
0000을 넣으면, 제일 첫 열을 선택할 겁니다.
0001을 넣으면, 그 다음 열을 선택할거구요. 다른 수도 만찬 가지입니다.
행을 담당하는 멀티플렉서와 
열을 담당하는 멀티플렉서가 필요합니다.
좋아요, 다시 복잡해지기 시작하는 군요.
256 비트 메모리를 하나의 부품으로 만듭시다.
한 번 더 새로운 추상화 레벨!
8비트 주소를 입력으로 받습니다. 
4비트는 행을 4비트는 열을 나타내지요.
write와 read enable이 필요하고요.
마지막으로 데이터 선 하나가 있어야죠.
이 선으로 데이터 읽기, 쓰기를 할 겁니다.
아쉽게도, 256 비트 메모리라고 할지라도
뭔가를 하기에는 충분하지 않습니다.
그래서 더 확장해볼 거에요.
이것들을 한 열로 붙여봅니다.
레지스터 같이요.
8개를 일렬로 세웠으니
, 8비트의 숫자를 저장할 수가 있습니다.
8비트는 1바이트죠.
그럴려면, 8개 모든 256비트 메모리에 
정확히 똑같은 주소를 동시에 입력합니다.

English: 
at the same time, and each one saves one bit
of the number.
That means the component we just made can
store 256 bytes at 256 different addresses.
Again, to keep things simple, we want to leave
behind this inner complexity.
Instead of thinking of this as a series of
individual memory modules and circuits, we’ll
think of it as a uniform bank of addressable
memory.
We have 256 addresses, and at each address,
we can read or write an 8-bit value.
We’re going to use this memory component
next episode when we build our CPU.
The way that modern computers scale to megabytes
and gigabytes of memory is by doing the same
thing we’ve been doing here -- keep packaging
up little bundles of memory into larger, and
larger, and larger arrangements.
As the number of memory locations grow, our
addresses have to grow as well.
8 bits hold enough numbers to provide addresses for 256 bytes of our memory, but that’s all.
To address a gigabyte – or a billion bytes
of memory – we need 32-bit addresses.
An important property of this memory is that
we can access any memory location, at any
time, and in a random order.

Spanish: 
al mismo tiempo, y cada uno guarda un bit del número.
Eso significa que el componente que acabamos de crear puede almacenar 256 bytes en 256 direcciones diferentes.
Nuevamente, para mantener las cosas simples, queremos dejar atrás esta complejidad interna.
En lugar de pensar en esto como una serie de módulos de memoria y circuitos individuales, lo haremos
pensar en ello como un banco uniforme de memoria direccionable.
Tenemos 256 direcciones, y en cada dirección, podemos leer o escribir un valor de 8 bits.
Vamos a usar este componente de memoria el próximo episodio cuando construyamos nuestra CPU.
La forma en que las computadoras modernas escalan a megabytes y gigabytes de memoria es haciendo lo mismo
que hemos estado haciendo aquí: seguir empaquetando pequeños paquetes de memoria en arreglos más grandes y más
grandes y más grandes.
A medida que crece la cantidad de ubicaciones de memoria, nuestras direcciones también deben crecer.
8 bits contienen suficientes números para proporcionar direcciones para 256 bytes de nuestra memoria, pero eso es todo.
Para abordar un gigabyte, o mil millones de bytes de memoria, necesitamos direcciones de 32 bits.
Una propiedad importante de esta memoria es que podemos acceder a cualquier ubicación de memoria, en cualquier
tiempo, y en un orden aleatorio.

iw: 
באותו הזמן, וכל אחד שומר ביט אחד מהמספר.
זה אומר שהרכיב שיצרנו יכול לאחסן 256 בייטים ב- 256 מקומות שונים.
שוב, כדי להפוך את זה לפשוט, אנחנו רוצים להניח בצד את המורכבות הפנימית.
במקום לחשוב על זה כעל סדרה של מודולי זיכרון יחידים ומעגלים, אנחנו
אנחנו נחשוב עליהם כבנק של כתובות לזיכרון.
יש לנו 256 כתובות, ובכל כתובת, אנחנו יכולים לקרוא או לכתוב ערך של 8-ביט.
אנחנו הולכים להשתמש ברכיב הזיכרון הזה בפרק הבא כשנבנה את ה- CPU שלנו.
הצורה בה הזיכרון של מחשבים מודרניים צמח למגהבייטים וג'יגהבייטים היא ע"י אותה הפעולה
שעשינו כאן- לשים יותר יותר רכיבי זיכרון קטנטנים
במארג שהולך וגדל.
כשמספר מקומות הזיכרון גדל, מספר הכתובות שלנו חייב לגדול גם כן.
ביטים מחזיקים מספיק מספרים כדי לספק 8 כתובות עבור 256 בייטים של זיכרון, אבל זה הכל.
כדי להגיע לג'יגהבייט- או מיליארד בייטים של זיכרון- אנחנו נזדקק לכתובות 32-ביט.
תכונה חשובה של הזיכרון הזה היא שאנחנו יכולים לכל מקום בזיכרון, בכל זמן,
בסדר רנדומלי.

Korean: 
그리고, 각 메모리에는
 숫자의 한 비트씩 저장하는 겁니다.
즉, 방금 만든 부품은 256개의 주소에
 256 바이트를 저장할 수 있다는 거죠.
이렇게 복잡한건 치워 버리고, 
다시 한번 간단하게 만들어 봅시다.
일렬로 연결된 메모리 모듈과 회로로 
생각하는 대신에,
주소로 지정 가능한 메모리의
 일정한 분할단위 (뱅크) 라고 생각합시다.
256개의 주소가 있고, .
각 주소에 있는 8비트 값을 읽거나,
8비트 값을 쓸 수가 있습니다
이 메모리를 다음 강의에서 만들어 볼 
CPU에 사용할 겁니다.
요즘 컴퓨터에서 메모리를 메가바이트와 기가바이트로 확장하는 방법도 여기서 배운 것과 동일합니다.
작은 메모리 묶음을 크고 크고 더 큰 배열로 묶는 거에요.
작은 메모리 묶음을 크고 크고 더 큰 배열로 묶는 거에요.
메모리 위치의 수가 증가하면, 
주소도 증가해야 됩니다.
8비트의 주소는 256바이트의 메모리에 나타내기에 
충분하지만, 그게 다죠.
기가바이트 (십억 바이트) 메모리의 주소를 나타내려면
 32비트 주소가 필요합니다.
오늘 배운 메모리의 중요한 특성은
언제, 어느 위치든 무작위 순서로 
접근이 가능하다는 것입니다.

Chinese: 
每个存 1 bit
意味着我们可以在 256 个地址存 256 个字节 （byte）（1 个 byte 是 8 个 bit）
再次，为了简单，我们不管内部。
不看作一堆单独的存储和电路
看做一个统一的可寻址内存
我们有 256 个地址
每个地址可以 读或者写 一个 8 bit 值
我们下集做 CPU 时会用到这个内存
现代计算机扩展到兆字节（MB）和千兆字节（GB）内存的方式
就像我们这里做的一样
不断将内存打包扩至更大规模
随着内存大小增长，内存地址也必须增长
8 bit 最多能代表 256 个内存地址 
（1111 1111 是255，0~255 一共 256 个数字）
但 256 字节就是最大了
要给千兆或十亿字节的内存寻址，需要 32 位的地址
内存的一个重要特性是可以随时访问任何位置

iw: 
מהסיבה הזאת זה נקרא זיכרון גישה רנדומלית או RAM.
כשאתם שומעים אנשים מדברים על כמה RAM יש למחשב- זהו הזיכרון של המחשב.
ה- RAM הוא ביטוי מקוצר או זיכרון עבודה, בו אתם יכולים לעקוב אחרי הדברים
המתרחשים עכשיו- כמו האם כבר אכלתם צהריים או שילמתם את חשבון הטלפון.
הנה רכיב RAM אמיתי- עם 8 מודולי זיכרון המאוכסנים על הלוח.
אם נפתח בזהירות את אחד המודולים האלו ונביט פנימה, הדבר הראשון שתראו הוא
32 ריבועים של זיכרון.
תביטו פנימה לאחד הריבועים האלו, ונוכל לראות שכל רכיב מורכב מ- 4 בלוקים קטנים יותר.
אם נסתכל עוד יותר מקרוב, אנחנו נגיע למטריצה של הביטים היחידים.
המטריצה הזאת היא של 128 על 64 ביטים.
זה 8192 ביטים בסך הכל.
לכל אחד מ- 32 הריבועים שלנו יש 4 מטריצות, כך שזה 32 אלף, שבע מאות ו- 68 ביטים.
ויש 32 ריבועים בסך הכל.
כך שבסך הכל, זה בערך 1 מיליון ביטים של זיכרון בכל שבב.
רכיב ה- RAM שלנו מכיל 8 מהשבבים האלו, כך שבסך הכל, ה- RAM הזה יכול להכיל 8 מיליון ביטים.
הידועים גם כ- 1 מגהבייט.

English: 
For this reason, it’s called Random-Access
Memory or RAM.
When you hear people talking about how much RAM a computer has - that's the computer’s memory.
RAM is like a human’s short term or working
memory, where you keep track of things going
on right now - like whether or not you had
lunch or paid your phone bill.
Here’s an actual stick of RAM - with 8 memory
modules soldered onto the board.
If we carefully opened up one of these modules
and zoomed in, The first thing you would see
are 32 squares of memory.
Zoom into one of those squares, and we can
see each one is comprised of 4 smaller blocks.
If we zoom in again, we get down to the matrix
of individual bits.
This is a matrix of 128 by 64 bits.
That’s 8192 bits in total.
Each of our 32 squares has 4 matrices, so
that’s 32 thousand, 7 hundred and 68 bits.
And there are 32 squares in total.
So all in all, that’s roughly 1 million
bits of memory in each chip.
Our RAM stick has 8 of these chips, so in
total, this RAM can store 8 millions bits,
otherwise known as 1 megabyte.

Korean: 
그래서  임의 접근 메모리 (Random Access Memory), RAM이라고 부르는 것입니다.
컴퓨터에 얼마나 큰 RAM을 달았는지 얘기하는 것은
 컴퓨터 메모리를 말하는 것입니다.
RAM은 인간의 단기 또는 활동 중인 기억과 비슷합니다. 사람은 일들이 잘 되고 있는지 계속 추적하고 있어야지요.
내가 점심을 먹었는지, 
전화 요금을 냈는지 하는 것들이요.
이게 진짜 막대기 모양의 RAM입니다. 
보드에 8개의 메모리가 납땜되어있죠.
메모리 모듈 한 개를 조심 스럽게 열어서 확대해 보면,
가장 먼저 32개의 메모리 사각형이 보입니다.
이 사각형 하나를 확대하면, 
4개의 블럭을 볼 수가 있지요.
다시 한번 확대하면, 각각 비트의 행렬이 나옵니다.
이것은 128 x 64 비트 행렬 입니다.
총 8192 비트입니다.
32개의 사각형이 각각 4개의 행렬을 갖고 있으니까,
 3만 2천 7백 68 비트
사각형이 32개니까,
이 칩에는 대략 백 만 비트가 있군요.
(32768*32=1,048,576)
RAM 스틱에 이런 칩이 8개 있으니까,
총 8백만 비트 또는 1 메가바이트를 저장할 수 있습니다.
RAM 스틱에 이런 칩이 8개 있으니까,
총 8백만 비트 또는 1 메가바이트를 저장할 수 있습니다.

Chinese: 
因此叫“随机存取存储器”，简称 RAM
当你听到有人说电脑有多少 RAM
他的意思是内存有多大
RAM 就像人类的短期记忆
记录当前在做什么事
比如是否吃过午饭 或 是否缴了电话费
这是一条真的内存，上面焊了 8 个内存模块
如果打开其中一个，然后放大
会看到 32 个内存方块
放大其中一个方块，可以看到由 4 个小块组成
如果再放大，可以看到存单个 bit 的矩阵
这是一个 128 Bit x 64 Bit 的矩阵
总共 8192 bit
32 个方格每个都有 4 个矩阵，所以一个方格有 32,768 个 bit （8192 x 4 = 32768）
而一共 32 个方格
总而言之，8 个芯片，每 1 个大约存 100 万 bit
RAM 有 8 个这样的芯片，所以总共存 800 万 bit
800 万位也叫 1 兆字节（MB）

Spanish: 
Por esta razón, se llama Memoria de Acceso Aleatorio o RAM.
Cuando escuche a las personas hablar sobre la cantidad de RAM que tiene una computadora, esa es la memoria de la computadora.
La memoria RAM es como la memoria de trabajo o de corto plazo de un ser humano, donde se hace un seguimiento de las cosas que van
en ese momento, como si almorzastes o no o pagastes la factura de tu teléfono.
Aquí hay una memoria RAM real: con 8 módulos de memoria soldados en la placa.
Si abrimos cuidadosamente uno de estos módulos y lo acercamos, Lo primero que vería
son 32 cuadrados de memoria.
Zoom en uno de esos cuadrados, y podemos ver que cada uno se compone de 4 bloques más pequeños.
Si hacemos un acercamiento de nuevo, llegamos a la matriz de bits individuales.
Esta es una matriz de 128 por 64 bits.
Eso es 8192 bits en total.
Cada uno de nuestros 32 cuadrados tiene 4 matrices, por lo que son 32.768 bits.
Y hay 32 cuadrados en total.
Así que en general, eso es aproximadamente 1 millón de bits de memoria en cada chip.
Nuestra memoria RAM tiene 8 de estos chips, por lo que en total, esta RAM puede almacenar 8 millones de bits,
también conocido como 1 megabyte.

iw: 
זה לא הרבה זיכרון בימינו- זהו מודול RAM משנות ה- 80.
היום אתם יכולים לקנות RAM שיש לו ג'יגהבייט של זיכרון ויותר- זה מיליארדי בייטים
של זיכרון.
אז, היום בנינו רכיב של SRAM- רכיב זיכרון רנדומלי סטטי- שעושה שימוש בבריחים.
ישנם עוד סוגים של RAM, כמו DRAM, זיכרון פלאש ו- NVRAM.
אלו מאוד דומים בשימושיות שלהם ל- SRAM, אבל משתמשים במעגלים שונים כדי לאחסן
ביטים יחידים- לדוגמא, שימוש שונה בשערים לוגיים, קבלים ועוד.
אבל באופן בסיסי, כל הטכנולוגיות האלו שומרות ביטים של מידע במטריצות
רבות של תאי זיכרון.
כמו דברים רבים במחשוב, התפעול הבסיסי הוא פשוט יחסית.. זה
השכבות על שכבות של ייצוג שעושים את זה מרתק- כמו בובת בבושקה רוסית
שהופכת לקטנה יותר ויותר.
אני אראה אתכם בשבוע הבא.

English: 
That’s not a lot of memory these days -- this
is a RAM module from the 1980’s.
Today you can buy RAM that has a gigabyte
or more of memory - that’s billions of bytes
of memory.
So, today, we built a piece of SRAM - Static
Random-Access Memory – which uses latches.
There are other types of RAM, such as DRAM, Flash memory, and NVRAM.
These are very similar in function to SRAM,
but use different circuits to store the individual
bits -- for example, using different logic
gates, capacitors, charge traps, or memristors.
But fundamentally, all of these technologies
store bits of information in massively nested
matrices of memory cells.
Like many things in computing, the fundamental
operation is relatively simple.. it’s the
layers and layers of abstraction that’s
mind blowing -- like a russian doll that
keeps getting smaller and smaller and smaller.
I’ll see you next week.

Chinese: 
1 MB 在如今不算大内存 - 这是 1980 年代的 RAM
如今你可以买到千兆字节（GB）的 RAM
这可是数十亿字节的内存
今天，我们用锁存器做了一块 SRAM（静态随机存取存储器）
还有其他类型的 RAM，如 DRAM，闪存和 NVRAM
它们在功能上与 SRAM 相似
但用不同的电路存单个 bit
- 比如用不同的逻辑门，电容器，电荷陷阱或忆阻器
但从根本上说，所有这些技术都是用矩阵层层嵌套，来存储大量信息
就像计算中的很多事情一样，基本操作都比较简单
让人难以理解的是那些一层层的精妙抽象
像一个越来越小的俄罗斯套娃
下周见

Spanish: 
Eso no es mucha memoria en estos días: este es un módulo RAM de la década de 1980.
Hoy puedes comprar RAM que tiene un gigabyte o más de memoria, eso es miles de millones de bytes
de la memoria
Entonces, hoy, construimos una pieza de SRAM - Static Random-Access Memory - que usa latches.
Hay otros tipos de RAM, como DRAM, memoria Flash y NVRAM.
Estos son muy similares en función a la SRAM, pero usan diferentes circuitos para almacenar los bits individuales,
por ejemplo, usando diferentes compuertas lógicas, condensadores, trampas de carga o memristores.
Pero, fundamentalmente, todas estas tecnologías almacenan bits de información en matrices de celdas de memoria anidadas masivamente.
memoria anidadas masivamente.
Al igual que muchas cosas en informática, la operación fundamental es relativamente simple. Son las
capas y las capas de abstracción las que te dejan boquiabierto, como una muñeca rusa que
se vuelve cada vez más y más y más pequeña.
Te veré la próxima semana.

Korean: 
이 메모리는 요즘 쓰이는 것이 아니고, 
1980년대에 쓰이던 모듈입니다.
요즘에는 기가바이트 이상의 메모리를 살 수 있습니다.
수십억 바이트의 메모리를요.
오늘 우리는 래치를 이용해서 SRAM (Static Random Access Memory) 한 조각을 만들어 보았습니다.
(SRAM : 정적 무작위 접근 기억장치)
DRAM, Flash 메모리, NVRAM과 같이
다른 종류의 램도 있습니다.
SRAM과 기능은 거의 유사합니다. 
각각의 비트를 저장하는 회로에 차이가 있는 거지요.
예를 들면, 다른 논리 회로, 축전기(캐패시터),
 차지 트랩, 멤리스터가  있습니다.
그러나 근본적으로, 이 모든 기술은 
메모리 셀이 대량으로 포개진 행과 열 안에서
정보 비트를 저장하는 기술들입니다.
컴퓨팅의 많은 부분과 마찬가지로
기본적인 동작은 상대적으로 간단해요.
놀랄만한 추상화의 단계, 단계들이 있지요.
점점 더 작아지는 러시아 인형처럼요.
다음 주에 봅시다.

iw: 
קרדיטים

Korean: 
 

English: 
Credits

Spanish: 
Créditos
