WEBVTT

00:00.000 --> 00:02.000
You

00:30.000 --> 00:32.000
You

01:00.000 --> 01:02.000
You

01:30.000 --> 01:32.000
You

02:00.000 --> 02:02.000
You

02:30.000 --> 02:32.000
You

03:00.000 --> 03:02.000
You

03:30.000 --> 03:32.000
You

04:00.000 --> 04:02.000
You

04:30.000 --> 04:32.000
You

05:00.000 --> 05:02.000
You

05:30.000 --> 05:32.000
You

06:00.000 --> 06:02.000
You

06:02.000 --> 06:04.000
You

06:30.000 --> 06:32.000
You

06:32.000 --> 06:34.000
You

07:00.000 --> 07:02.000
You

07:02.000 --> 07:04.000
You

07:30.000 --> 07:32.000
You

07:32.000 --> 07:34.000
You

07:34.000 --> 07:36.000
You

08:00.000 --> 08:02.000
You

08:02.000 --> 08:04.000
You

08:04.000 --> 08:06.000
You

08:06.000 --> 08:08.000
You

08:08.000 --> 08:10.000
You

08:10.000 --> 08:12.000
You

08:12.000 --> 08:14.000
You

08:14.000 --> 08:16.000
You

08:16.000 --> 08:18.000
You

08:18.000 --> 08:20.000
You

08:20.000 --> 08:22.000
You

08:22.000 --> 08:24.000
You

08:24.000 --> 08:26.000
You

08:26.000 --> 08:28.000
You

08:28.000 --> 08:30.000
You

08:30.000 --> 08:32.000
You

08:32.000 --> 08:34.000
You

08:34.000 --> 08:36.000
You

08:36.000 --> 08:38.000
You

08:38.000 --> 08:40.000
You

08:40.000 --> 08:42.000
You

08:42.000 --> 08:44.000
You

08:44.000 --> 08:46.000
You

08:46.000 --> 08:48.000
You

08:48.000 --> 08:50.000
You

08:50.000 --> 08:52.000
You

08:52.000 --> 08:54.000
You

08:56.000 --> 08:58.000
You

08:58.000 --> 09:00.000
You

09:00.000 --> 09:02.000
You

09:02.000 --> 09:04.000
You

09:04.000 --> 09:06.000
You

09:06.000 --> 09:08.000
You

09:08.000 --> 09:10.000
You

09:10.000 --> 09:12.000
You

09:12.000 --> 09:14.000
You

09:14.000 --> 09:16.000
You

09:16.000 --> 09:18.000
You

09:18.000 --> 09:20.000
You

09:20.000 --> 09:22.000
You

09:24.000 --> 09:26.000
You

09:26.000 --> 09:28.000
You

09:28.000 --> 09:30.000
You

09:30.000 --> 09:32.000
You

09:32.000 --> 09:34.000
You

09:34.000 --> 09:36.000
You

09:36.000 --> 09:38.000
You

09:38.000 --> 09:40.000
You

09:40.000 --> 09:42.000
You

09:42.000 --> 09:44.000
You

09:44.000 --> 09:46.000
You

09:46.000 --> 09:48.000
You

09:48.000 --> 09:50.000
You

09:52.000 --> 09:54.000
You

09:54.000 --> 09:56.000
You

09:56.000 --> 09:58.000
You

09:58.000 --> 10:00.000
You

10:00.000 --> 10:02.000
You

10:02.000 --> 10:04.000
You

10:04.000 --> 10:06.000
You

10:06.000 --> 10:08.000
You

10:08.000 --> 10:10.000
You

10:10.000 --> 10:12.000
You

10:12.000 --> 10:14.000
You

10:14.000 --> 10:16.000
You

10:16.000 --> 10:18.000
You

10:20.000 --> 10:22.000
You

10:22.000 --> 10:24.000
You

10:24.000 --> 10:26.000
You

10:26.000 --> 10:28.000
You

