
Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로 
보호되어 있습니다. 
MIT OCW(무료공개강좌) 는 계속해서 고품질의 교육자원을  
무료로 제공함으로써 여러분을 도와줄 것입니다. 
추가적인 MIT 코스의 자료를 보거나
기부하시려면 ocw.mit.edu을 
방문해주세요.
제가 지난 강의들에서 했던 것처럼, 
우리가 무엇을 하고 있는지에 대한 단계를 세우겠습니다, 그래서 우리는 
우리가 오늘 무엇을 할 것인지에 대해 이야기 하기 위해 그 단계를 사용할 수 있습니다. 
지금까지, 우리는 우리 언어에서 다음의 것들을 가집니다. 
네, 우리는 대입을 가집니다.  
우리는 조건문을 가집니다. 
우리는 입력/출력을 가집니다. 
그리고 우리는 루프 구조를 가집니다. 

English: 
ANNOUNCER: Open content is
provided under creative
commons license.
Your support will help MIT
OpenCourseWare continue to
offer high-quality educational
resources for free.
To make a donation, or view
additional materials from
hundreds of MIT courses, visit
MIT OpenCourseWare at
ocw.mit.edu .
PROFESSOR ERIC GRIMSON: As
I've done in the previous
lectures, let me set the stage
for what we've been doing, so
we can use that to talk about
what we're going to do today.
So far, we have the following
in our language.
Right, we have assignment.
We have conditionals.
We have input/output.
And we have looping
constructs.

Korean: 
이것들은 FOR 와 WHILE 루프 같은 것들 입니다. 
그리고 물론 우리는 그것과 함께 가는 데이터를 가집니다.
우리가 지난 시간에 말한 것 중 하나는, 그것들의 세트를 가지고, 
값을 주는 능력 이었어요 – 미안해요, 값에게 이름을 주기 위해서입니다 – 
결정을 하는 능력, 그 함수로써 루프를 도는 능력, 
무엇을 입력하고 출력하는 능력이었습니다. 
우리는 그것이 사실 우리에게 우리가 말한 Turing-complete 라는 
언어를 준다고 말했었습니다. 
그리고 영어에서, 그것은 이것이 어떤 프로그램을 
짤 만큼 충분하다는 것을 의미합니다. 
이제 그것은 약간 거짓말이에요 – 또는 사실 요즘의  
정치적인 논쟁, 약간 잘못 말한 것, 환상적인 단어에요 – 
그것은 기술적으로 맞습니다. 
그것은 우리가 어떤 프로그램을 짜도록 하기에 충분하지만 
우리가 어떤 프로그램을 쉽게 짜도록 하기엔 충분하지 않습니다.
그리고 저는 나쁜 농담을 했었죠, 지난 강의 마지막에요, 저는 동의할 것입니다, 
우리는 지금 멈추고 기말 시험까지 쭉 갈 수도 있어요, 
왜냐하면 이것이 여러분이 알아야 할 전부이니까요. 
핵심은, 네 이것은 출발하기에 충분하지만, 

English: 
These are things like
FOR and WHILE loops.
And of course we've got some
data to go with that.
One of the things we said last
time was, with that set of
things, the ability to give
values-- sorry, to give names
to values-- the ability to make
decisions, the ability to
loop as a function of that, the
ability get things in and
out, we said that that actually
gave us a language we
said was Turing-complete.
And that meant, in English, that
this was enough to write
any program.
Now that's a slight lie-- or
actually in these days of
political debates, a slight
misspeaking, a wonderful
word-- it is technically
correct.
It is enough to allow us to
write any program, but it's
not enough to allow us to easily
write any program.
And so I joked, badly, I'll
agree, at the end of last
lecture, that we can just stop
now, go straight to the final
exam, because this is all
you need to know.
The point is, yes it's enough to
start with, but we want to

Korean: 
우리는 이것에 우리가 문제를 잘 풀기 위한 것을 추가하길 원합니다. 
그리고 생각해 볼 것 중 하나는, 심지어 제가 그것 모두를 갖고 있다 하더라도, 
제가 무엇을 할 수 있는지에 대해 생각해 봅시다, 
제가 코드를 쓰고 싶다면요.  
지금, 여러분은 한 파일에 그것을 써야 합니다. 
그것은 명령문들의 긴 순서입니다, 그것은 시작에서 출발하고, 
쭉 가고, 약간 점프 할 수도 있지만, 
결과적으로 끝으로 갑니다. 
여러분이 이전 문제 세트를 이해 하는 것은 
괜찮습니다. 
10줄의 코드. 
20줄의 코드니까요. 
대신 여러분이 십만 줄, 
백만 줄의 코드를 쓴다고 상상해 보세요. 
여러분은 이 형태에서 그것을 쓰길 원하지 않습니다. 
좋아요, 그리고 여러분이 그것을 원하는 이유는, 
몇 가지가 있습니다. 
먼저, 그것은 모든 것이 어디 있는지, 
모든 것이 어디서 가는지 알아 내기 정말 어렵습니다. 
제가 옳은 곳에 있는지 확신하기 위해서요. 
1970년대의 저나 존만 이해할 수 있는 예전의 명령문들을 사용하기 위해, 
코드가 무엇인지, 
그것이 무엇을 만들려고 하는지
이해하는 것은 정말 어렵습니다. 
그리고 그것이 그 경우인 이유와 우리가 가지고 있지 않은 것은 

English: 
add things to this that let
us problem solve well.
And one of the things to think
about is, even though I've got
all of that, let's think about
what I could do, if I wanted
to write a piece of code.
Right now, you've got to
write it in one file.
It's a long sequence of
instructions, it starts at the
beginning, walks through, may
jump around a little bit, but
eventually comes down
at the end.
It's okay for the things you're
doing for the early
problem sets.
Ten lines of code.
Twenty lines of code.
Imagine instead, you're writing
code that's a hundred
thousand lines, a million
lines, of code.
You don't want to write
it in this form.
All right, and the reason you
don't want to do that is,
well, several.
First of all, it's really hard
to figure out where everything
is, where everything goes,
making sure I'm
in the right place.
To use an ancient expression
from the 1970's, which only
John and I will appreciate, it's
really hard to grok what
that code is doing, to
understand what it's trying to
make happen.
And the reason that that's the
case is, what we don't have,

Korean: 
두 가지 중요한 것입니다. 
우리는 decomposition(분해)가 없습니다, 그리고 우리는 추상적 개념이 없습니다. 
그리고 그것은 우리가 오늘 추가하려고 하는 것입니다. 
그래서 그것이 무엇을 의미하죠? 
그것들은 환상적인 용어들이에요. 
분해는 코드에 구조를 
두는 방법입니다. 
그것은 코드를 모듈로 나누는 방법입니다. 
모듈은 그들 스스로 이해하기 쉽습니다. 
우리가 다시 사용할 수 있는 모듈은 많은 곳에 있어요. 
모듈은 프로세스의 성분들을 분리합니다. 
모듈은 프로세스의 성분들을 분리합니다. 
그리고 추상화는 그것과 관련이 있는데, 추상화는 
우리가 자세한 내용을 숨기도록 합니다. 
그것은 우리가 무엇의 특정한 내용을 숨기도록 하고 
블랙 박스와 같은 computation 를 다룹니다. 
그리고 그 박스로, 정말로 기이한 작은 
블랙 박스처럼 행동 합니다. 
여러분은 입력을 하고, 그것은 여러분이 옳은 입력을 했는지를 말하는 계약을 가집니다. 
여러분은 구체적인 출력을 얻을 것입니다. 
그러나 여러분은 그 박스 내부가 무엇인지 
알 필요가 없습니다. 

English: 
are two important things.
We don't have decomposition, and
we don't have abstraction.
And that's what we're
going to add today.
So what does that mean?
Those are fancy terms.
Decomposition is a way of
putting structure
onto the code.
It's a way of breaking the
code up into modules.
Modules that makes sense
on their own.
Modules that we can reuse
in multiple places.
Modules that, if you
like, isolate
components of the process.
And abstraction is related to
that, abstraction is going to
let us suppress details.
It's going to let us bury away
the specifics of something,
and treat that computation
like a black box.
And by black box, I mean,
literally behaves like a
mysterious little black box.
You put some inputs in, it has
a contract that says if you
put the right kind of inputs
in you'll get a specific
output coming out, but you
don't have to know what's
inside of that box.

Korean: 
그리고 그 추상화는 정말 중요해요. 
다시, 제가 코드를 쓴다고 상상해 보세요. 
저는 그것을 사용하고 싶습니다, 저는 그 내부에서 사용하는 변수들이 무엇인지에 대해 
걱정하지 않아도 됩니다, 저는 코드에서 그것이 어디에 있는지에 대해 걱정하지 않아도 되요, 
저는 그것을 단지 추상화할 수 있어야 합니다.
저는 그것을 단지 추상화할 수 있어야 합니다.
그리고 그것은 우리가 오늘 추가하려는 두 가지 것입니다. 
이제, 그것을 하기 위한 우리의 매커니즘 – 
또는 적어도 하나의 매커니즘, 저는 오직 하나에 대해 말해서는 안됩니다 – 
그것을 하기 위한 한 매커니즘은 우리의 언어에 함수들을 추가하는 것이 될 것입니다. 
이제, 함수의 핵심은 그것이 이것들 둘 다를 제공하는 것 입니다. 
그래서 그것이 하는 첫 번째 것은, 
그것은 우리가 모듈들로 나누도록 합니다. 
그것들이 하려는 두 번째 것은 우리가 자세한 것을 숨기도록 하는 것입니다. 
그리고 본질적으로 그것이 하는 것은 함수들입니다. 
그리고 우리는 곧 많은 예들을 볼 것입니다, 
이 함수들은 우리에게 방법을 줍니다, 그것에 대해 생각하는 몇 가지 또는 하나의 방법을요, 그

English: 
And that abstraction is
really important.
Again, imagine if I'm a writing
a piece of code.
I want to just use it, I
shouldn't have to worry about
what variables I use inside of
it, I have shouldn't have to
worry about where that is in the
code, I should be able to
just abstract it away.
And that's what we want to add
today, are those two things.
Now, our mechanism for doing
that-- or at least one
mechanism, I shouldn't say the
only one-- one mechanism for
doing that is going to be to add
functions to our language.
Now, the point of a function is
that it's going to provide
both of these things, so the
first thing it's going to do
is, it's going to let us
break up into modules.
Second thing they're going to do
is let us suppress detail.
And in essence what that does
is, the functions, and we're
going to look at a bunch of
examples in a second, these
functions are going to give us
a way to, in some or in one

English: 
way of thinking about it is
to create new primitives.
And I'm going to put those in
quotes, it's a generalization.
What do I mean by that?
The idea of a function is, that
I'm going to capture a
common pattern of computation.
Computing square root.
I'm going to capture it in a
piece of code, I'm going to be
able to refer to it by a name,
and I'm going to suppress the
details, meaning inside of that
computation, you don't
need to know what it does.
You just need to know, if I
give it the right kind of
input, it'll give me back an
input that satisfies the
contract that I set up.
And that in essence says, I've
just created the equivalent of
a new primitive.
Same way that I have
multiplication or division as
a primitive, functions are going
to give me, or somebody
else who wrote them for me as
part of a library, a new
primitive that I'm going
to be able to use.
And that gives me a lot of power
in terms of what I want
to have inside of the language.
OK.
So, let's look at an example.

Korean: 
것은 새로운 초기 명령들을 만들어 내는 것입니다. 
그리고 저는 여기에 따옴표를 두겠습니다, 그것은 일반화입니다. 
제가 그것으로 무엇을 의미하죠? 
함수의 생각은, 저는 computation의 일반적인 패턴을 
캡쳐하고 싶습니다. 
제곱근을 계산하는 것처럼요. 
저는 코드에서 그것을 캡쳐 할 것입니다, 저는 그것을 
이름으로 부를 수 있을 것입니다, 
그리고 저는 자세한 것을 숨길 것입니다, 그 computation 내부를 의미하죠, 
여러분은 그것이 무엇인지 알 필요가 없어요. 
여러분은 제가 그것에 옳은 입력을 주면, 
그것이 저에게 제가 만든 계약을 만족시키는 입력을 
돌려 준다는 것을 알면 됩니다. 
그리고 본질적으로, 저는 새로운 초기 명령들과 
동등한 것을 만들었습니다. 
제가 초기 명령들로 곱셈이나 나눗셈을 가진 것과 같은 방법으로, 
함수들은 저에게 또는  
저에게 라이브러리 일부로 그것들을 써주는 누군가에게, 
제가 사용할 수 있을 새로운 초기 명령들을 줍니다. 
그리고 그것은 저게게 언어 내부에서 제가 원하는 것의 관점에서 
많은 힘을 줍니다. 
좋아요.
그래서, 예를 봅시다. 

English: 
To try to see what we're
going to do with this.
Before I do that though, let me
try and give you an analogy
to keep this in mind of why we
want to basically build these
abstractions and what
we need in order to
have them work together.
So here's the supposed
to say silly analogy.
You can tell my jokes
are always bad.
John's are much better, by the
way, which is why Thursday
will be a much better lay--
a better lecture.
But here's the example.
You've been hired by PBS to
produce a nice thirteen-hour
documentary, or drama,
that's going to run.
And, you know, you start by
saying, OK, thirteen hours,
I'm going to break it up into
thirteen different chunks.
I'm going to assign each chunk
to a different writer.
And they're going to go off and
write that element, that
hour's worth of stuff.
You can imagine what you get:
each hours worth of drama, if
you like, may be great, but it
may have absolutely nothing to
do with the other
twelve hours.
And unless, you know, you've
been hired to do Pirandello's
Six Characters In Search Of An
Author, this is not a great
thing, because you
get something

