Name: 待つ方法 - マックス・グッドハート｜JSConf Hawaii 2020 (How to Wait - Max Goodhart | JSConf Hawaii 2020)
Uploaded: 2021-01-14T10:24:44.000Z
Duration: 24 min 10 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

So our story begins with a humble, await patch.

These two lines of code making http request.

Wait for a response and print out the status code.

While this code is waiting, a cascade of activity is taking place in your JavaScript runtime, your operating system and your hardware.

In this talk, we're going to look at what happens between these two lines of code and what waiting can teach us about software design.

Why do I need to think about this stuff while riding JavaScript code and more so 100 feet from a beautiful beach?

I've wrestled with motivated myself to dig into these lower level details before, and I'd like to offer to motivating ideas, maybe enough to get you over the postal on chump first.

These aerial systems we use every day while writing JavaScript code understanding Systems teaches us examples of how problems can be solved, and most importantly, it gives us the opportunity to identify patterns that guide how new systems can be built.

Second, computers are really complex and powerful, and that can sometimes make them feel magical.

But much of that complexity comes from layer upon layer of simple solutions to simple problems.

As JavaScript programmers, these problems a relatable to us because we live in a synchronous world.

By understanding the problems the lower layers solved, we can gain a greater confidence in the face of this complexity.

As you'll see, a lot of that complexity serves a simple task.

I'm visiting from San Francisco and I'm a developer.

On the first Wednesday of every month, I co organized a local meet up called Waffle Jazz.

I worked with a team of some amazingly talented people I've learned a ton from, and if you ever passing through, I'd invite you to come join us.

Or come give a talk to talk to me after the after this, So back to waiting.

Waiting's kind of a strange concept, and it was difficult for me to like, nail down in writing this talk because we rarely do it.

We spend a little time waiting is humanly possible.

If I ask you to wait for something you're gonna switch to something else to D'oh.

So our use of the word wait is usually in the context of a set of instructions to do something.

And when there's some dependency in that process, we have to wait for our progress into the Hill of Progress is no longer blocked, by the way.

Thanks, Andres, for the cute spaghetti image on the slide.

Good recipes take advantage of the idle time by inter leaving processes while you're blocked on one thing you can start on another.

This is a great analogy to how computers multi task except computers have thousands of different processes They're carrying out at any given time.

And unlike most recipes, the order in which things could happen is unpredictable.

As programmers, we like to think in terms of sequential steps because it makes our code simple to reason about you making http request.

Then you wait for the response, then you print out the status.

This is why a single weight style program was so useful.

It lets us express steps in a clear and then your order waiting makes that possible.

It's the glue that allows us to express a Siri's of separate events linearly.

But when we say to wait, we expect that the human or computer on the other side is gonna find something else to do.

In the meantime, this is a behavior we have to design into our computers.

Let's dive into the mechanisms of how this works.

Starting with a simple microprocessor for simplicity, I'm gonna focus on a single core CPU.

That means it can only do one thing at a time.

Richest talk, which is immediately after this that around 1 30 is gonna cover threading, which takes advantage of modern si, pues having multiple concurrent course.

So back to the CPU, we're gonna start with a simple sub component called the clock the clock.

Periodically, pulse is an electrical signal on and off.

In modern si, pues, we measure the frequency of the clock and gigahertz, meaning the clock is oscillating billions of times per second.

From a reductionist point of view, every single thing a computer does or waits for, begins at one clock cycle and ends with another.

By programming a microprocessor, we can implement a simple kind of waiting called busy waiting.

This is a loop where each cycle we checked the condition we're waiting for.

If you want to do other things while we wait, though, we kind of have to intersperse them in this wait Luke.

And that increases the time between checks as a number of things we want to wait for increases.

This loop becomes less and less efficient because you're checking more things.

Signal the CPU when something happens, such as your network interface receiving data, keyboard key being pressed or timer elapsing.

When a processor receives an interrupt, it pauses.

What's currently running saves the execution ST and switches to different code called interrupt Handler.

The interrupt handler takes any immediate actions necessary and then determines how to proceed forward.

The code that implements interrupt handlers is part of your operating system.

The OS makes it possible to write higher level programs that don't have to worry about interrupt handling and communication with hardware.

The OS governs switching between which programs are running so that multiple programs can take turns sharing a CPU.

The operating system also provides a P eyes for Io called system calls for things like writing to files and sending packets in limits.

Most kinds of Io's representative operations on streams of bites.

Here's a couple examples on screen I owe takes time, though you know discs take time to perform operations.

Network devices take time to transfer data.

When a program is performing, I owe it often wants to wait until that Io is completed.

So a simple model for this is called blocking Io.

While the program's waiting for an I O operation, we say that the calling program blocks until that IO completes.

Once the OS receives an interrupt that the eye is completed, the process is queued to be resumed by the scheduler.

While that process is blocked, the OS scheduler can run something else.

In the meantime, simple blocking Io system calls only wait for one thing at a time, though.

If we want to wait for multiple things, we're gonna need some more tools.

Operating systems provide non blocking versions of many Io calls for this.

When you open a file or network connection, the OS returns a number that identifies the stream called a file descriptor you can use that f d to reference the stream and other system calls.

So, in this example, if an operation would block the non blocking, read returns an error instead.

If we get an error indicating the reed would block, that means there's no late data left in the buffer for us to read.

So instead, we can find something else to do instead of pausing execution.

This leaves our process running, so we get to decide what to do instead of blocking non blocking.

Io calls can also be used to wait for multiple things at a time.

For example, we can loop over a set of file descriptors and try to read from each of them.

If there's no data to read, we continue on to the next file descriptor.

However, now we're back to essentially busy waiting.

What we really want to do is block on a set of things that could happen.

Resuming when any one of them does operating systems provide event based system calls for this.

Select has given three sets of file descriptors, one for each kind of event streams ready to read, streams ready to write and streams with errors.

The select call then blocks until an event happens or a specified amount of time elapses.

It then returns to the programmer, which file descriptors could be read to written two or have errors.

So here's a really simplified example of how select works we pass.

A set of file descriptors were interested in reading from, and then it blocks until one or many of them becomes readable when select returns.

It gives us the list of files that now of data available, and we can loop over them and read from them without blocking.

Each operating system provides a slightly different modern implementation of a venture of an IO, though Lennox this is called a pole Mac OS and BSD F K Q.

And Windows has OCP, too right cross platform software.

字幕リスト動画再生

待つ方法 - マックス・グッドハート｜JSConf Hawaii 2020 (How to Wait - Max Goodhart | JSConf Hawaii 2020)

process

multiple

accomplish

script