10:28.000 --> 10:30.000
You

10:30.000 --> 10:32.000
You

10:32.000 --> 10:34.000
You

10:34.000 --> 10:36.000
You

10:36.000 --> 10:38.000
You

10:38.000 --> 10:40.000
You

10:40.000 --> 10:42.000
You

10:42.000 --> 10:44.000
You

10:44.000 --> 10:46.000
You

10:48.000 --> 10:50.000
You

10:50.000 --> 10:52.000
You

10:52.000 --> 10:54.000
You

10:54.000 --> 10:56.000
You

10:56.000 --> 10:58.000
You

10:58.000 --> 11:00.000
You

11:00.000 --> 11:02.000
You

11:02.000 --> 11:04.000
You

11:04.000 --> 11:06.000
You

11:06.000 --> 11:08.000
You

11:08.000 --> 11:10.000
You

11:10.000 --> 11:12.000
You

11:12.000 --> 11:14.000
You

11:16.000 --> 11:18.000
You

11:18.000 --> 11:20.000
You

11:20.000 --> 11:22.000
You

11:22.000 --> 11:24.000
You

11:24.000 --> 11:26.000
You

11:26.000 --> 11:28.000
You

11:28.000 --> 11:30.000
You

11:30.000 --> 11:32.000
You

11:32.000 --> 11:34.000
You

11:34.000 --> 11:36.000
You

11:36.000 --> 11:38.000
You

11:38.000 --> 11:40.000
You

11:40.000 --> 11:42.000
You

11:44.000 --> 11:46.000
You

11:46.000 --> 11:48.000
You

11:48.000 --> 11:50.000
You

11:50.000 --> 11:52.000
You

11:52.000 --> 11:54.000
You

11:54.000 --> 11:56.000
You

11:56.000 --> 11:58.000
You

11:58.000 --> 12:00.000
You

12:00.000 --> 12:02.000
You

12:02.000 --> 12:04.000
You

12:04.000 --> 12:06.000
You

12:06.000 --> 12:08.000
You

12:08.000 --> 12:12.000
You

12:12.000 --> 12:14.000
You

12:14.000 --> 12:16.000
You

12:16.000 --> 12:18.000
You

12:18.000 --> 12:28.000
You

12:28.000 --> 12:32.000
You

12:32.000 --> 12:34.000
You

12:34.000 --> 12:44.000
So I'm so sorry about this. I didn't even remember. So how do I do this I don't know how to put it in?

12:44.000 --> 12:46.000
Yeah.

12:46.000 --> 12:48.000
Oh, okay.

12:54.000 --> 13:00.000
Mine is 5 minutes. Sorry. Sorry, this is my fault.

13:00.000 --> 13:03.000
The clip is supposed to be on the left of him.

13:03.000 --> 13:05.000
Yeah, it's pretty tight.

13:05.000 --> 13:06.000
Yeah.

13:06.000 --> 13:07.000
Okay.

13:07.000 --> 13:10.000
I hope that can you please be honest.

13:10.000 --> 13:11.000
Yeah, I'm going to hold this one.

13:11.000 --> 13:12.000
All right.

13:12.000 --> 13:15.000
All right, boys.

13:15.000 --> 13:20.000
So it had one global file tree rooted as lash.

13:20.000 --> 13:24.000
Most of it was just files.

13:24.000 --> 13:27.000
Well, yeah, there we go.

13:27.000 --> 13:29.000
Most of it was just files, actual files.

13:29.000 --> 13:33.000
Some of it was directories.

13:33.000 --> 13:39.000
Others were devices, so we had devices being represented as files like terrenals,

13:39.000 --> 13:43.000
hard drives and line printers.

13:43.000 --> 13:49.000
Some of them were programs that were stored in slash bin.

13:49.000 --> 13:54.000
What am I doing here?

13:54.000 --> 14:00.000
And when you want to run one of these programs because of the process.