Korean: 
우리가 이것으로 무엇을 하려는지 보도록 노력하세요. 
제가 그것을 하기 전에, 저는 여러분에게 
왜 우리가 기본적으로 그 추상화를 구축하길 원하는지 
그것들이 함께 작동하도록 하기 위해 우리가 필요한 것은 무엇인지 
마음 속에 새겨야 할 비유를 주겠습니다.  
그래서 여기 어리석은 비유가 있습니다. 
여러분은 제 유머가 항상 나쁘다고 말할 수 있어요. 
존은 훨씬 낫습니다, 그런데, 왜 목요일이 더욱 그럴까요 – 
더욱 좋은 강의입니다. 
그런데 여기 예가 있습니다. 
여러분은 좋은 13 시간의 다큐멘터리나 드라마를 제작하도록 
PBS에 의해 고용되었습니다. 그것은 상영될 것입니다. 
그리고 여러분은 좋아요, 13 시간이라고 말하면서 시작합니다, 
저는 그것을 13 시간 덩어리로 나눌 것입니다. 
저는 각 덩어리에 다른 작가를 배정할 것입니다.  
그리고 그들은 시작하여 요소를 씁니다, 
그것은 볼 가치가 있는 것이죠.
여러분은 여러분이 무엇을 얻는지 상상할 수 있습니다: 
드라마의 각 시간은 훌륭하지만 절대적으로 다른 12 시간과 관련이 
없을 수 있습니다. 
그리고 그렇지 않으면, 여러분은 Pirandello's Six Characters 를 하라고 고용되었습니다, 
작가를 찾아서요, 이것은 좋은 것이 아닙니다, 
왜냐하면 여러분은 정말 혼란스러운 것을 

Korean: 
가지니까요. 
이제, 비유의 핵심은 무엇이죠? 
저는 이 작가들이 모두 함께  
상호 작용할 필요가 있나요? 
저는 설명서가 필요해요. 
저는 입력으로 가지는 것의 관점에서 원하는 것이 여기 있습니다 
라고 말하는 계약이 필요해요, 여러분의 
드라마 파트를 시작하기 위해, 출력에서 여러분이 만들어야 할 것이 여기 있어요 라고 하는 것이요. 
그리고 그것들이 내부에서 하는 것의 자세한 사항은 그것에 달려 있습니다.
추상화에 대한 생각, 설명서에 대한 생각은 정확히 우리가 
우리 함수들 안에서 사용하길 원하는 것입니다. 
우리는 여러분이 Pirandello 같은 드라마를 쓰게 하지 않을 것이지만 
여러분이 적어도 좋은 코드를 쓰도록 할 것입니다. 
그리고 그것이 우리가 하려는 것입니다. 
좋아요. 
그것을 위한 단계를 세웁시다. 
스크린 위에서, 저는 – 저는 그것을 comment 했지만 
여러분이 전에 본 코드를 가지고 있습니다, 바로 여기에요. 
알겠죠? 
그것이 무엇이죠?  
그것은 우리가 제곱근을 계산 하기 위해 쓴 코드입니다. 
사실 완전한 배수의 제곱근을 말합니다.
여러분에게 그것이 무엇을 하는지 상기시키기 위해,  
우리는 x를 어떤 값으로 두고, ANS 또는 답변 이라고 하는 초기 변수를 만듭니다, 그리고 나서 
작은 루프를 통해 런합니다. 
좋아요, 우리는 – 사실, 

English: 
that is really confusing.
Now, what's the point
of the analogy?
What do I need for
those writers to
all interact together?
I need a specification.
I need a contract that says,
here's what I want in terms of
things that you're going to take
as input, to begin your
part of the drama, here's what
you're going to produce at the
output, and the details
of what they do
inside are up to them.
An idea of abstraction, that
idea of specification, is
exactly what we want to use
inside of our functions.
We won't make you write dramas
like Pirandello, but we're
going to try make you at
least write good code.
And that's we're going
to try and do.
All right.
Let's set the stage for it.
Up on the screen, I've got--
I commented it out, but I've
got a piece of code that
you've seen before,
right up here.
OK?
What is that?
It's the piece of code we wrote
for computing square
roots, square roots of actually
perfect squares.
[UNINTELLIGIBLE]
Just to remind you what it
does, we bound x to some
value, we set up an initial
variable called ANS or answer,
and then we run through
a little loop.
All right, we're-- well
actually, I should say that

English: 
better, we first check to see,
is x greater than or equal to
zero, if it's not, then we come
down here and we print
something out, otherwise we run
through a little loop to
get the answer, and then
we check it and we
spit something out.
It does the computation,
that's fine.
Suppose I want to compute square
roots a lot of places
in a big chunk of code.
Right now, I have to take that
piece of code and replicate it
everywhere I want in
my larger file.
And I've got to worry about,
is somebody else using ANS,
answer, as a variable, in which
case I've got to be
really careful.
Is somebody else using
x as a variable?
I've got to deal with a
lot of those details.
I want to abstract that.
And the abstraction you
see, right here.
I'm going to highlight it for
a second so you can see it.
I want you to look at it
on the handout as well.
This is the creation
of a function.
And I want to describe both the
syntax, what we're doing,
and then the semantics of
how do we use it and
what does that mean.
So.

Korean: 
저는 그것을 더 좋게 말해야 합니다, 우리는 확인해 봐야 합니다, x가 0 보다 크거나 같은지를요, 
그렇지 않으면, 우리는 여기로 내려 와서 무엇을 프린트 합니다, 
그렇지 않으면 우리는 답을 얻기 위해 작은 루프를 통해 런합니다, 
그리고 나서 그것을 확인하고 무언가를 내놓습니다. 
그것은 computation 을 합니다, 좋습니다. 
제가 많은 곳의 큰 덩어리의 코드에서 제곱근을 계산하길 원한다고 
가정해 보세요. 
바로 지금, 저는 그 코드를 가지고 더 큰 파일에서 제가 원하는 모든 곳에 
그것을 복사 해야 합니다. 
그리고 저는 누가 ANS를 변수로 썼는지 걱정해야 합니다, 
제가 정말로 
주의해야 하는 경우에요. 
누군가가 x를 변수로 사용했나요? 
저는 많은 자세한 것들을 다루어야 해요. 
저는 그것을 추상화하고 싶습니다. 
그리고 여러분이 보는 추상화는, 바로 여기 입니다. 
저는 그것을 강조하고 싶습니다. 잠깐 여러분은 그것을 볼 수 있어요. 
여러분은 이것을 또한 핸드아웃에서도 볼 수 있습니다. 
이것은 함수를 만드는 것이에요. 
그리고 저는 문법과 우리가 무엇을 하고 있는지를 설명하고 싶습니다, 그리고 나서 
우리가 그것을 어떻게 사용하는지의 의미와 그것이 무엇을 의미하는지를요. 
네. 

Korean: 
여기 함수의 문법이 있습니다. 
먼저, 우리는 키워드를 가집니다. Def 입니다. 
정의 또는 정의하다 이죠, 여러분이 어느 역사로부터  
왔는지에 따라서요.
이것은 파이썬의 키워드 입니다. 
그것이 파일에서 이것을 읽을 때 그것은 저는 정의를 만듭니다, 
저는 함수를 만듭니다 라고 말합니다. 
그리고 – 이것은, 저는 이것이 키워드라고 하겠습니다 – 
이것은 바로 옆에 이름이 나옵니다. 
그리고 이것은 그것과 같습니다. 
이 경우에, sqrt는 제곱근입니다. 
이것은 제가 이 함수에게 준 
이름 입니다. 
이것은 제가 이 함수를 사용하길 원할 때 
언급 할 이름 입니다. 
알겠죠? 
그리고 주목 하세요, 이름 바로 옆에, 
우리는 괄호를 가지고 그 안에 다른 변수 이름이 있습니다. 
그리고 이것은 이 함수의 형식적인 인자들을 정의합니다. 
네. 
그것은 정말 그래요, 고마워요. 

English: 
Here's the syntax
of the function.
First of all, we have
a keyword. def.
Definition or define, depending
on which sort of
piece of history
you come from.
This is a keyword to Python that
says, when it reads this
in the file, it says, I'm
creating a definition.
I'm creating a function.
And that's follow-- so this
is, let me say this is a
keyboard-- that is followed
immediately by a name.
And this equates to that.
In this case, sqrt,
square root.
I'm saying, this is the
name I'm going to
give to this function.
This is the name to which I'm
going to refer when I want to
use this function.
All right?
And notice, immediately after
that name, we have an open and
close paren with another
variable name inside of that.
And this defines formal
parameters of this function.
Yup.
PROFESSOR JOHN GUTTAG:
[INAUDIBLE]
PROFESSOR ERIC GRIMSON: It
does indeed, thank you.

English: 
This is me being a Scheme
hacker, not a Python hacker.
Yes, def has to be lowercase
or won't recognize it.
Thank you, John.
OK. def's the keyword.
I'm creating a function.
sqrt-- again, I'm being
careful about case-sensitive,
I'm using all lowercase here,
followed by an open paren, and
I said, formal parameters.
We'll see there could be
more than one there.
We're going to come back to what
they mean in a second,
but for now, think of them as,
or think of x, in this case,
as the place holder.
This place holder is saying, if
you give me a value for x,
inside the body of this function
I'm going to use that
value everywhere I see x.
Question.
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: Ah,
we're going to come back to
this in a second.
But the question was, do
I always need an input?
I can have functions with no
parameters, that's fine, I
will still need the open and
close paren there to identify
that I have no parameters.
We're going to see an
example in a second.
Good question.
Actually, I've got to get rid of
this candy, so since it was
a good question, here you go.
Nice catch.
Almost. Sorry.
OK.

Korean: 
이것은 파이썬 해커가 아니라 스키마 해커입니다. 
네, def는 소문자가 되어야 합니다 그렇지 않으면 알아 볼 수 없어요. 
고마워요, 존. 
네. def는 키워드 입니다. 
저는 함수를 만들고 있습니다. sqrt – 다시, 저는 이 경우에 대해 주의할 것입니다 – 
저는 여기서 모두 소문자를 사용하고 있습니다, 뒤에 열린 괄호가 나오고 
형식적인 인자들이 있습니다. 
우리는 하나 이상이 될 수 있는 것을 볼 것입니다. 
우리는 곧 그것들이 무엇을 의미하는지로 돌아올 것이지만, 
지금은, 그것들에 대해 생각해 보세요, 또는 x에 대해 생각해 보세요, 이 경우에, 
그것들을 플레이스 홀더로써요. 
이 플레이스 홀더는, 여러분이 저에게 x의 값을 주면, 
이 함수의 내부에서 저는 x를 볼 수 있는 어디서나 
그 값을 사용할 것입니다.   
질문 하세요.
아, 우리는 곧 이것으로 
돌아 올 것이에요. 
그러나 질문은, 제가 항상 입력을 해야 하나요? 
저는 인자가 없는 함수를 가질 수 있습니다, 그것은 괜찮아요, 
저는 인자가 없다는 것을 알려 주는 열린 괄호와 닫힌 괄호가 
여전히 필요하죠. 
우리는 곧 예를 볼 것입니다.
좋은 질문입니다. 
사실, 저는 이 사탕을 없애 버려야 하거든요, 
좋은 질문이었으니까, 여기 있습니다. 
잘 잡았어요. 
거의요. 
미안해요. 
네. 

Korean: 
아니에요, 저는 아닙니다. 
미안해요. 
저는 학생이 그것을 가지고 있다고 생각하고 안경을 
잘못 썼네요 그렇지 않다는 걸 알았어요, 아 나중에 
돌아 옵시다. 
여기서 우리가 무엇을 하고 있죠? 
우리는 정의를 가집니다, 우리는 이름을 가집니다, 우리는 형식적인 인자들의   
세트를 가집니다. 
좋아요. 
여러분이 코드의 나머지를 보면, 그것은 제가 
다른 곳에서 가지는 것과 매우 같아 보입니다. 
그것의 밖에서 저는 무엇을 가지죠, 네? 
그것은 루프의 비슷한 세트를 통해 런할 것입니다. 
그래서 이 세트에서, x가 제가 원하는 값을 갖는 한, 
그것은 옳은 것을 해야 합니다.
그러나, 우리가 강조하고 싶은 다른 
변화들이 있습니다. 
특히, 주목하세요 – 여러분에게 강조하기 위해서, 
제가 잘못 된 안경을 끼고 찾는 다면 – 우리는 
이 리턴 명령문을 가집니다. 
그래서 return 은 또 다른 키워드 입니다. 
그리고 그것은 기본적으로, 여러분이 computation 에서 이 점을 가질 때, 
computation을 멈추라고 말합니다. 
문자 그대로, 이 함수로부터 제어를 돌려 줍니다,  
그리고 다음 명령문의 값을 가지고 와서, 

English: 
No, I'm not.
I'm sorry.
I thought you had it, and then
I've got the wrong glasses on
and I realized you didn't,
so I will, ah come
back to that later.
What are we doing here?
We got definition, we got name,
we got a set of formal
parameters.
Right.
If you look at the rest of that
code, gee, it looks a lot
like what I had elsewhere.
Of what I had outside
of it, right?
It's running through a
similar set of loops.
So in some sets, as long as x
has the value I want, it ought
to do the right thing.
However, there's a couple of
other changes there that we
want to highlight.
In particular, notice-- let me
highlight it for you, if I can
find it with the wrong glasses
on-- we've got
these return commands.
So return is another keyword.
And it basically says, when you
get to this point in the
computation, stop
the computation.
Literally, return the control
from this function, and take
the value of the next
expression, and return that as

Korean: 
전체 computation의 값으로 리턴 합니다.
이제, 우리가 흥미 있는 것은 
사실, 그것이 ANS를 내 놓고, 여러분은 코드 아래에서 볼 수 있다는 것이에요, 
ANS의 값을 리턴해 주는 곳이 있어요, 
우리가 원하는 것이 무엇이죠, 네? 
그것은 우리가 가지려고 한 값을 갖는 것입니다. 
그러나 코드에서 이 재미있게 보이는 것을 갖는 곳이 있습니다, 
아무 것도 리턴하지 않아요, 그리고 
다른 색으로 변하지 않는 것에 주목하세요. 
아무 것도 특정한 값이 아닙니다, 그리고 그것은 다음의 약간 이상한 행동을 합니다: 
그것은 값입니다, 우리는 그것을 리턴할 수 있습니다 – 축복이 있기를 – 그러나 
아무 것도 아닌 것이 말하는 것은 이 computation 으로부터 
돌아 올 값이 없다는 것입니다. 
그래서 그것이 리턴 될 때, 우리는 곧 보게 될 텐데, 
인터프리터로, 그것은 프린트 하지 않습니다.  
좋아요. 
그것은 단지 아무 것도 프린트 하지 않습니다. 
그렇지만, 그것은 사실 값이고 우리는 그것을 사용할 수 있습니다, 예를 들어, 
비교를 할 때요. 
우리가 이 함수가 값을 리턴 하는지, 