14:00.000 --> 14:03.000
Process can copy itself.

14:03.000 --> 14:06.000
It replaces itself with another process.

14:07.000 --> 14:14.000
It can send numeric signals to other processes to indicate specific events.

14:14.000 --> 14:17.000
For example, I'm killing this one right now.

14:17.000 --> 14:24.000
Besides opening reading writing, you could use the device specific control call.

14:24.000 --> 14:27.000
And you would run programs using the shell.

14:27.000 --> 14:29.000
This is an example over there.

14:29.000 --> 14:33.000
The operating system did not define any file formats.

14:33.000 --> 14:38.000
So it was the program's responsibility to know what you do with the data in a file.

14:38.000 --> 14:44.000
Therefore, you could make scripts by starting a sequence of commands in a file.

14:44.000 --> 14:47.000
And ask the shell to execute it.

14:47.000 --> 14:53.000
Now, there you go.

14:53.000 --> 15:00.000
To build programs, developers would create dependency rules in a make file and run make.

15:00.000 --> 15:08.000
Because everything was organized in a file tree, it became unanimous with unix that everything was a file.

15:08.000 --> 15:14.000
To this day, version 7 still serves as the foundation to modern unix-like operating systems,

15:14.000 --> 15:19.000
for example like Linux, Android, iOS, and Mac OS.

15:19.000 --> 15:23.000
However, things were changing very fast.

15:24.000 --> 15:27.000
Ethernet technology starts to be commercialized in 1980.

15:27.000 --> 15:32.000
And it becomes obvious that was an immediate need to start connecting machines between each other.

15:32.000 --> 15:35.000
But unix wasn't made for that.

15:35.000 --> 15:38.000
Computers were getting faster and memory was becoming cheaper.

15:38.000 --> 15:41.000
And graphical terms started to become viable.

15:41.000 --> 15:45.000
Like the Blit Terminal built by Rob Pike in 1982.

15:45.000 --> 15:47.000
It looked like something like this.

15:48.000 --> 15:53.000
It was, in fact, so early that people didn't even know what a mouse was.

15:53.000 --> 16:00.000
And I did, but make this BNG index 16 to make it easier for me to download the file.

16:00.000 --> 16:03.000
Oh, this is the run computer.

16:03.000 --> 16:04.000
All right.

16:04.000 --> 16:10.000
So, I am in the run computer again.

16:10.000 --> 16:13.000
All right.

16:13.000 --> 16:16.000
Unix can now render graphics.

16:16.000 --> 16:23.000
But now, terminals were no longer speaking just next.

16:23.000 --> 16:30.000
This latch of the development of a window manager, which doesn't want to show up right now.

16:30.000 --> 16:32.000
It should thank you.

16:32.000 --> 16:33.000
Thank you.

16:33.000 --> 16:35.000
Let me delete this guy.

16:35.000 --> 16:38.000
There you go.

16:38.000 --> 16:41.000
It looked like something like this, right?

16:41.000 --> 16:44.000
I think that some of you are familiar with it.

16:44.000 --> 16:49.000
The way you would use it would be to hold the right mouse button.

16:49.000 --> 16:55.000
And many would show up showing all of the options that you could use to manage the layers.

16:55.000 --> 17:00.000
You know, back then layers windows were not a expression used.

17:00.000 --> 17:05.000
It was actually called layers.

17:05.000 --> 17:08.000
So, you could open a terminal like that.

17:08.000 --> 17:12.000
You would hold the mouse button 3, which would be this one.

17:12.000 --> 17:19.000
You would create a window, the size you want it.

17:19.000 --> 17:27.000
And now, we also had this graphical innovation led to the development of new graphical tools.

17:27.000 --> 17:33.000
For example, the text editor Jim, which looked like something like this.

17:33.000 --> 17:38.000
Now,

17:39.000 --> 17:45.000
you have the ability to use multiple shells at the same time on the same screen.