English: 
the value of the whole
computation.
Now, the one that we're most
interested in is the one
where, in fact, it gets out ANS,
so you see down here in
the code, there's a spot where
it's going to return the value
of ANS, which is what
we want, right?
That's the thing that holds the
value that we intended to
have.
But there's another couple of
places in that code where it's
got this funky-looking thing,
return none, and notice none's
in a different color.
None is a special value, and
it has the following
slightly-odd behavior: it is
a value, we can return it--
God bless-- but what none says
is, there is no value coming
back from this computation.
So when it is returned, and
we'll see this in a second, to
the interpreter, it
doesn't print.
OK.
It simply doesn't
print anything.
Nonetheless, it is actually a
value and we can use it, for
example, to do comparisons.
If we want to know, did this
function return a value or

English: 
not, rather than reserving, say,
-1 or some other special
thing which you might want to
use some other ways, it
literally returns this very
special value that says, there
is no actual value return
from this computation.
OK.
Note, by the way, if I chase
through each possible path,
like there's some IFs in here,
there's some places to go, at
least in this piece of code,
every possible path through
this code ends in a return.
And that's a good programming
discipline, to
make sure that happens.
There's an exception, which
we'll see in a second, but
I'll highlight, which is, if
we get to the end of the
procedure, there's sort of
an implicit return there.
In fact, a return of
none, in that case.
It comes out of it.
But if I look at this, right?
If I come into this code, I'm
going to check this branch
first, if it's not true, ah,
there's a return at the end of
that branch.
If it is true, I do that, and
then I've got a second test.
If it's true, I return,
otherwise a return.
So there's a return branch
on every possible
path through the code.
And that's valuable, it's
something you want to think
about as your right your own.

Korean: 
-1이나 여러분이 다른 방법으로 사용할 어떤 다른 특정한 것을 보유 하는지 알고 싶으면, 
그것은 문자 그대로 
그 매우 특별한 값을 리턴 합니다, 이 computation 으로부터 
실제 리턴 값은 없어요.  
좋아요. 
그런데, 주목하세요, 제거 여기 IF들과 같은 
각 가능한 경로를 통해 쫓으면, 
적어도 이 코드에서는 갈 곳이 있어요, 이 코드를 통한 
모든 가능한 경로는 리턴에서 끝납니다. 
그리고 그것은 좋은 프로그래밍 지시입니다, 
그것이 일어나는 걸 확실히 해줍니다. 
예외가 있습니다. 우리는 곧 보게 될 텐데, 저는 강조하고 싶군요, 
그것은, 우리가 프로시저의 끝에 다다르면, 
암시적 리턴이 있습니다. 
사실, 그 경우에는 아무것도 리턴하지 않아요. 
그것은 거기서 나옵니다. 
그러나 제가 이것을 보면요, 네? 
제가 이 코드로 들어 가면, 저는 이 branch를 먼저 검사할 것입니다, 
그것이 옳지 않으면, 아, 그 branch의 마지막에 
리턴이 있군요. 
그것이 옳으면, 저는 그것을 하고 나서 두 번째 테스트를 합니다. 
그것이 옳으면, 저는 리턴하고, 그렇지 않으면 리턴 합니다. 
그것은 귀중한 
것입니다, 
그것은 여러분 스스로 생각해 
보길 원하는 것입니다.  

Korean: 
좋아요.   
제가 특별히, 이것을 이용해서 무엇을 하나요? 
제가 이것을 어떻게 적용하죠? 
좋아요, 저는 인자의 값을 넘겨 줌으로써 
함수를 적용할 것입니다. 
그리고 이 경우에, 
그것은 문자 그대로 sqrt를 타이핑 하는 것을 의미합니다, 그 괄호 안의 값을 가지고요.
좋아요. 
이제, 무슨 일이 일어 나는지 보기 위해 이것을 시도해 봅시다.
저는 제가 거기서 그것을 가지는지 확실히 하고 싶어요, 예를 들어, 
제가 16의 sqrt를 타이핑 하면, 아하! 
그것이 무엇을 했죠? 
자, 그것이 무엇을 했는지 이야기 해 봅시다. 
이 적용이 하는 것은 다음과 같습니다: 그것은 바인드 합니다, 

English: 
OK.
What do I do to use this,
in particular?
How do I invoke this?
OK, so I'm going to invoke a
function by passing in values
for the parameters.
And in this case, that literally
means typing sqrt,
with some value inside
the parens.
OK.
Now, let's just try this out
to see what happens.
I'm going to make sure I've got
it there, so if I type,
for example, sqrt
of 16, ah-ha!
What did it do?
Well, let's talk about
what it did.
What this invocation does, is
the following: it binds, and

Korean: 
그리고 저는 이것이 이 예에서 
일반적이기 보다는 특별하다고 말할 수 있습니다, 그것은 x를 16으로 바인드 합니다. 
여러분은 높은 수준의 것에서 이 대입문을 
가지고 할 수 있습니다. 
그러나 이 바인딩은 지역적입니다. 
그것이 이 프로시저의 코드의 국한된 곳 내에서 갖는 다는 것을 
의미합니다. 
그것과 연관하여, 그것을 새로운 환경이라고 부르는 것을 만드는 것으로 
생각해 보세요. 
그것과 연관하여, 그것은 우리가 하는 모든 다른 실행을 합니다,  
거기 첫 번째 명령문이 ANS의 바인딩을 만든다는 것을 
주목하세요.
그래서 답변 또는 ANS는 또한 오직 지역적으로 바인드 됩니다. 
이 프로시져의 이 환경의 한정된 곳의 내부를 
의미합니다. 
ANS를 값으로 시작하고 이제 우리는 
우리가 전에 한 것처럼 루프를 통해 런 합니다. 
Increments를 천천히 쓰고, 제곱 된 ANS가 x 보다 큰지 검사해 보세요, 
그리고 그것이 그 점으로 갔을 때, 
그것은 그것이 사실 완벽한 제곱인지 아닌지 검사합니다, 
그리고 그것을 리턴 합니다. 

English: 
I'm going to say this
specifically for this example,
rather than general,
it binds x to 16.
Just as you would have done with
an assignment statement
up in the top level thing.
But this binding is local.
Meaning it only holds within
the confines of the code of
this procedure.
Relative to that, think of that
as creating what we, I'm
going to call a new
environment.
Relative to that, it does all
the other execution we would
do, including, notice the first
instruction there is to
the set up a binding for ANS.
So answer, or ANS, is also
bound only locally.
Meaning, inside the
confines of this
environment of this procedure.
ANS starts off with a value of
0 and now we just run through
that loop just like
we did before.
Writing Increments it slowly,
checking to see if ANS squared
is bigger than x, and when it
gets to that point, it checks
to see, is it actually a perfect
square or not, and it
returns it.

Korean: 
그리고 그것이 리턴하면, 그것은 그 리턴으로부터의 값을 리턴합니다, 
이 경우에는 단지 프린트 됩니다. 
좋아요. 
이제 저는 이 지역 바인딩에 대해 
말하고 싶군요. 
저는 이것을 두 번 반복할 것입니다. 왜냐하면  
중요하기 때문입니다. 
이 지역 바인딩은 어떤 전역 바인딩에 영향을 미치지 않습니다. 
그것이 무엇을 의미하죠? 
여러분에게 작은 예를 보여줄게요, 그리고 나서 
이것으로 돌아 올 것입니다. 
저는 여기 작은 함수를 갖습니다. 
보세요, 저는 f x 를 x의 값을 가지고 x+1로 바꿔주는 함수로 정의했습니다. 
그리고 나서 값을 리턴합니다. 
좋아요. 
그래서 그것은 단지 x에 1을 더하는 것입니다. 
그러나 저는 여러분이 지금 제가 이것을 사용하면 무슨 일이 일어나는지 보길 바랍니다. 
X를 3의 값으로 바인드 합니다.  
그것은 이 전역 환경에서 x를 위한 바인딩을 만듭니다. 
이것은 인터프리터가 보는 것입니다. 
맞죠?

English: 
And once it returns it, it
returns a value from that
return, that in this case
is just printed out.
All right.
Now I want to say a
couple of things
about these local bindings.
I'm going to repeat this
a second time,
because it's important.
These local bindings do not
affect any global bindings.
What does that mean?
Let me show you a little
example, and then we'll come
back to this.
I've got a little
function here.
See, I've defined f of x to be
a function that takes a value
of x in, changes x to x+1, and
then just returns the value.
OK.
So it's just adding 1 to x.
But I want you to see now what
happens if I use this.
Let's bind x to the
value of 3.
It's creating a binding for x
in this global environment.
This is what the interpreter
sees.
All right?

Korean: 
사실, 제가 x를 보면, 그것의 값은 3입니다. 
Z를 바인드해 봅시다 – 제가 도움이 되도록 타이프 하면 – 그러니까, 
f 3 입니다. 
네?  
값은 z는 4입니다, 그것이 제가 예상한 것인가요, 네? 
지역적으로 x는 3으로 바인드 됩니다, 제가 그것에 1을 더했고, 
4를 얻었습니다. 
그러나 x의 값은 무엇이죠? 
그것은 여전히 3입니다. 
다시, 이것을 생각하는 방법은, 저는 많은 기회 또는 
많은 프레임을 가집니다, 우리가 이 용어로 돌아 오면, 
저는 그 언어 환경을 사용할 것입니다, 왜냐하면 
저는 오래된 Lisp 해커니까요, 많은 환경은 
바인딩이 있습니다. 
그래서 조금 더 자세히 이것의 철자를 적어 보겠습니다.  
이것이 말하는 것은 다음과 같습니다. 
제가 인터프리터에게 말할 때, 

English: 
In fact, if I look at
x, its value is 3.
Let's bind z eh let's bind z
to the-- if I could type it
would help-- say, f of 3.
OK?
So the value is z is 4, it's
what I expect, right?
Locally x got bound to 3, I
added 1 to it, whoop-dee-doo,
I get back a 4.
But what's the value of x?
It's still 3.
The way to think of this is,
again, I've got multiple
scopes, or multiple frames, or
if we're going to come back to
those terms, I'm going to use
the word environment, because
I'm an old-time Lisp hacker,
multiple environments in which
there are bindings.
So let me spell this out in just
a little bit more detail.
What this is saying
is the following.
When I'm talking to the
interpreter, when I'm typing

Korean: 
제가 한 것에 있어서 타이프 할 때, 그 파이썬 환경에서, 
저는 전역 바인딩이라는 것을 얻습니다. 
저는 여기 작은 차트를 그리겠습니다. 
이것을 인터프리터의 세계라고 생각해 보세요, 
즉 저는 3으로 바인드 되는 x와 같은 것을 가집니다. 
제가 함수를 부르거나 실행할 때, 
그것을 지역 테이블을 만드는 것이라고 생각하세요. 
그 지역 테이블 안에, 저는 형식적인 인자를 바인드 합니다, 
그것은 제가 16을 어떤 값으로 한 것입니다. 
이 x는 오직 sqrt에 의해 얻습니다. 
거기 내부에서, 저는 다른 것들을 바인드 할 수 있습니다. ANS가 지역적으로 0으로 바인드 되는 것처럼요. 

English: 
things in as I just did, to that
Python environment, I'm
getting what I'm going to
call global bindings.
I'm going to draw a
little chart here.
Think of this as the, as the
world of the interpreter, in
that I've got things like x
bound to the value of 3.
When I call or invoke a
function, think of it as
creating a local table.
Inside that local table, I bind
the formal parameter,
which is what I do I did
16 right to some value.
This x only gets seen by sqrt.
Inside of there, I can bind
other things, like ANS gets

Korean: 
그리고 그것은 증가하고 
결국 우리는 그 값을 리턴합니다. 
제가 sqrt로부터 리턴을 얻었을 때, 어떤 값은  
인터프리터로 다시 리턴 됩니다. 그리고 그 테이블은 없어집니다. 
그러나 그 테이블은 ANS를 위한 x와 같은 변수의 
다른 경우를 위한 어떤 바인딩에 영향을 미치지 않습니다. 
좋아요. 
다른 예들을 봅시다, 
그것을 강조하기 위해서요. 
그리고 제가 보여 주려고 한 것 중 하나는, 좋아요. 
다시, 저는 이제 함수를 그것이 초기 명령인 것처럼 사용할 수 있습니다. 
그래서 이것은 단지 대입이고 저는 그것의 값이 되는 테스트를 할 것입니다. 
물론 그것이 대입문이기 때문에 
아무것도 프린트 되지 않습니다. 
알겠죠? 
그래서 제가 sqrt를 혼자 호출하면, 그 리턴 값이 행해집니다, 그러나 
제가 그것을 테스트에 바인드 한 경우에, 저는 테스트를 가서 볼 수 있고, 
거기 그것이 있습니다. 
제가 그것을 하면 무슨 일이 일어나죠? 
좋아요. 

English: 
locally bound to 0, and then
it increments around and
eventually we return
that value out.
When I get to a return from
sqrt, some value is returned
back to the interpreter, and
that table goes away.
But that table does not affect
any bindings for other
instances of the variable
like x for ANS.
OK.
Let's look at a couple of
examples, just to sort of
stress that.
And one of the things I
wanted to show is, OK.
Again, I can now use a function
just as if it was a
primitive, so this is just an
assignment and I going to take
test to be the value of that, of
course nothing gets printed
because that was an assignment
statement.
All right?
So if I called sqrt alone, that
return value is done, but
in this case I bound it to
test, so I can go look at
test, and there it is.
What happens if I do that?
OK.

Korean: 
여러분이 코드를 보면, 그것이 프린트 됩니다, 그것은 제가 원하던 완벽한 제곱이 아니에요, 
그러나 지금, 
테스트의 값이 무엇이죠? 
네, 저는 테스트를 무언가로 바인드 했어요, 제가 그것을 보면, 그것은 아무 것도 프린트 하지 않습니다, 
그러나 – 제가 타이프 하면 – 저는 질문할 수 있습니다, 
테스트가 그 특별한 이름으로 바운드 됩니까? 
답은 네입니다. 
여러분, 이것은 뉘앙스 같아 보입니다, 그렇죠? 
그러나 이것은 귀중한 것입니다. 
각 경우에서, 저는 이 프로시저로부터 유용한 값을  
리턴합니다.
저는 그것을 검사할 수 있습니다, 이것이 어떤 computation의 일부이면, 저는 알고 있습니다, 
그것이 완벽한 제곱을 찾았나요 아닌가요? 
저는 화면에 무엇이 프린트 되었는지 읽으러 갈 필요가 없습니다. 
이것은 제가 사용할 수 있는 값을 리턴했습니다. 
왜냐하면 저는 이것이 리턴 값입니까? 라고 말하는 테스트를 할 수 있기 때문입니다. 
만약 그렇지 않으면, 저는 그것으로 다른 것을 할 것입니다. 
그래서 바인딩은 여전히 거기 있습니다, 그것은 단지 그것을 프린트 하지 않습니다. 
네. 
우리가 이것으로부터 무엇을 가지죠? 
간단해요, 적어도 덧셈 같아 보입니다. 
우리는 함수의 이 개념을 더했습니다. 

English: 
If you look at the code, it
printed out, it's not a
perfect square, which is what I
wanted, but now, what's the
value of test?
OK, I bound test to something,
if I look at it, it doesn't
print anything, but--
if I could type--
I can ask, is test bound to
that special name none?
The answer is yes.
Boy, this seems like
a nuance, right?
But it's a valuable thing.
It says, in each case, I return
some useful value from
this procedure.
I can check it, so if this
was part of some other
computation, I want to
know, did it find a
perfect square or not?
I don't have to go read what it
printed out in the screen.
This has returned a value
that I can use.
Because I could do a test to
say, is this a return value?
If it's not, I'll do something
else with it.
So the binding is still
there, it simply
doesn't print it out.
OK.
What do we have out of this?
Simple, seems like,
at least addition.
We've added this notion
of a function.

English: 
I've highlighted some of the key
things we got here, right?
We have that def keyword, we've
got a name, we've got a
list-- or I shouldn't say
a word list, we have a
collection of formal parameters
that we're going to
use-- we have a body, and the
body looks just like the
normal instructions we'd use,
although by the way, we ought
to be able to use functions
inside the body, which we're
going to do in a second, and
then we're going to simply
return some values
out of this.
Now I started by saying,
build these functions.
I'm trying to get both
decomposition and abstraction.
Well, you hopefully can see
the decomposition, right?
I now have a module.
OK, let me set the stage.
Imagine I wanted to do sqrt, or
square root-- no, I'm going
to use sqrt, that's the name I'm
using here-- square root a
hundred different places
in some piece of code.
Without function, I'd have to
copy that piece of code
everywhere.
Now I got one just simple
thing, and I simply have
isolated that module inside
of that function.
What about abstraction?
Well, I've got part of what
I want for abstraction.
Abstraction, again, says I'm
going to suppress details.

Korean: 
저는 우리가 여기서 가지는 키들 중 몇 가지를 강조했습니다, 그렇죠? 
우리는 def 키워드를 가지고, 이름을 가지고, 리스트를 가집니다 – 
또는 저는 리스트라는 단어를 말해서는 안됩니다, 
우리는 우리가 사용할 형식적인 인사들의 컬렉션을 가집니다 – 
우리는 몸체를 가지고, 몸체는 우리가 사용하는 평범한 명령문들 같아 보입니다, 
그런데, 우리는 몸체 내부의 함수들을 사용할 수 있어야 합니다, 
그것은 우리가 곧 할 것 입니다, 그리고 나서 우리는 이것으로부터 
어떤 값을 간단히 리턴 할 것입니다. 
이제 저는 이 함수들을 만들라고 말하면서 시작했습니다. 
저는 분해와 추상화 모두를 가지려고 노력하고 있습니다. 
자, 여러분은 희망적으로 분해를 볼 수 있어요, 그렇죠? 
저는 이제 모듈을 가집니다. 
좋아요. 단계를 세웁시다.  
제가 sqrt 또는 제곱근을 하길 원한다고 상상해 보세요 – 아닙니다, 
저는 sqrt를 사용할 것입니다, 그것은 제가 여기서 사용하는 이름이에요 – 
제곱근은 다른 코드의 백 가지 다른 곳에서 사용되고요. 
함수 없이, 저는 
코드 어디서나 그것을 복사해야 합니다. 
이제 저는 간단한 것 하나를 가집니다, 그리고 
그 함수 내부에 그 모듈을 간단히 격리 시킬 것입니다.
추상화는 어떻습니까? 
자, 저는 제가 추상화를 위해 원하는 것의 부분을 가집니다. 
다시, 추상화는 제가 자세한 사항을 감추라고 말합니다. 

Korean: 
이제 제가 sqrt를 썼으니까, 
저는 코드에서 제가 원하는 곳 어디서나 그것을 사용할 수 있습니다. 
여러분은 제가 그것을 옳게 썼다는 사실에 의존 해야 하지만, 
여러분은 기본적으로 그것이 사용되는 방법의 자세한 사항은 숨길 수 있습니다. 
우리가 이것에서 얻으려는 것이 하나 더 있습니다, 
그리고 그것은 – 여러분은 놀랄지도 모릅니다, 
이 줄에 여기 세 개의 따옴표를 가지는 재미있는 것이 있어요. 
그렇죠? 
그리고 그것은 설명서입니다. 
그것은 정말 귀중한 것이에요. 
그래서 설명서는 무엇을 하죠? 
프로그래머로써, 사용자에게 정보를 쓰는 것이 
제가 하는 것입니다.
 이것은 저에게 Pirandello 에피소드를 1 시간 쓰기 하고 
다른 작가들에게 여기에 여러분이 사용하는 것으로 추측되는 것이 있습니다 
라고 말하는 것입니다. 그것을 옳게 하는 것은 저에게 달려 있어요, 
그러나 제가 그것을 하면, 저는 구체화할 것입니다, 
이 함수는 무엇을 하죠? 
그것이 입력으로 기대하는 것, 그리고 제가 
넘겨 주고 싶은 어떤 다른 정보 입니다. 
그리고 주목하세요, 그런데, 제가 그것을 하면, 
저는 여기서 내려 갈 수 있습니다, 그리고 저는 sqrt를 타이프하고 괄호를 엽니다, 아하! 

English: 
Now that I've written sqrt, I
can just use it anywhere I
want in the code.
You've got to rely on the fact
that I wrote it correctly, but
you can basically suppress the
details of how it's used.
There's one more piece that we'd
like to get out of that,
and that is-- you may have been
wondering, what's with
the funky stuttering here of
three double-quotes in a row.
All right?
And that is a specification.
Which is a really valuable
thing to have.
So what is the specification
going to do?
It is my place, as a programmer,
to write
information to the user.
This is me writing one hour of
that episode of Pirandello and
telling the other authors,
here's what I'm assuming as
you use it.
So it's up to me to do it right,
but if I do it, I'm
going to specify, what does
this function do?
What does it expect as input,
and any other information I
want to pass on.
And notice, by the way, if I
do that, I'm going to come
down here, and I type sqrt and
open the paren, ah-ha!

Korean: 
그것은 저에게 창조자가 무엇인지 보여줍니다, 
이 경우에 사실 저는 존으로부터 이것을 훔쳤습니다,  
구탁 교수가 이 코드를 위한 그의 설명을 한 것을요..
이제 그것은 그것이 옳다는 것을 보장해 주지 않습니다, 그렇죠? 
여러분은 프로그래머가 그것을 옳게 한다고 믿을 것이지만, 
이것은 이제 여러분이게 무언가를 말해줍니다.  
이것이 무엇이죠? 
이것은 추상화의 환상적인 부분입니다. 
이것은 여러분이 이 함수 몸체 내부가 무엇인지 알 필요가 
없다는 것을 말해 줍니다. 
여러분은 인자 이름이 무엇인지에 대해 걱정할 필요가 없습니다, 왜냐하면 
그것들은 보존 될 것이니까요, 여러분은 
제가 그것을 어떻게 하는지에 대해 걱정할 필요가 없습니다, 
이것은 저에게 제가 옳게 사용하기 위해 어떻게 이것을 사용할 수 
있을지를 말해 줍니다. 
좋아요, 그래서 그것이 추상화의 개념이고 저는 돌아 올 것이라고 했습니다 – 
우리는 학기 동안 여러 번 돌아 올 것입니다 – 
그리고 그것은 단지 추상화가 아닙니다, 
그것은 구체적인 것에 대한 생각입니다. 
그리고 약간 앞으로 보세요, 여러분은 
제가 거기서 식을 놓지 않기를 바랄 수도 있다는 것을, 자세한 사항이 무엇인지 쉽게 상상할 수 있습니다, 
저는 제약들을 둘 것입니다. 
여러분이 코드를 옳게 부르는지 확실히 하기 위해, 
검사해야 하는 구체적인 것들이죠. 
그리고 그것은 코드에 대해 사고하는 강력한 방법, 
코드를 사용하는 강력한 방법이 될 것입니다, 그래서 자세한 사항들의 개념들은 
정말 중요합니다. 

English: 
It shows me what the creator, in
this case actually I stole
this from John so what Professor
Guttag put up as his
specification for this
piece of code.
Now, it's not guaranteed
it's right, right?
You're trusting the programmer
did it right, but this now
tells you something.
What is this?
This is a wonderful piece
of abstraction.
It is saying, you don't need
to know squat about what's
inside the body of
this function.
You don't have to worry about
the parameter names, because
they're going to be preserved,
you don't need to worry about
how I'm doing it, this tells you
how you can use this, in
order to use it correctly.
Of course, I can then close
it off, and off we go.
All right, so that notion of
abstraction and I was going to
come back-- we're going to come
back to multiple times
during the term-- and it's not
just abstraction, it's the
idea of a specification.
And just to look ahead a little
bit, you could easily
imagine that I might want to
not just put a statement in
there, what the specs are,
I might want to put some
constraints.
Some specific things to check
for, to make sure that you're
calling the code right.
And it becomes a powerful way of
reasoning about the code, a
powerful way of using the code,
so those notions of
specs are really important.

Korean: 
보세요, 제가 여러분을 속이는 이유는, 
제곱근 같은 것입니다, 자세한 사항을 그것에 쓰는 것은 바보 같아 보입니다. 
모두 이것이 무엇을 할 것인지 알고 있습니다. 
그러나 여러분은 좋은 위생, 
좋은 스타일의 지시로 들어가길 원합니다. 
여러분은 자세한 사항을 쓰길 바랍니다, 모두 사실 
이 코드가 무엇을 하고 있는지 알도록요, 그리고 여러분은 
매번 그것을 쓸 것입니다. 
좋아요. 
이제 우리가 함수들을 가지니까, 우리가 문제 해결 도구로써 그것들을 사용해야 
무엇을 할 수 있는지 봅시다, 
특히, 저는 제가 모듈 방식의 개념을 가지고 싶다고 이미 말했습니다, 
그것은 제가 격리할 수 있는 모듈입니다, 그리고 저는 
자세한 사항을 추상화하는 개념을 가지고 싶습니다, 
우리가 실제로 상당히 흥미로운 코드를 쓰기 위해 그것을 어떻게 사용할 수 있을지 봅시다, 
그러나 특히, 추상화와 분해의 생각을 캡쳐하기 위해 
그것을 어떻게 
사용할 수 있을지를요. 
그래서 저는 기어를 이동할 것입니다. 
간단한 문제부터 시작해 봅시다. 
여러분, 우리는 갑자기 네브래스카 주로 이동되었습니다. 

English: 
Look, part of the reason I'm
flaming at you is, something
like square root, it seems dumb
to write specs on it.
Everybody knows what this
is going to do.
But you want to get into that
discipline of good hygiene,
good style.
You want to write the specs so
that everybody does in fact
know what this piece of code is
doing, and you're writing
it each time around.
OK.
Now that we've got functions,
let's see what we can do as a
problem-solving tool
using them.
In a particular, I've already
said I want to get this notion
of modularity, it's a module I
can isolate, and I want to get
the notion of abstracting away
the details, let's see how we
can actually use that to
actually write some reasonably
interesting pieces of code, but
in particular, to see how
we can use it to capture the
ideas of decomposition and
abstraction.
So I'm going to shift gears.
Start with a simple problem.
Boy, we're suddenly be
transported to Nebraska.

English: 
Or where I grew up,
Saskatchewan.
All right, we've got
a farm air problem.
I got a farmer, walks out into
his yard, one morning.
This farmer has a bunch of pigs
in a punch-- it's been a
long day-- a bunch of pigs
and a bunch of chickens.
And he walks out into the
farmyard and he observes 20
heads and 56 legs.
And for sake of argument, there
are no amputees among
the chickens and the pigs.
And the question is, so how many
pigs does he have, and
how many chickens does he have?
Wow.
What a deep problem, right?
But you're going to see
why we're going to
use this in a second.
So you know how to solve
this, this is a
fifth-grade problem, right?
And what's the way
to solve this?
System of linear equations.
What are the equations here?
Well, I could say, you know,
the number of pigs plus the
number of chickens
equals 20, right?
Because we've got 20 heads.
And then what else do I have?

Korean: 
또는 서스캐처원에서 자랐습니다. 
좋아요, 우리는 농장 공기 문제를 가집니다. 
저는 어느 날 아침 농부를 그의 마당으로 걸어가게 했습니다. 
이 농부는 많은 돼지들을 가지고 있습니다 – 오래 되었죠 –
많은 돼지들과 닭들을 가지고 있습니다. 
그리고 그는 농장 뜰로 나와 
20 개의 머리와 56 개의 다리를 봅니다. 
그리고 논쟁을 위해, 닭과 돼지 가운데는 다리가 
절단 된 것이 없습니다. 
그리고 질문은, 그는 돼지 몇 마리를 가지고, 
닭 몇 마리를 가지나요? 
와우. 
어려운 문제네요, 그렇죠? 
그러나 여러분은 왜 우리가 이것을 
곧 사용할지 알게 될 것입니다. 
그래서 여러분은 이것을 푸는 방법을 압니다, 이것은 5학년 문제에요, 
네? 
그리고 이것을 푸는 방법이 뭐죠? 
선형 방정식 체계입니다.  
여기 방정식이 무엇입니까? 
자, 저는 돼지의 수 더하기 닭의 수는 
20 이라고 말할 수 있습니다, 그렇죠? 
왜냐하면 머리가 20개니까요. 
그리고 나서 저는 또 무엇을 가집니까? 