17:45.000 --> 17:51.000
We take that for granted now, but it foreshadowed how modern window systems would work.

17:51.000 --> 17:59.000
It enabled the development of new graphical tools, just like the one I showed you.

17:59.000 --> 18:01.000
I am very confused about your computers.

18:01.000 --> 18:07.000
I should have not done that.

18:08.000 --> 18:11.000
So, in 1983, BSD4.2 is released.

18:11.000 --> 18:14.000
It comes with a socket API.

18:14.000 --> 18:26.000
And this was our solution to networking.

18:26.000 --> 18:31.000
And to this day, it is the D facto Unix networking API.

18:31.000 --> 18:35.000
However, that solution introduced problems.

18:35.000 --> 18:37.000
You should be simple.

18:37.000 --> 18:43.000
Now, instead of one IOModel, the kernel grew separate paths for terminals, pipes, and networking.

18:43.000 --> 18:47.000
It worked, but the elegance was gone.

18:47.000 --> 18:52.000
Now, as you all know, in Unix, everything is a file.

18:52.000 --> 19:00.000
So, here's the list of things that are not files in Unix.

19:01.000 --> 19:05.000
So, in 1984, the year, not the documentary, by the way,

19:05.000 --> 19:10.000
the engineers at Bell Labs started developing their own version of networking.

19:10.000 --> 19:18.000
So, instead of adding new kernel objects for networking, they worked on streams.

19:18.000 --> 19:24.000
This allowed a user program to interact with a device.

19:24.000 --> 19:29.000
And therefore, it was possible to talk to other computers.

19:29.000 --> 19:30.000
Good.

19:30.000 --> 19:32.000
The machines can connect to each other.

19:32.000 --> 19:34.000
Now, what?

19:34.000 --> 19:38.000
Well, the question is, how do you make software network aware?

19:38.000 --> 19:42.000
How do we rewrite all of our old software to make them network aware?

19:42.000 --> 19:45.000
The answer is, you don't.

19:45.000 --> 19:47.000
You create a new directory.

19:47.000 --> 19:49.000
You name your machines.

19:49.000 --> 19:52.000
And you access the file through it.

19:52.000 --> 19:56.000
And now, copying a file is just copying a file.

19:56.000 --> 20:00.000
You copy a file between machines is no different from a local copy.

20:00.000 --> 20:04.000
And because these machines were just names in the file system,

20:04.000 --> 20:10.000
that meant you could change them together to access files from another server

20:10.000 --> 20:13.000
that you didn't have access to.

20:13.000 --> 20:14.000
Now, mind you.

20:14.000 --> 20:18.000
This was five years before an FS was released.

20:18.000 --> 20:19.000
Okay.

20:19.000 --> 20:23.000
So, we can name machines and put them in the file system.

20:23.000 --> 20:27.000
But what else can we put in the file system?

20:27.000 --> 20:29.000
What about things inside the machine?

20:29.000 --> 20:32.000
What about processes for example?

20:32.000 --> 20:35.000
The answer is surprisingly the same.

20:35.000 --> 20:39.000
We just name the processes and find a way to put them in.

20:39.000 --> 20:42.000
And find a directory you should put them in there.

20:42.000 --> 20:44.000
But wait a minute.

20:44.000 --> 20:45.000
A process file system.

20:45.000 --> 20:47.000
I've already seen that somewhere.

20:47.000 --> 20:50.000
Isn't that a little bit you complicated?

20:51.000 --> 20:54.000
Isn't that very not unix-like to have something like this?

20:54.000 --> 20:58.000
Well, if you're thinking about the unix file system,

20:58.000 --> 21:01.000
then yes, that's definitely you complicated.

21:01.000 --> 21:03.000
But that was not the case for unix.

21:03.000 --> 21:08.000
Back then, we only had one file per process.

21:08.000 --> 21:10.000
And I don't know how I'm going to the next slide,

21:10.000 --> 21:12.000
but I'm going to accept it.

21:20.000 --> 21:30.000
So, now you could write a process inspector.

21:30.000 --> 21:34.000
And you didn't need any special system calls for it.

21:34.000 --> 21:38.000
You could just use standard file system operations.

21:38.000 --> 21:42.000
Now, for the very first time, we have a synthetic file system

21:42.000 --> 21:46.000
that doesn't represent anything physical in the computer.

21:46.000 --> 21:51.000
And this is very important to understand, because otherwise,

21:51.000 --> 21:59.000
it's going to be difficult to understand plan 9 later down the line.

21:59.000 --> 22:06.000
So, whereas previously files represented only physical things,

22:06.000 --> 22:09.000
for example, like a real file on a hard drive.

22:09.000 --> 22:12.000
Now, we have a completely synthetic file system

22:12.000 --> 22:15.000
that doesn't represent anything physically.

22:15.000 --> 22:18.000
So, what comes after number 7?

22:18.000 --> 22:20.000
Number 8, unix version 8 is released.

22:20.000 --> 22:23.000
It comes with networking graphics,

22:23.000 --> 22:29.000
the news, lashing, file system, and the lashing product file system.

22:29.000 --> 22:35.000
Now, because terminals were now graphical, we have a problem.

22:35.000 --> 22:39.000
You see, the file that is used to represent the terminal

22:40.000 --> 22:46.000
was made with the intention of having only one program at a time accessing it.

22:46.000 --> 22:53.000
So, now we had multiple shells at the same time trying to access this file.

22:53.000 --> 22:55.000
So, how do we solve that problem?

22:55.000 --> 22:59.000
The key is to identify the root of the problem.

22:59.000 --> 23:02.000
So, the problem happens when we try to open the file.

23:02.000 --> 23:08.000
So, what if we could make it so that only one program would open this file at a time,

23:09.000 --> 23:13.000
and the other ones would be transferred to a virtual file.

23:13.000 --> 23:17.000
Now, the way you would do that with, you know, the BSDs,

23:17.000 --> 23:20.000
they decided to make a special file for it.

23:20.000 --> 23:22.000
You know, a special kernel case for it.

23:22.000 --> 23:25.000
The people at Bell Lab didn't really want to do this.

23:25.000 --> 23:30.000
They knew that this would not be in the long term a good solution.

23:30.000 --> 23:34.000
So, they decided to think about something that would mess with the namespace itself.

23:34.000 --> 23:39.000
So, they thought about making mounts with strings.

23:39.000 --> 23:43.000
So, now you could take a string and mount it directly to a file.

23:43.000 --> 23:48.000
This would allow you to create a program that would open the terminal.

23:48.000 --> 23:52.000
We would have only one program reading and writing to the terminal.

23:52.000 --> 23:58.000
And whatever programs that try to access it later after it mounted itself as a terminal

23:59.000 --> 24:04.000
would become, would be talking to this program.

24:04.000 --> 24:07.000
A program like Vismon for example.

24:07.000 --> 24:13.000
It is used to display system time and also, you know, incoming email.

24:13.000 --> 24:30.000
So, at this point, a pattern should be obvious.

24:30.000 --> 24:35.000
Instead of trying to create a new object something external to the file system.

24:35.000 --> 24:42.000
Whenever unix engineers find a problem, they try to fit it inside the file system.

24:42.000 --> 24:49.000
Now, what people don't understand is that it's never being about files for the file's sake.

24:49.000 --> 24:56.000
You know, what you really want is a single interface that is uniform across your entire system.

24:56.000 --> 25:04.000
Because the moment you want to add a new technology, if you are able to incorporate it into this interface,

25:04.000 --> 25:09.000
every previous software that you have ever written is going to automatically support it.

25:09.000 --> 25:14.000
So, you don't need to backtrack your work and start writing things again.

25:14.000 --> 25:23.000
Now, since operating systems need to represent files anyway, why not try to use that interface to use it to represent everything?