English: 
Four times the number of pigs
plus two times the number of
chickens, assuming they're
not next to a
nuclear reactor, is 56.
And then how would
you solve this?
Well, it's, you sort of know
how you'd do it if this was
grammar school right?
You'd pull out your pencil and
paper, you can do it as a
matrix inversion if you know
how to do that, or you can
just simply do substitution
of one equation into
another to solve it.
That's certainly one way to do
it, but for computers that's
not necessarily the
easiest way.
So another way of solving it is
to do something we already
saw last time, which is
basically, why not simply
enumerate all possible examples
and check them?
You could say, I could have
zero chickens and 20 pigs,
does that work?
I've got one chicken and
nineteen pigs, does that work?
I've got two chickens
and eighteen
pigs, you get the idea.
So I'm going to solve this by
enumerate and check, which is

Korean: 
돼지 수의 4배 더하기 닭 수의 2배는, 
그들이 핵 원자로 옆이 있지 않다고 가정하세요, 
56입니다. 
그러면 이것을 어떻게 풀죠? 
자, 여러분은 이것이 문법 수업이라면 
어떻게 하는지를 알죠? 
여러분은 종이와 연필을 꺼냅니다, 여러분은 그것을  
행렬 도치로 할 수 있습니다. 그것을 어떻게 하는지 안다면요. 
또는 여러분은 간단히 한 방정식을 다른 것으로 
치환 할 수 있습니다. 
그것은 확실히 그것을 하는 한 방법이지만, 
컴퓨터에게는 그것이 필수적으로 가장 쉬운 방법이 아닙니다. 
그래서 그것을 푸는 다른 방법은 우리기 지난 번에 이미 본 것을 하는 것입니다, 
즉, 기본적으로, 왜 가능한 모든 예를 단순히 열거해서 
그것들을 검사하지 않죠? 
여러분은 닭 0 마리와 돼지 20 마리를 가진다고 말할 수 있습니다, 
그것이 맞습니까? 
닭 1 마리와 돼지 19 마리를 가진다고 말할 수 있습니다, 그것이 맞습니까? 
닭 2 마리와 돼지 18 마리를 가진다고 말할 수 있습니다, 
여러분이 생각해 보세요. 
그래서 저는 열거하고 검사함으로써 이것을 풀 것입니다, 

Korean: 
그것은 주먹구구 알고리즘이라고 불리는 것의 예입니다. 
제가 그것을 하는 작은 루프를 
쓸 수 있다는 것을 의미합니다. 
좋아요, 우리 코드로 돌아가 봅시다. 
맞습니다, 이것을 옆으로 약간 빼 보겠습니다, 
그래서 저는 이것을 볼 수 있습니다. 
그리고 여러분이 보길 바라는 것은, 
저는 곧 여기서 이것을 강조할 것입니다, 그것은 이 두 코드입니다. 
알겠죠? 
풀어 봅시다. 
좋아요. 
여기 푸는 생각이 있습니다. 
저는 다리가 몇 개인지, 머리가 몇 개인지를 입력으로 가질 것입니다, 
그리고 작은 루프를 쓰고 
싶습니다. 
좋아요. 
저는 그것을 어떻게 하는지 압니다, 그렇죠? 
작은 루프를 씁니다, 
제가 하려는 모든 것은 여기서 FOR 루프를 돌리는 것입니다. 
저는 닭의 수가 이 범위가 되도록 할 것입니다. 
범위가 무엇인지 기억하세요, 
그것은 저에게 1이 마지막 값이 되는 것까지의 인티져의 튜플 또는 
컬렉션 또는 세트를 줍니다. 
그래서 그것은 저에게 총 머리 수가 되는 모든 것을 줍니다. 
그것을 알기 때문에, 저는 말할 수 있습니다, 좋아요, 돼지가 몇 마리인지, 
저는 총합을 갖는데, 그 양을 빼고, 
그리고 저는 알 수 있어요, 다리가 몇 개 인지요, 

English: 
an example of what's called
a brute-force algorithm.
Meaning, I'm just going
to write a little
loop that does that.
All right, so let's go
back to our code.
That's right, let me pull
this over a little bit,
so I can see it.
And what I'd like you to look
at, I'm going to highlight it
just for a second here, is
those two pieces of code.
OK?
Let's start with solve.
OK.
Here's the idea of solve.
I'm going to have it take in as
input how many legs I got,
how many heads do I have,
and I just want to
write a little loop.
OK.
I know how to do that, right?
Write a little loop, all
I'm going to do, is
run a FOR loop here.
I'm going to let the number of
chickens be in this range.
Remember what range does, it
gives me a set or a collection
or a tuple of integers from 0
up to 1 - is the last value,
so it's going to give me
everything from 0 up to the
total number of heads.
Knowing that, I'm going to say,
OK, how many pigs are
there, well that's just how
we're, however many I had
total, minus that amount, and
then I can see, how many legs

Korean: 
그리고 답을 구하기 위해 다리의 수를 검사해 봅니다, 
그것은 심지어 제가 시작한 다리 수와 같군요, 아! 
그것은 심지어 제가 시작한 다리 수와 같군요, 아! 
흥미롭습니다. 
리턴입니다.  
특히, 저는 튜플을 리턴 할 것입니다. 
그래서, 이 두 값의 쌍이나 컬렉션을요. 
만약 그렇지 않으면, 저는 루프로 돌아 갈 것입니다, 
그리고 무슨 일이 일어나는지 주목합니다.   
제가 루프 주변의 모든 방법을 가지면, 즉, 
FOR 루프를 통한 모든 방법을 가지면, 저는 여기를 통해 절대 길을 찾을 수 없습니다, 그
리고 제가 하려는 마지막 것은 두 배가 아닌 
그냥 특별한 수의 튜플이나 쌍을 
리턴하는 것입니다.
네. 
여러분은 저에게 괄호를 원하는지  
아닌지 말하고 있나요? 
좋아요. 
저는 이 언어를 싫어해요. 왜냐하면 저는 항상 괄호를 원하거든요. 
여러분이 꺾쇠 괄호를 볼 때 마다 매번, 안에 괄호를 두세요. 
알겠죠? 
고마워요, 크리스티. 
저는 결국 그것을 얻을 것입니다.
그것을 다 했으니까, 좋아요, 무엇을 얻었는지 주목하세요. 
먼저, 두 인자입니다. 
좋아요. 
그것이 말하는 모든 것은, 제가 이것을 부를 때, 
저는 이것이 작동하기 위해 두 인자를 넘겨 주어야 한다는 것입니다. 

English: 
does that give, and then I can
check, that the number of legs
that I would get for that
solution, is it even equal to
the number of legs I
started with, ah!
Interesting.
A return.
In particular, I'm going
to return a tuple.
So, a pair or collection
of those two values.
If it isn't, then I'm going to
go back around the loop, and
notice what happens.
If I get all the way around the
loop, that is, all the way
through that FOR loop and I
never find a path that takes
me through here, then the last
thing I'm going to do is
return a pair or a tuple
with a special
simple number none twice.
Yep.
Are you telling me I want
parens there and
not, and not braces?
All right.
I hate this language, because I
always want to have parens.
Every time you see a square
bracket, put a paren in.
All right?
Thank you, Christy.
I'll get it eventually .
Having done that, right,
notice what I've got.
First of all, two parameters.
It's OK.
All it says is, when I call
this, I need to pass in two
parameters for this to work.

English: 
All right?
Now, if I want to use that,
I'm going to use a second
piece of code here,
called Barnyard.
I'm going to read in a couple
of values, convert them into
integers, and then I'm
going to use solve to
get a solution out.
And what do I know
about solve?
It is going to give me back a
tuple a collection of two
things, and so check
out the syntax.
I can give two names, which
will get bound to the two
parts of that return tuple.
OK, pigs will be the first part,
chickens will be the
second part.
OK, and then once I've got that,
well, notice: I can then
check to see, did I return
that special symbol none?
Is the first part.
That says, I took the branch
through here that eventually
got to the end and said, there
wasn't a solution, in which
case I'm
going to print out, there ain't
no solution, otherwise
I'll print out the pieces.
All right, let's check it out.
Ah, what did I say?
Twenty and 56, Right?
OK, notice the form.

Korean: 
알겠죠? 
이제, 제가 그것을 사용하길 원하면, 
저는 여기 코드의 Barnyard라는 두 번째 부분을 사용할 것입니다. 
저는 몇 가지 값들에서 읽을 것입니다, 그것들을 인티져로 변환하세요, 
그리고 저는 해결책을 얻기 위해 해결을 
사용할 것입니다. 
제가 해결에 대해 무엇을 알죠? 
그것은 저에게 두 가지의 컬렉션이나 튜플을 돌려 줍니다, 
그리고 문법을 검사합니다.
저는 두 이름을 줄 수 있습니다. 
그것은 그 리턴 튜플의 두 부분으로 바인드 될 것입니다. 
네, 돼지는 첫 번째 부분이 될 것이고, 닭은 
두 번째 부분이 될 것입니다. 
네, 그리고 나서 제가 그것을 얻으면, 자, 주목하세요: 저는 검사할 수 있습니다, 
제가 특별한 기호를 아무것도 리턴하지 않았나요? 
그것이 첫 번째 부분입니다. 
저는 여기를 통해 branch를 갖고 그것은 결국 
끝에 이르고, 답이 없다고 말합니다, 
제가 프린트 하는 경우에, 
답이 없지 않습니다, 그렇지 않으면 
저는 그것들을 프린트 할 것입니다. 
좋아요, 확인해 봅시다. 
아, 제가 뭐라고 했죠? 
20 그리고 56, 맞나요? 
제, 형태에 주목하세요. 

English: 
I've got two parameters, they're
separated by a comma.
Ah, right.
Sorry?
Yeah, but I see-- it's legs and
heads, but it should not
still have--
Oh, sorry.
Thank you.
I've been doing the
wrong thing.
I want Barnyard this way, and if
I had looked when I opened
the paren, it would have shown
me a closed paren with no
parameters.
Aren't you glad I make mistakes,
so you can see how
well I can fix from these?
All right.
Now I call that, and it says,
tell me how many heads you
want, give it a 20, and tell
it how many legs you want,
give it 56, and it prints
out the answers.
I know, whoop-dee-doo.
But notice what's
inside if here.
First of all, notice
the modularity.
I've used solve.
All right?
Right there.
I've captured it as
a computation.
It's buried away, all the
details are suppressed.

Korean: 
저는 두 인자들을 갖습니다, 그것들은 콤마에 의해 분리됩니다. 
아, 맞아요. 
뭐라구요? 
네, 그러나 저는 – 그것은
다리와 머리이지만 여전히 가져야 합니다 -- 
오, 미안해요. 
고마워요. 
저는 잘못 된 것을 했군요. 
저는 Barnyard를 이런 방법으로 원했어요,
그리고 제가 괄호를 열었을 때 보면, 
그것은 저에게 인자가 없는 닫힌 괄호를 보여 줍니다. 
제가 실수를 해서 기쁘지 않나요? 
그래서 여러분은 제가 이것으로부터 어떻게 잘 고치는지 볼 수 있으니까요. 
좋아요.  
이제, 그것을 부르겠습니다, 그리고 그것은 저에게 
머리를 몇 개 원하는지 말하라고 합니다, 그것에 20을 줍니다, 그리고 다리를 몇 개 원하는지 말하라고 합니다, 
그것에 56을 줍니다, 그리고 답을 프린트 합니다, 
저는 알아요.  
그러나 여기서 내부에 있는 것을 주목하세요.
먼저, 모듈 방식을 주목하세요. 
저는 해법을 사용합니다. 
그렇죠? 
바로 저기서요. 
저는 그것을 computation 으로써 캡쳐 했습니다. 
그것은 묻어 둡니다, 모든 자세한 것들은 숨겨집니다. 

English: 
I can use that to return values,
which I can then use
elsewhere, which I did-- and
if I just come back and
highlight this-- inside
of that computation.
But I don't have to know, inside
of Barnyard, what the
values are used inside
of solve.
I don't know what the names of
the variables are, I don't
care, I can basically suppress
away that detail.
Second thing we saw is, that
using this as a computation, I
can return multiple values.
Which is actually of
real value to me
here as I use that.
OK.
Yeah.
Question.
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: Ah.
The question was, when it
returns, how does it
distinguish between local
and other things?
So let me try and answer that.
Inside of solve, solve creates
an environment where inside of
that, it has bindings for the
parameters it's going to use.
All right?
Like, number of-- wait, what
did we call a were solve--
number of legs and
number of heads.
OK, those are bound locally.

Korean: 
저는 그것을 값을 리턴하기 위해 사용할 수 있습니다, 
그것은 제가 어디서나 사용할 수 있는 것입니다, -- 
그리고 제가 돌아와서 이것을 강조하면 -- 그 computation의 내부에서요. 
그러나 저는 Barnyard의 내부에서 해법의 내부에서 
어떤 값이 사용되는지 알 필요가 없습니다. 
저는 변수들의 이름이 무엇인지 모릅니다, 저는 상관하지 않아요, 
저는 기본적으로 자세한 것들을 숨길 수 있어요. 
우리가 보는 두 번째 것은, 이것을 computation 으로 사용하는 것입니다, 
저는 많은 값들을 리턴할 수 있어요. 
그것은 제가 사용했을 때 여기 저에게 실제 값입니다. 
좋아요. 
네. 
질문하세요. 
아. 
질문은, 그것을 리턴 할 때, 
지역과 다른 것들 사이에서 그것은 어떻게 구별하죠? 
그래서 그것을 답해 봅시다. 
해법 안에서, 그것의 내부인 환경을 만드세요, 
그것은 그것이 사용할 인자들을 위한 바인딩을 가집니다. 
그렇죠? 
숫자처럼요 – 기다리세요, 우리가 부른 것은 해법인데요 – 
다리의 수와 머리의 수처럼요.   
좋아요, 그것들은 지역적으로 바인드 됩니다. 