25:23.000 --> 25:29.000
I mean, how else are you going to represent files if not in a hierarchical file free?

25:29.000 --> 25:36.000
So, this is the true spirit of everything being a file.

25:36.000 --> 25:44.000
And it is with this spirit that then is rich in Dave Prasoto, brought to an networking on unix.

25:44.000 --> 25:49.000
So, by the mid-80s, we already had several services running on our networks,

25:49.000 --> 25:53.000
and they tried to bring those to the file system.

25:53.000 --> 25:59.000
Since Mount had been extended, we could now have a file connected to a stream.

25:59.000 --> 26:03.000
Now, we can create a directory and store all those connections in it.

26:04.000 --> 26:10.000
We're going to call it the connection server, CS down there.

26:10.000 --> 26:13.000
Now, some files stuck directly to the server.

26:13.000 --> 26:18.000
Other files act as a middleman for more complicated protocols.

26:18.000 --> 26:24.000
So, for example, if you wanted to dial a phone, you would call for the phone file,

26:24.000 --> 26:27.000
and then you would provide the phone that you want to talk to.

26:27.000 --> 26:32.000
If you wanted to talk to an email server, you would ask for the TCP file,

26:32.000 --> 26:36.000
and then you provide the address and the port.

26:36.000 --> 26:40.000
And then you start sending the SMTP messages by yourself.

26:40.000 --> 26:43.000
Not by yourself, you're client.

26:43.000 --> 26:53.000
So, everything was being done with file operations.

26:53.000 --> 26:58.000
You didn't need an extra system, call you didn't need to create a new kernel driver

26:58.000 --> 27:01.000
for the TCP for the IP stack.

27:01.000 --> 27:06.000
So, moving away from network for a little bit.

27:06.000 --> 27:12.000
By this time, the text editor Jim was already showing a little bit of its limitations.

27:12.000 --> 27:18.000
He was a cut-and-paste text editor, and it was limited to the blip thermal.

27:18.000 --> 27:22.000
Now, Rob Pike started to write the text editor Sam.

27:22.000 --> 27:26.000
Both of these text editors tried to solve the same problem space.

27:26.000 --> 27:30.000
How do you edit large files over a very low link?

27:30.000 --> 27:35.000
Now, the way Sam went about this problem was to create a client server model,

27:35.000 --> 27:41.000
where the server would hold the file, and the client would just send commands to edit those files.

27:41.000 --> 27:44.000
It worked really well.

27:44.000 --> 27:53.000
And for that reason, Sam was designed with a more robust command language.

27:53.000 --> 27:58.000
It was a visual text editor, but it's true power state in the command language that it possessed.

27:58.000 --> 28:02.000
So, as you can see, this is an example of the same text editor.

28:02.000 --> 28:05.000
We have a blue window over there where you can resize, move around.

28:05.000 --> 28:07.000
You put your commands in there.

28:07.000 --> 28:10.000
You can create as many yellow windows as you want.

28:10.000 --> 28:13.000
This is how many files you can edit at a time.

28:13.000 --> 28:22.000
There you go.

28:22.000 --> 28:25.000
I have made a mistake.

28:25.000 --> 28:39.000
There you go.

28:39.000 --> 28:41.000
So, what comes after?

28:41.000 --> 28:42.000
That's right.

28:42.000 --> 28:43.000
Version 9.

28:43.000 --> 28:54.000
Unix's version 9 is related in 1986 with mouse streams, the connection server file system, and the text editor Sam.

28:54.000 --> 29:02.000
Now, earlier the Unix had a culture.

29:02.000 --> 29:07.000
At this point, the computer world was vastly different from when Unix was conceived.

29:07.000 --> 29:15.000
For that reason, a lot of things that had been put on the system were not made for them.

29:15.000 --> 29:17.000
Unix had become big and fragmented.

29:17.000 --> 29:18.000
This was bad.

29:18.000 --> 29:24.000
You see, everyone had access to the same file system in the same machine.

29:24.000 --> 29:30.000
This local interaction created local community, a fellowship that built the foundations of Unix.

29:31.000 --> 29:39.000
But now, Bell Labs had hundreds of Unix installations across the laboratory.

29:39.000 --> 29:45.000
And each one with their own disk, their own users, and their own configurations, and their own quirks.

29:45.000 --> 29:50.000
But how do we preserve this culture that was built on locality?

29:50.000 --> 29:55.000
When systems were clearly becoming more distributed and isolated.

29:56.000 --> 30:04.000
If we go back and think about it, the computer in early Unix, we didn't really have any network.

30:04.000 --> 30:06.000
Because there was no need to have any.

30:06.000 --> 30:10.000
In a sense, the network was the computer itself.

30:10.000 --> 30:12.000
So, that's it.

30:12.000 --> 30:18.000
That's the idea that drove the development of the new operating system that Bell Labs would create.

30:18.000 --> 30:23.000
Now, instead of treating the network as an amalgamation of individual Unix machines,

30:23.000 --> 30:30.000
why don't we create a network that is the computer itself?

30:30.000 --> 30:33.000
But Unix would not be abandoned yet.

30:33.000 --> 30:36.000
It would be developing parallel with both versions.

30:36.000 --> 30:44.000
So, the first design decision was to delegate the different parts of the operating system to different physical machines.

30:44.000 --> 30:50.000
So, the operating system was divided into three independent parts.

30:51.000 --> 30:53.000
First, we had the file server.

30:53.000 --> 30:58.000
It only did one thing, which was to serve files using a protocol, which I'll get into detail later.

30:58.000 --> 31:01.000
It could not execute any commands.

31:01.000 --> 31:08.000
Next, we had the CPU server.

31:08.000 --> 31:18.000
There we go.

31:18.000 --> 31:23.000
Basically, you would use it to run commands remotely on your machines.

31:23.000 --> 31:25.000
It did not have any disks.

31:25.000 --> 31:29.000
It's kernel did not even have drivers for audio, keyboard, and stuff like that.

31:29.000 --> 31:35.000
It would just be used as a remote machine where your turn-lose, which are the third type of computer, would connect to.

31:35.000 --> 31:39.000
Now, turn-lose were a little bit more complete than the CPU servers.

31:39.000 --> 31:43.000
They could do the same thing that could execute commands, not remotely though,

31:43.000 --> 31:46.000
but they were not as powerful as a CPU server.

31:46.000 --> 31:51.000
So, in essence, what you want to do is use the terminal to do lightweight work,

31:51.000 --> 31:55.000
and when you need to compile something heavy, you would connect to the CPU server.

31:55.000 --> 32:02.000
Now, when developing the new operating system, the team at Bell Labs followed two principles.

32:02.000 --> 32:12.000
First, we're going to have a private view of the name space for each and every individual process.

32:13.000 --> 32:24.000
The second principle is that everything in this operating system is going to be done with a single protocol.

32:24.000 --> 32:27.000
Now, let's talk about this last one first.

32:27.000 --> 32:32.000
In order to create a network service, we need to write true programs of client and a server.

32:32.000 --> 32:37.000
Both of them need to write network code, and we need to design a protocol for them to speed.

32:37.000 --> 32:40.000
We have to do this every single time.

32:41.000 --> 32:46.000
Now, what if we define a new interprocess protocol for all those services?

32:46.000 --> 32:52.000
And what if we use that protocol for local machine services as well?

32:52.000 --> 33:00.000
That means that we would be able to have a significant amount of service with only a single client,

33:00.000 --> 33:07.000
and everything would be remote file, it wouldn't matter if the server was a remote file server or a local file server.

33:07.000 --> 33:14.000
That is the conception of the 9-P protocol.

33:14.000 --> 33:16.000
Here's the current 9-P protocol.