Korean: 
해법이 되었을 때, 그것은 리턴하는 값을 
마무리 합니다. 
이것이 그것입니다.
그 명령문, 또는 그 값, 또는 그 값은, 
문자 그대로 지역 환경 밖으로 그것으로부터 
돌아 오는 값을 돌려 줍니다. 
그래서 특히, 해결된 리턴은 쌍입니다. 
그것은 아무 쌍도 아닐 수도 있습니다. 그것은 
우리가 거기에 만든 것인 답이 무엇이든 그것의 쌍이 될 수도 있습니다. 
그 값은 나와서 이제 Barnyard의 범위 내부에서 
가능합니다. 
좋아요. 
그리고 Barnyard는 그것을 사용합니다. 
질문입니까? 
여기서요? 
질문은, 왜 이 리턴이 
FOR와 같은 레벨에 있습니까? 
학생은 왜 그렇게 생각하나요? 
아닙니다. 
좋은 질문이에요. 
그렇죠? 
그래서 여기서 무엇이 일어나죠? 

English: 
When solve is done, it wraps up,
if you like, a value that
it returns.
Which is that.
That expression, or that
value, or that value,
literally gets passed back out
of that local environment to
the value that comes
back out of it.
So in particular, what's solved
returns is a pair.
It could be the pair of none,
none, it could be the pair of,
you know, whatever the answer
was that we put up there.
That value comes back out and
is now available inside the
scope of Barnyard.
OK.
And Barnyard then uses that.
Question?
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: Here?
So the question is, why is this
return on the same level
as the FOR?
Why do you think?
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: No.
Good question.
All right?
So what's going to
happen here?

Korean: 
제가 이 FOR 내부에 있으면, 좋아요, 저는 런 할 것입니다, 
제가 이 테스트가 맞는 곳에서 힛하면, 저는 그 리턴, 
전체 프로시저로부터의 리턴을 실행할 것입니다. 
네? 
그래서 리턴은 프로시저로부터 돌아옵니다
그래서 질문은, 왜 이 리턴이 이 단계 아래에 있나요? 
제가 이 FOR 루프 밖에서 실행하면, 
저는 FOR 루프의 끝에 이릅니다 리턴을 통해 저에게 가져다 주는 branch를 힛하지 않고도요, 
그리고 오직 저는 사실 말할 수 있습니다, 
저는 이 곳에 왔습니다, 리턴하는 어떤 값도 없습니다, 
저는 어떤 것도 리턴하지 않을 것입니다.  
저는 여전히 이 사탕을 제거하려고 합니다, 할로윈이 
다가 옵니다, 우리는 어디에 있죠? 
여기 있습니다, 고마워요. 
저는 제가 무엇을 하려는지 생각하지 않습니다, 저는 그랬어요. 
고마워요. 
말이 되나요? 
대답은 no 입니다. 
저는 튜플을 만들 괄호를 원하고 리스트와 튜플 사이의 차이에 대해 
정말 혼란스럽습니다. 

English: 
If I'm inside this FOR, OK, and
I'm running around, if I
ever hit a place where this
test is true, I'm going to
execute that return,
that return returns
from the entire procedure.
OK?
So the return comes back
from the procedure.
So the question was, why is
this return down at this
level, it says, well if I ever
execute out of this FOR loop,
I get to the end of the FOR
loop without hitting that
branch that took me through the
return, then and only then
do I want to actually say,
gee, I got to this place,
there isn't any value to return,
I'm going to return
none and none.
I'm still trying to get rid
of this candy, Halloween's
coming, where were we?
There's one, thank you.
I don't think I'm going
to make it, I did.
Thank you.
Make sense?
The answer is no, I want parens
to create tuple and I
get really confused about
the difference
between lists and tuples.

Korean: 
지금은, 코드가 작동하고 있습니다. 
Yes 가 답입니다. 그렇죠? 
그리고 우리는 우리가 여기서 튜플을 사용할지 리스트를 사용할지에 관한 
의견의 차이를 가집니다, 그렇죠? 
그러나 답은 Yes 입니다, 여러분은 할 수 있어요.
 그리고 저의 진짜 답변은, 그것을 해 보세요, 
왜냐하면 명백히 여러분은 제가 종종 이것을 잘못된 방법으로 하고 조교들이 저에게 
매번 힘든 시간을 준다고 말할 수 있으니까요. 
존. 
마이크가 켜져 있나요? 
네.
여러분이 다음 주에 볼 것인데, 
튜플들과 리스트는 같은 것에 매우 가깝습니다. 
여러분이 튜플을 사용하는 것을 버릴 수 있는 대부분 어떤 곳에서 
여러분은 리스트를 사용할 수 있습니다. 
네.
그러나 단어가 대부분이라고 강조하고 싶군요, 
왜냐하면 우리는 그것이 튜플을 예측하고 
여러분이 리스트를 사용하면 여러분이 에러 메시지를 얻게 되는 곳을 보게 될 것이니까요. 
그러나 우리는 다음주에 볼 것입니다.
맞아요, 이것들을 가져 가려고 진짜 프로가 오면 
저는 그 뒤에 숨을 것입니다. 
네. 
이것을 다시 해 봅시다. 
우리가 지금 하고 있는 것은 우리는 이 캡슐화를 만들고 있습니다. 
그런데 이제 여러분이 여기서 주목해야 할 것들 중 한 가지는 
이것이 본질적으로 간단한 문제들을 푼다는 것입니다. 

English: 
For now, the code is working.
Yes is the answer, all right?
And we're having a difference
of opinion as to whether we
should use a tuple or
a list here, right?
But the answer is
yes, you can.
And my real answer is, go try it
out, because obviously you
can tell I frequently do this
the wrong way and the TAs give
me a hard time every time.
John.
PROFESSOR JOHN GUTTAG:
Is the microphone on?
PROFESSOR ERIC GRIMSON: Yes.
PROFESSOR JOHN GUTTAG: As you'll
see next week, tuples
and lists are very close
to the same thing.
In almost any place where you
can get away with using tuples
you can use lists.
PROFESSOR ERIC GRIMSON: Yes.
PROFESSOR JOHN GUTTAG: But
want to emphasize word is
almost, because we'll see a
couple of places where if it
expects a tuple and you
use a list you'll
get an error message.
But we'll see all
that next week.
PROFESSOR ERIC GRIMSON: Right,
when the real pro comes in to
pick up the pieces I'm leaving
behind for him.
OK.
Let me pull this back up.
What we're doing now is we're
building this encapsulation.
Now one of the things you notice
here by the way is, you
know, this in essence just
solves the simple problems.

English: 
Suppose I now add one
other piece to this.
The farmer is not keeping a
great set of things so in
addition to pigs, and chickens
he raises spiders.
I have no idea why.
He's making silk I guess.
Right?
Why am I giving you
this example?
I want to show you how easy
it is to change the code.
But, notice, once I've
added this I
actually have a problem.
This is now an under-constrained
problem.
I have more unknowns than
I have equations.
So you know from algebra I can't
actually solve this.
There may be multiple
solutions to this.
What would I have to do
to change my code?
And the answer is fortunately
not a lot.
So I'm going to ask you to
look now at this set of
things, which is solve
1 and Barnyard 1.
OK.
The change is, well, on Barnyard
1 it looks much the
same as it did for Barnyard.
Right, I'm going to read in the
values of the number of
heads and the number of legs.
I'm going to use solve 1 as
before, but now I'm going to
bind out three variables.
And then I'm going to do
a similar thing to

Korean: 
이제 제가 이것에 한 가지 다른 것을 더한다고 가정해 보세요. 
농부는 돼지, 닭에 추가하여 그가 기르는 거미들의 
좋은 세트를 가지고 있지 않습니다. 
저는 왜 그런지 모릅니다. 
그는 비단을 만들고 있을 수도 있고요. 
네? 
왜 제가 이 예를 주나요? 
저는 여러분에게 코드를 바꾸는 것이 얼마나 쉬운지 보여주고 싶습니다. 
그러나, 주목하세요, 제가 한 번 이것을 더하면 저는 사실 문제를 가집니다. 
이것은 이제 제약 하의 문제 입니다. 
저는 방정식을 가지는 것 보다 알려지지 않은 것이 더 많습니다. 
그래서 여러분은 대수학으로부터 제가 실제로 이것을 풀 수 없다는 것을 압니다. 
이것을 푸는 많은 방법들이 있을 겁니다. 
제가 코드를 바꾸기 위해 무엇을 해야 하죠? 
그리고 답은 운 좋게도 많이 가 아닙니다. 
그래서 저는 여러분에게 이 세트를 보라고 요청하고 싶습니다, 
그것은 해결책 1과 Barnyard 1입니다. 
네. 
변화는 Barnyard 1 에서 그것이
Barnyard 를 위해 한 것과 더욱 같아 보입니다. 
좋아요, 저는 머리의 수와 다리의 수의 값에서 읽을 것입니다.  
좋아요, 저는 머리의 수와 다리의 수의 값에서 읽을 것입니다.  
저는 전처럼 해결책 1을 사용할 것이지만 지금 
세 변수들을 묶으려고 합니다. 
그리고 나서 이것을 프린트하는 것과 비슷한 것을 

English: 
print things out.
But would the solver do?
Well here what I'd like
to do is to run
through a couple of loops.
Right, how would I solve
this problem?
You can use the same enumerate
and check idea, but now say
gee let me pick how many
pigs there are.
Is that the one I used first?
Sorry, let me pick the number
of spiders there are.
Having chosen the number of
spiders, let me pick how many
chickens I have. With those two
in place, I now know how
many pigs I must have
and I can run
through the same solution.
The reason I'm showing you this
is this is another very
standard structure.
I now have two nested loops.
One running through a choice for
one parameter, another one
running through a choice
for a second parameter.
And then the rest
of the solution
looks much like before.
I'm going to get the total
number of legs out.
I'm going to check to see
if it's right or not.
And again I'm going to return
either a three tuple there or
a three tuple there.
It's part of what I want,
because I'm going to bind
those values out.

Korean: 
하려고 합니다. 
그러나 푸는 사람은 무엇을 하죠? 
여기서 제가 하고 싶은 것은 루프를 통해 
런하는 것입니다. 
좋아요, 제가 어떻게 이 문제를 풀 수 있죠? 
여러분은 같은 열거를 사용하고 생각을 검사할 수 있습니다, 그러나 
이제 저는 돼지가 몇 마리인지 골라 보겠습니다. 
제가 먼저 사용한 것입니까? 
미안해요, 거미의 수를 골라 보겠습니다. 
거미의 수를 고르면, 닭 몇 마리를 가지고 있는지 
고르겠습니다. 
이 둘을 가지고, 저는 이제 제가 가져야 하는 돼지가 몇 마리인지 압니다. 
그리고 같은 방법을 통해 런할 수 있습니다. 
제가 여러분에게 이것을 보여 주는 이유는 이것이 또 다른 
매우 표준적인 구조이기 때문입니다. 
저는 이제 두 nested 루프(루프 속의 루프)를 가집니다. 
하나는 한 인자 선택을 통해 런하는 것이고, 
또 다른 하나는 두 번째 인자 선택을 통해 런하는 것입니다. 그
리고 남은 해결책은 전과 더욱 같아 
보입니다. 
저는 다리의 총 수를 얻을 것입니다. 
저는 그것이 맞는지 아닌지 검사할 것입니다. 
그리고 다시 거기 세 튜플 또는 거기 세 튜플을 
리턴 할 것입니다.  
그것은 제가 원하는 부분입니다. 왜냐하면 저는 이 값들을 
바인드 할 것이니까요.

Korean: 
그리고 제가 그 예, Barnyard 1 를 런하면, 저는 우리가 그것에 20 개의 머리, 56 개의 
다리를 줄 것인지 모르겠어요; 그리고 그것은 답을 찾습니다.  
저는 어떤 다른 것을 런할 수 있어야 합니다. 
저는 모르겠어요, 저에게 수를 주세요. 
머리가 몇 개 인가요? 
누가 정수를 골라 보세요.
5요. 
5.
좋아요. 
다리는 몇 개죠? 
10?
좋아요. 
우리는 쉬운 것을 가졌군요. 
젠장 – 저는 이것을 하기 전에 
더 좋은 예제를 찾았어야 했어요. 
여기 돌연 변이 거미는 없습니다. 
좋아요, 제가 무엇을 했죠?  
저는 지금 약간 더 더했습니다. 
이제 저는 루프 쌍을 통해 런할 것입니다. 
다시 캡슐화에 주목하세요, 그것은 좋은 추상화가 이뤄지고 있어요, 
그것은 제가 원하는 것입니다. 
제가 이 단계를 얻으면, 한 해결책 보다 
더 많이 있을 것입니다. 
왜냐하면 제약 문제 하에서 많은 해결책들이 
있을 수 있으니까요. 
그래서 제가 그것들 모두를 캡쳐하거나 
프린트 한다고 가정해 보세요  

English: 
And if I run that example,
Barnyard 1, I don't know we'll
give it 20 heads, 56 legs;
and it find a solution.
I ought to be able to
run something else.
I don't know, give
me some numbers.
How many heads?
Pick an integer, somebody.
STUDENT: 5.
PROFESSOR ERIC GRIMSON: 5.
All right.
How many legs?
10?
All right.
We got an easy one.
Let's just for the
heck of it --
I should have found some
better examples
before I tried this.
No mutant spiders here.
OK, so what have I done?
I just added a little
bit more now.
I'm now running through
a pair of loops.
Again notice the encapsulation,
that nice
abstraction going on, which
is what I want.
Once I get to this stage though
by the way, there might
be more than one solution.
Because in an under-constrained
problem
there could be multiple
solutions.
So suppose I want to capture
all of them or
print all of them out.

Korean: 
저는 간단히 루프를 일반화함으로써 
그것을 할 수 있어야 합니다. 
그리고 그것은 여러분의 핸드아웃에 있는  
다음 코드 입니다. 
저는 여러분이 이것을 보도록 할 것입니다. 
여러분이 해결책 2를 보면, 그것은 같은 루프를 통해 
런하고, 모든 답을 프린트 할 것입니다.
그러나 그것은 계속 할 것입니다. 
다른 말로 그것은 그것이 하나를 찾았을 때 리턴하지 않습니다. 
그것은 그것들 모두를 통해 런할 것입니다. 
그렇죠? 
합리적인 것처럼 들리는군요. 
마지막 한 가지에 주목하세요. 
제가 그것을 하면, 모든 가능한 답변을 통해 런하세요, 
저는 여전히 알고 싶어요, 답이 없으면 어떡하죠? 
그 경우는 어떻게 리턴하나요? 
그리고 그것은 여러분에게 우리가 원하는 다른 작은 좋은 것을 보여줍니다. 
그것은 제가 이 코드를 보면, 
제가 여기 Solution Found 라는 변수를 만드는 것에 주목하세요. 처음엔 false로 바운드 되었었습니다. 
그 코드의 나머지는 루프들의 쌍입니다. 
거미들의 수를 고르세요. 
닭들의 수를 고르세요. 
그것은 돼지들의 수를 만듭니다. 
다리를 알아내 보세요. 
그것이 옳은지 살펴 보세요. 
그것이 옳으면, 저는 정보를 프린트 하지만 
또한 변수를 true로 바꿀 것입니다. 

English: 
Well I ought to be able
to do that by simply
generalizing the loop.
And that's what the next
piece of code on your a
hand out shows you.
I'm just going to let
you look at this.
If you look at solve 2, it's
going to run through the same
kind of loop, printing out
all of the answers.
But it's going to keep going.
In other words it doesn't just
return when it finds one, it's
going to run through
all of them.
All right?
Sounds like a reasonable
thing to do.
Notice one last piece.
If I'm going to do that, run
through all possible answers,
I still want to know,
gee, what if
there aren't any answers?
How do I return that case?
And that shows you one other
nice little thing we want to
do, which is if I look in this
code notice I set up a
variable up here called Solution
Found, initially
bound to false.
The rest of that code's
a pair of loops.
Pick the number of spiders.
Pick the number of chickens.
That sets up the
number of pigs.
Figure out the legs.
See if it's right.
If it is right, I'm going to
print out the information but
I'm also going to change
that variable to true.

Korean: 
그리고 그것은, 제가 바로 여기 이 점으로 갈 때 
루프들의 쌍의 끝에서, 저는 제가 답을 찾을 수 있는지 검사 할 수 있습니다. 
그리고 그렇지 않으면 그 경우에 
해결책이 없다고 출력합니다. 
그래서 이것은 여러분에게 다른 좋은 것을 줍니다. 
그것은 제가 지금 첫 해결책 찾을 수 있는 것입니다, 저는 모든 해결책들을 찾을 수 있습니다, 
그리고 저에게 제가 찾은 것이 무엇인지 알게 하는 내부 변수들을 
유지할 수 있습니다. 
여러분이 여러분의 함수를 쓸 때 많이 사용할 
트릭입니다. 
좋아요, 저는 마지막 10분에 끝내려고 합니다 
문제들에 대해 생각하는 함수를 어떻게 사용하는지 다른 변화를 
가지고요. 
그리고 그것은 순환의 생각을 도입하는 것입니다. 
여러분 중 얼마나 전에 사용한 그 용어에 대해 들어 봤나요? 
프로그래밍 언어의 관점에서 여러분 중 얼마나 전에 
사용한 그 용어에 대해 들어 봤나요? 
좋아요. 
나머지 학생들은, 불안해 하지 마세요. 
이것은 컴퓨터 과학자들이 실제 그들 보다 
더 똑똑해 보이기 위해 사용하는 허세 부리는 용어 이거든요. 

English: 
And that allows me then, at the
end of that pair of loops
when I get down to this point
right here, I can check to see
did I find any solution and if
not in that case print out
there is no solution.
So this gives you another nice
piece which is I can now look
for first solution, I can look
for all solutions, and I can
maintain some internal variables
that let me know
what I found.
A trick that you're going to
use a lot as you write your
own functions.
All right, I want to end up with
the last 10 minutes with
a different variation on how
to use functions to think
about problems. And that is to
introduce the idea of recursion.
How many of you have heard
the term used before?
How may have you heard the term
used before in terms of
programming languages?
Great.
For the rest you,
don't sweat it.
This is a highfalutin term that
computer scientists use
to try and make them look like
they're smarter than they
really are.

English: 
But it is a very handy way of
thinking about, not just how
to program, but how to
break problems down
into nice sized chunks.
And the idea behind recursion
I'm going to describe with a
simple example.
And then I'm going to show you
how we can actually use it.
The idea of recursion is that
I'm going to take a problem
and break it down into a simpler
version of the same
problem plus some steps
that I can execute.
I'm go to show you an example
of a procedure, sorry a
function, in a second.
But let me give you actually
an analogy.
If you look at US law, and you
look at the definition of the
US legal code that defines
the notion of a
natural born US citizen.
It's actually a wonderful
recursive definition.
So what's the definition?
If you're born in the United
States you are by definition a
natural born US citizen.
We call that a base case.

Korean: 
그러나 이것은 단지 프로그래밍 하는 방법 말고, 
프로그램을 좋은 사이즈의 덩어리로 나누는 방법에 대해 생각하는 
매우 유용한 방법입니다. 
그리고 순환 뒤의 생각은 저는 간단한 예를 
가지고 설명해 보겠습니다. 
그리고 나서 여러분에게 우리가 실제 그것을 어떻게 사용할 수 있는지 보여주겠습니다. 
순환의 생각은 제가 문제를 가지고 
그것을 같은 프로그램의 더 간단한 버전 더하기 
제가 실행할 수 있는 단계로 나누는 것입니다. 
저는 여러분에게 곧 프로시저의 예를 보여줄 것입니다, 
미안해요 함수 입니다. 
그러나 여러분에게 실제 비유를 주겠습니다. 
여러분이 미국 법을 보면, 
여러분은 미국 토박이 시민을 정의하는 미국 법 코드의 
정의를 볼 수 있습니다 
그것은 사실 환상적인 순환의 정의입니다. 
그래서 정의가 무엇인가요? 
여러분이 미국에서 태어났으면 여러분은 
정의에 의해 미국 토박이 시민입니다. 
우리는 그것을 기본 경우라고 부릅니다. 

English: 
It's basically the
simplest possible
solution to the problem.
Now if you were not born in
the United States, you may
still be, under definition, a
natural born US citizen if
you're born outside this United
States, both of your
parents are citizens of the
United States and at least one
parent has lived in
the United States.
There's a wonderful
legal expression.
But notice what that is.
It's a recursive definition.
How do you know that your
parents, at least one of your
parents satisfies
the definition?
Well I've reduced the problem
from am I a natural born US
citizen to is one
of my parents a
natural born US citizen?
And that may generalize again
and it keeps going until you
either get back to Adam
and Eve, I guess.
I don't think they were born in
the US as far as I know, or
you find somebody who satisfies
that definition or
you find that none
of your parents
actually are in that category.

Korean: 
그것은 기본적으로 문제를 푸는 가능한 가장 간단한 
해결책입니다. 
이제 여러분이 미국에서 태어나지 않았으면, 여러분은, 
정의 하에서, 여전히 미국 토박이 시민일 수도 있어요. 
여러분이 미국 밖에서 태어났으면, 여러분의 부모님 모두가 미국 시민이거나 
적어도 한 분이 미국에 살면 
미국 토박이 시민입니다. 
이것은 훌륭한 법적 표현입니다. 
그러나 그것이 무엇인지에 주목하세요. 
그것은 순환적인 정의입니다. 
여러분은 여러분의 부모님이나 적어도
한 분이 적어도 정의를 만족하는지 어떻게 알죠? 
저는 문제를 줄였습니다. 제 부모님 중 한 명이 미국 토박이 시민이면 
저는 미국 토박이 시민인가요? 
그리고 그것은 다시 일반화하고 여러분이 아담과 이브로 돌아올 때까지 
계속 합니다. 
저는 제가 아는 한 그들이 미국에서 태어나지 않았다고 생각해요, 
여러분은 그 정의를 만족하는 누군가를 찾거나 
여러분 부모님 중 아무도 실제 그 범주에 들지 않는 다는 것을 알 수도 있습니다. 

English: 
But that second one is called
the inductive step, or the
recursive step.
And in my words it says break
the problem into a simpler
version of the same problem
and some other steps.
And I think this is best
illustrated by giving you a
simple little piece of code.
I use simple advisedly here.
This is actually a piece of code
that is really easy to
think about recursively and is
much more difficult to think
about in other ways.
And the piece of code is suppose
I have a spring and I
want to know if it's
a palindrome.
Does it read the same
thing left to
right as right to left.
OK?
How would I solve that?
If the string has no elements
in it it is obviously a
palindrome.

Korean: 
그 두 번째는 귀납적인 단계 또는 
순환적인 단계라고 불립니다. 
그리고 그것은 문제를 같은 프로그램의 더 간단한 버전과 
다른 단계들로 나누라고 말합니다. 
저는 이것이 여러분에게 간단한 코드를 줌으로써 
가장 잘 설명 될 수 있다고 생각합니다. 
저는 심사 숙고하여 여기 간단한 것을 사용합니다. 
이것은 사실 순환적으로 생각하기 정말 쉬운 코드입니다. 
그리고 다른 방법으로 생각하기 
더욱 어렵습니다. 
그리고 코드는 가정해 보세요, 제가 스프링을 가지고 있고 
그것이 회문 인지 알고 싶다고요. 
회문은 앞에서부터 읽으나 뒤에서부터 읽으나 동일한 단어를 말합니다. 
알겠죠? 
저는 그것을 어떻게 풀죠? 
문자열이 그 안에 요소들이 없으면 
그것은 명백히 

Korean: 
회문 입니다.
기본적인 경우이죠. 
그것이 하나 보다 길면, 저는 무엇을 원하죠? 
저는 두 끝 점이 같은 문자인지 
검사하고 싶습니까? 
그리고 그렇다면, 오, 제가 알아야 하는 것은 
회문 중간에 있는 모든 것입니까?
저는 그것이 간단하게 들리는 것을 알지만, 제가 한 것을 주목하세요. 
저는 순환의 정의를 사용했습니다. 
저는 그것을 같은 프로그램의 더 작은 버전으로 줄였습니다. 
그것은 제가 더 작은 문자열의 
모든 예를 푸는 코드를 쓸 수 있으면, 제가 설명한 것은 
더 큰 크기의 것도 풀 수 있다는 것입니다. 
그리고 사실 그것은 정확히 제가 가진 것입니다. 
저는 여러분이 isPalindrome 라는 여기 
이 코드를 보았으면 좋겠어요. 
그것이 무엇을 말하는지 주목하세요. 
저는 s 라는 문자열을 넘겨 줄 것입니다. 그것을 지역적으로 바인드하고 
그것은 다음을 말합니다. 
그것은 이것이 1 길이의 문자열이면, 다 했다고 말하는 것입니다. 

English: 
If the string has one element
in it, it's a palindrome.
There's the base case.
If it's longer than one,
what do I want to do?
Well I'd like to check the two
end points to see are they the
same character?
And if they are, then oh,
I just need to know is
everything else in the
middle a palindrome?
I know it sounds simple, but
notice what I just did.
I just used a recursive
definition.
I just reduced it to a smaller
version of the same problem.
That is if I can write code that
would solve all instances
of smaller size strings, then
what I just described will
solve the larger size one.
And in fact that's exactly what
I have. I would like you
to look at this piece of
code right here called
isPalindrome.
Notice what it says.
I'm going to pass in a string,
call it s, binds it locally,
and it says the following.
It says if this is a string of
length 0 or 1, I'm done.

English: 
I'm going to return
the answer true.
Otherwise I'm going to check to
see is the first and last,
there's that - 1 indexing, is
the first and last element of
the string the same?
And if that's true is everything
in the string,
starting at the first element
and removing the last element,
a palindrome?
Let me remind you.
By saying first element remember
we start at 0 as the
initial indexing point.
Wonderful recursive
definition.
OK, let's try it out.
Go back over here and we're
going to say isPalindrome.
How did I actually spell this?
Palindrome with a capital P.
Only in New York, in Canada we
pronounce it Palindrome.
When you're teaching it you get
to call it your way, I'm
going to call it my way.
Sorry John, you're
absolutely right.
OK.
Notice by the way, there's
that nice speck going on
saying put a string here.
It's going to return true if
it's a PAIL-indrome and false

Korean: 
저는 옳은 값을 리턴할 것입니다. 
그렇지 않으면 저는 문자열의 첫 번째와 마지막 요소가 같은지 검사할 것입니다. 
그리고 그것이 옳으면 
첫 요소에서 
시작하여 
마지막 요소를 제거하는 
문자열의 모든 것은 회문 입니까? 
여러분에게 상기시키고 싶군요. 
첫 번째 요소를 말함으로써 우리는 
처음 인덱싱 점에서 시작한다는 것을 기억하세요. 
훌륭한 순환의 정의입니다. 
좋아요, 해 봅시다. 
여기로 돌아 와서 우리는 isPalindrome을 말할 것입니다. 
제가 이것을 사실 어떻게 철자를 썼죠? 
isPalindrome 에서 P는 대문자 P 입니다. 
오직 뉴욕과 캐나다에서만 우리는 그것을 Palindrome 이라고 발음합니다. 
여러분이 그것을 가르칠 때 그것을 
여러분의 방법으로 부르세요. 저는 제 방법으로 부르겠습니다.
미안해요 존, 당신이 절대적으로 맞습니다. 
좋아요. 
그런데 주목하세요, 문자열을 여기 놓으라고 
말하는 좋은 작은 반점이 있습니다. 
그것이 PAIL-indrome 이면 true를 리턴하고 

English: 
if it's a PAL-indrome.
And it says true.
Now maybe you're
bugged by this.
I know you're bugged by my
bad humor, but too bad.
Maybe you're bugged by this,
saying wait a minute, how does
this thing stop?
This is the kind of definition
that your high school geometry
teacher would have rapped
your knuckles over.
You can't define things in
terms of themselves.
This is an inductive
definition.
Actually we could prove
inductively that it holds, but
how do we know it stops?
Well notice what the computation
is doing. it's
looking first to see am I in the
base case, which I'm done.
If I'm not I'm just going to
reduce this to a smaller
computation.
And as long as that smaller
computation reduces to another
smaller computation, eventually
I ought to get to
the place where I'm down
in that base case.
And to see that I've written
another version of this, which
I'm going to use here, where I'm
going to give it a little
indentation.
I'm going to call this
palindrome 1.
Sorry about that.
Palindrome 1.