33:16.000 --> 33:21.000
It's pretty simple. I can print it in the entire screen.

33:21.000 --> 33:31.000
So, having local services, talk the same protocol, which is a file system protocol, as remote services has a very big implication.

33:31.000 --> 33:38.000
If we can design our device interfaces as file systems, we can share the devices around the network.

33:38.000 --> 33:43.000
This is how you would make a CPU server, for example, play audio on a terminal.

33:43.000 --> 33:49.000
Even though there was not any drivers or special code for that.

33:49.000 --> 33:52.000
Remember, this is all possible.

33:52.000 --> 33:58.000
Due to the fact that we have a single uniform interface to our system.

33:58.000 --> 34:03.000
Now, let's get back to our first principle.

34:03.000 --> 34:08.000
The go behind private namespaces, what should give power and flexibility to users.

34:08.000 --> 34:14.000
If they can build their own private spaces, they don't have to wait for the system administrator to give them permission,

34:14.000 --> 34:20.000
and they don't have to worry about affecting other users.

34:20.000 --> 34:30.000
But, in order to manipulate namespaces, we need to understand what the concept of a mount, a bind, and a union directory are.

34:30.000 --> 34:34.000
So, amount to something that you can straight up from unix.

34:34.000 --> 34:42.000
You just have a device or a service that you want to mount, and you provide a mount point for it.

34:43.000 --> 34:53.000
Bind is something similar, except that it takes an existing point in your tree, and you'll buy it somewhere else.

34:53.000 --> 34:58.000
Now, both points are referring to the same place.

34:58.000 --> 35:07.000
And a union directory takes the same idea as the mount, except that they don't replace one with the other.

35:07.000 --> 35:18.000
They join their files together, and notice how the original files of the directory are still there, but now we have two profiles.

35:18.000 --> 35:22.000
This is something that Unix would never allow.

35:22.000 --> 35:30.000
When you join two directors together, you can specify which one comes before and which one comes after.

35:30.000 --> 35:35.000
And this is going to determine what profile actually gets read.

35:36.000 --> 35:40.000
Now, this might feel like you're linking files and directories, but that's not the case.

35:40.000 --> 35:47.000
This is a virtual view that the kernel is showing to you, and this is not supposed to happen right now.

35:47.000 --> 35:52.000
I don't know what happened.

35:52.000 --> 35:58.000
Well, we're going to be without the computer turned off.

35:58.000 --> 36:00.000
I was just going to make.

36:00.000 --> 36:03.000
All right, so we're going to wait for the computer to turn on.

36:03.000 --> 36:10.000
And since I already went through the heavy stuff, I am going to make a demonstration of what namespaces are,

36:10.000 --> 36:18.000
because I believe that it is kind of hard to understand the purpose and what you can do with a namespace,

36:18.000 --> 36:21.000
if you don't see it being used at the time.

36:21.000 --> 36:24.000
So let's just wait for a while.

36:25.000 --> 36:32.000
I'm sorry, what do you say?

36:32.000 --> 36:46.000
So when you do a union mount, you can tell the kernel if the director is going to come before or after the other one that was already there.

36:46.000 --> 36:51.000
So if it is going to come before, it is going to take priority over the directorie that was there.

36:51.000 --> 36:54.000
So this is the profile that is going to be used.

36:54.000 --> 36:58.000
However, if you tell it that it comes after, it has less priority.

36:58.000 --> 37:01.000
Does that make sense?

37:01.000 --> 37:03.000
Yeah, yeah.

37:03.000 --> 37:07.000
So actually, it's already 9.30, 6.

37:07.000 --> 37:10.000
So this is pretty much the time I had.

37:10.000 --> 37:14.000
I apologize for the technical delays.

37:14.000 --> 37:16.000
Yeah, that's pretty much it, guys.

37:16.000 --> 37:18.000
Thank you very much.

37:21.000 --> 37:24.000
Thank you.