Korean: 
PAL-indrome 이면 false 를 리턴합니다. 
그리고 그것은 true라고 말합니다. 
이제 아마 여러분은 이것에 의해 괴로울 것입니다. 
저는 제 나쁜 유머, 너무 나쁜 유머에 의해 여러분이 괴롭다는 것을 알아요. 
이제 아마 여러분은 이것에 의해 괴로울 것입니다. 
잠깐만요, 이것이 어떻게 멈췄죠? 
이것은 여러분의 고등 학교 지리 선생님이 
여러분의 손가락 관절을 쥐어박는 정의입니다. 
여러분은 그것들의 관점에서 그것들을 정의할 수 없습니다. 
이것은 귀납적인 정의입니다. 
사실 우리는 귀납적으로 그것이 가지는 것을 입증할 수 있지만 
우리가 그것이 멈춘다는 것을 어떻게 알죠? 
Computation이 무엇을 하는지 주목하세요. 그것은 
제가 기본 경우에 있는지, 제가 다 했는지 봅니다. 
제가 그렇지 않으면 저는 이것을 더 작은 computation 으로 
줄일 것입니다. 
그 작은 computation이 또 다른 작은 computation 으로 줄어 드는 한, 
결과적으로 저는 제가 그 기본 경우에 있는 곳으로 
이르러야 합니다.  
그리고 이것의 다른 버전을 쓰기 위해, 
그것은 제가 여기 사용할 것입니다, 
그것은 제가 여기 사용할 것입니다, 
저는 그것에 약간 들여 쓰기를 할 것이고요. 저는 이것을 palindrome 1 이라고 부를 것입니다. 
미안해요. 
Palindrome 1 이에요. 

English: 
I'm going to give it a
little indentation so
that we can see this.
OK.
Code is right here.
And all it's doing is when I'm
getting into the different
places I'm simply printing out
information about where I am.
What I want you to see is notice
what happened here.
OK.
I'm calling palindrome
with that.
It first calls it
on that problem.
And the code over here says,
OK gee, if I'm in the base
case do something.
I'm not, so come down here check
that the two end points
a and a are the same and
call this again also.
Notice what happens.
There's this nice unwrapping
of the problem.
I just doubled the indentation
each time so you can see it.
So each successive call, notice
what's happening.
The argument is getting
reduced.
And we're going another
level in.
When we get down to this point,
we're calling it with
just a string of length one.

Korean: 
저는 그것에 들여쓰기를 해서 
우리가 이것을 볼 수 있도록 할 것입니다. 
좋아요. 
코드는 바로 여기 있습니다. 
그리고 그것이 하는 모든 것은 
제가 어디 있는지에 대한 정보를 간단히 찍어 주는 다른 곳으로 들어갈 때 입니다. 
여러분이 보길 바라는 것은 여기서 무슨 일이 일어 나는지 주목하세요. 
좋아요. 
저는 그것으로 Palindrome 을 부를 것입니다. 
그것은 먼저 그 문제에서 그것을 부릅니다. 
그리고 코드는 여기서 말합니다, 좋아요, 
제가 기본 경우에서 무엇을 하면, 
저는 여기로 와서 그 두 끝점 a를 검사하지 않습니다.
a는 같은 것이고 이것을 또한 다시 부릅니다. 
무슨 일이 일어 나는지 주목하세요. 
문제를 푸는 좋은 방법이 있습니다. 
저는 각 들여쓰기를 두 배로 해서 여러분은 그것을 볼 수 있습니다. 
그래서 각 연속적인 호출은, 무슨 일이 일어 나는지 주목하세요. 
인자는 줄어들 것입니다. 
그리고 우리는 다른 단계를 갈 것입니다. 
우리가 이 점으로 왔을 때, 우리는 그것을 1 길이의 
문자열로 부를 것입니다. 

English: 
At that point we're in the base
case and we can unwrap
this computation.
We say, ah, that's now true.
So I can return true here.
Given that that's true and I
already checked the two end
points, that's true,
that's true.
And I unwrap the computation
to get back.
You are going to have to
go play with this.
Rock it if you like to try
and see where it goes.
But I want to stress again, as
long as I do the base case
right and my inductive or
recursive step reduces it to a
smaller version of the same
problem, the code will in fact
converge and give me
out an answer.
All right, I want to show you
one last example of using
recursion because we're going
to come back to this.
This is a classic example
of using recursion.
And that is dating from
the 1200s and
it is due to Fibonacci.
Does anyone know the history
of what Fibonacci
was trying to do?
Sorry, let me re-ask that.
Fibonacci.
Which actually is son of Bonacci
which is the name of

Korean: 
기본 경우에 우리가 있는 점에서 
우리는 이 계산을 풀 수 있습니다. 
우리는, 아, 그것이 이제 옳습니다. 
그래서 저는 여기서 true 를 리턴 할 수 있습니다.  
그것이 true이고 제가 이미 두 끝 점을 체크 한 것을 고려 할 때, 
그것은 옳습니다, 그것은 true에요. 
그리고 저는 돌아갈 계산을 풀 것입니다.
여러분은 이것과 함께 가서 놀아야 합니다. 
여러분이 그것이 어디로 가는지 보려고 한다면 그것을 흔드세요. 
그러나 저는 다시 강조 하고 싶습니다, 제가 기본 경우를 하고 
제 귀납적인 또는 순환적인 단계가 그것을 같은 문제의 더 작은 버전으로 줄이는 한, 
코드는 사실 수렴되어 저에게 
답을 줄 것입니다. 
좋아요, 저는 여러분에게 순환을 사용한 한 가지 마지막 예를 보여 줄 것입니다. 
왜냐하면 우리는 이것으로 돌아 오려고 하니까요. 
이것은 순환을 사용하는 고전적인 예입니다.  
그리고 그것은 1200년 대부터 있었어요 
그리고 피보나치로 인한 것입니다. 
피보나치가 무엇을 하려고 했는지의 역사를 
아는 학생 있나요?
미안해요, 다시 물어 볼게요.  
피보나치 입니다. 
Bonacci의 아들이고 그의 아버지는 

English: 
his father who was apparently
a very friendly guy.
First of all, does anyone know
what a Fibonacci number is?
Wow.
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON: Right,
we're going to do that in a
second, but the answer is
Fibonacci numbers, we define
the first two.
Which are both defined to be,
or I can define them in
multiple ways, 0 and 1.
And then the next Fibonacci
number is the sum of the
previous two.
And the next number is the
sum of the previous two.
Do you know the history
of this?
STUDENT: [INAUDIBLE].
PROFESSOR ERIC GRIMSON:
Exactly.
Thank you.
Bad throw, I'm playing
for the Yankees.
Sorry John.
The answer is Fibonacci actually
was actually trying
to count rabbits back
in the 1200s.
The idea was that rabbits could
mate after a month, at
age one month.
And so he said, if you start off
with a male and a female,
at the end of one month they
have an offspring.
Let's assume they have
two offspring.
At the end of the next month
let's assume those offspring
have offspring.
Again a male and female.
The question was how many
rabbits do you have at
the end of a year?
At the end of two years?

Korean: 
명백히 매우 친근한 사람이었어요.  
무엇보다도, 피보나치 수열이 무엇인지 아는 학생 있나요? 
와우.
맞아요, 우리는 곧 그것을 할 것입니다, 
그러나 답은 피보나치 수열 입니다. 우리는 
첫 번째 두 수를 정의합니다. 
둘은 정의 되어 있거나 제가 다양한 방법으로 정의 할 수 있습니다.
0 그리고 1입니다. 
그리고 나서 다음 피보나치 수는 이전 두 수의 합입니다. 
그리고 나서 다음 피보나치 수는 이전 두 수의 합입니다. 
그리고 다음 피보나치 수는 이전 두 수의 합이고요. 
여러분은 이것의 역사를 아나요?  
정확해요. 
고마워요. 
나쁘게 던졌군요, 저는 양키스를 위해 뛰어야겠어요. 
미안해요 존. 
답은 피보나치가 사실 1200년 대에 
토끼들을 세려고 했었습니다. 
그 생각은 토끼들은 한 달 후에 짝짓기를 합니다, 
1달의 나이에요. 
그리고 그는, 여러분이 수컷과 암컷으로 시작하면, 
1달의 마지막에 그들은 새끼를 가진다고 말했습니다. 
그들이 두 자식을 가진다고 가정해 봅시다. 
다음 달의 말에 자식들이 자식을 가진다고 
가정해 보세요. 
계속 수컷과 암컷이요. 
질문은 1년의 말에 얼마나 많은 
토끼를 가지게 되나요? 
2년의 말에는요? 

Korean: 
더 많은 년의 말에는요? 
우리는 이것을 다음 단계의 정의로 할 수 있습니다. 
0의 쌍을 0달의 쌍의 수로 하고, 
사실 그것은 0이 되지 않습니다. 
1달의 쌍을 1로 합시다. 
그리고 나서 n 달의 쌍은 
n – 1 달의 쌍 더하기 n – 2 달의 쌍 입니다. 
이전 둘의 합이죠. 
제가 피보나치를 쓰면 여러분은 바로 저기서 볼 수 있습니다. 
그리고 제가 여러분에게 이것을 보여 주고 싶은 이유는 
순환이 두 배가 될 수 있다는 것을 주목하려고 입니다. 
그래서 이것은, x 값이 주어 졌을 때 그것이 1이거나 
두 경우 이면 1을 리턴 합니다. 
그렇지 않으면 이것을 더 간단한 문제의 
두 버전으로 나눕니다. 
Fib of x - 1 과 fib of x – 2, 그리고 나서 그것들의 합을 구해서 
그것을 값으로 리턴 합니다. 

English: 
At the end of more than that
number of years, and so.
We can do this with the
following level definition.
We're going to let pairs of 0,
the number of pairs at month
0, actually it would not
be 0 it would be 1.
We let the number of pairs
at month 1 be 1.
And then the number of pairs
at month n is the number of
pairs at month n - 1 plus
the number of pairs
at month n - 2.
The sum of the previous two.
If I write Fibonacci, you
see it right there.
And the reason I want to show
you this is to notice that the
recursion can be doubled.
So this says, given a value x,
if it's either 0 or 1, either
of those two cases,
just return 1.
Otherwise break this down
into two versions
of a simpler problem.
Fib of x - 1 and fib of x - 2,
and then take the sum of those
and return that as the value.

Korean: 
제가 두 다른 부가적 문제들을 가지면 저는 여기서 
이것을 잡을 두 기본적인 경우를 가져야 한다는데 주목하세요. 
그리고 제가 하나만 가지면 에러가 납니다. 
그리고 결과적으로, 저는 시작해서 토끼에 대해 물어 볼 수 있습니다. 
봅시다. 
12 달의 마지막에, 나쁘지 않군요. 
2년의 마지막에, 그리 좋지 않아 보여요. 
3년의 마지막에, 우리는 이제 호주에 있어요. 
토끼가 급속히 많아졌어요. 
사실 저는 그것이 돌아 온다고 생각하지 않아요, 
그래서 저는 그것을 멈출 것입니다. 왜냐하면 그것은 사실 여기서 다 쓰게 되거든요. 
그리고 저는 그것을 재 시작 할 것입니다.  
이것의 핵심은 무엇이죠? 
다시, 이제 저는 그것에 대해 순환적으로 생각할 수 있으니까, 
저는 비슷하게 그것들을 같은 문제의 더 간단한 
버전들로 나눌 수 있습니다. 
그것은 한 버전이 될 수 있어요. 
그것은 여러 버전들이 될 수도 있고요. 
그리고 우리는 이것을 반영하는 프로그램을 어떻게 짜는지에 
대해 생각해 보기 위해 용어를 통해 돌아 올 것입니다. 
제가 여러분에게 하고 싶은 마지막 핵심은, 여러분은 

English: 
Notice if I'm going to have two
different sub problems I
need to have two base cases
here to catch this.
And if I only had one
it would error out.
And as a consequence, I can go
off and ask about rabbits.
Let's see.
At the end of 12 months,
not so bad.
At the end of two years, we're
not looking so good.
At the end of three years,
we are now in Australia.
Overrun with rabbits.
In fact I don't think the thing
ever comes back, so I'm
going to stop it because it
really gets hung up here.
And I'm going to restart it.
What's the point of this?
Again, now that I can think
about things recursively, I
can similarly break things down
into simpler versions of
the same problem.
It could be one version.
It could be multiple versions.
And we're going to come back
throughout the term to think
about how to code programs
that reflect this.
The last point I want to make
to you is, you've started

English: 
writing programs that you
would think of as being
inherently iterative.
They're running through
a loop.
It's a common way of thinking
about problems. Some problems
are naturally tackled
that way.
There are other problems that
are much more naturally
thought of in a recursive
fashion.
And I would suggest palindrome
as a great example of that.
That's easy to think
about recursively.
It's much harder to think
about iteratively.
And you want to get into the
habit of deciding which is the
right one for you to use.
And with that, we'll
see you next time.

Korean: 
여러분이 선천적으로 반복인 것으로 생각하는 프로그램을 
쓰길 시작하는 것입니다. 
그들은 루프를 통해 런할 것입니다. 
그것은 문제들에 대해 생각하는 일반적인 방법입니다. 
어떤 문제들은 자연스럽게 그 방법으로 다뤄질 것입니다. 
순환의 방법에서 더욱 더 자연스럽게 생각되는 
다른 문제들이 있습니다. 
그리고 저는 palindrome을 그것의 훌륭한 예로 제안합니다. 
그것은 순환적으로 생각하는 쉬운 것입니다. 
반복적으로 생각하는 것은 더 어렵습니다. 
그리고 여러분은 어떤 것이 사용하기 옳은 것인지 
결정하는 습관으로 가길 원합니다. 
그리고 이것으로 하세요, 우리는 다음 시간에 보겠습니다.
