{"id":958,"date":"2010-10-18T18:12:15","date_gmt":"2010-10-18T18:12:15","guid":{"rendered":"http:\/\/pchero21.com\/?p=958"},"modified":"2010-10-18T18:12:15","modified_gmt":"2010-10-18T18:12:15","slug":"lec-1-mit-6-00-introduction-to-computer-science-and-programming-fall-2008","status":"publish","type":"post","link":"http:\/\/pchero21.com\/?p=958","title":{"rendered":"Lec 1 | MIT 6.00 Introduction to Computer Science and Programming, Fall 2008"},"content":{"rendered":"

<\/param><\/param><\/param><\/embed><\/object><\/p>\n

 \uccab \uc2dc\uac04. \uc218\uc5c5\uc758 \ub0b4\uc6a9\uacfc \uc55e\uc73c\ub85c \uc5b4\ub5a4 \uacf5\ubd80\ub4e4\uc744 \ud558\uac8c \ub420 \uac83\uc778\uc9c0\uc5d0 \ub300\ud55c \uc124\uba85\uc744 \ud558\uace0 \uc788\ub2e4.<\/p>\n

 \ud30c\uc774\uc36c\uc744 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4\ub85c \uc0ac\uc6a9\ud560 \uac83\uc774\uba70, \uadf8\uc678 \uae30\ud0c0 \ub4f1\ub4f1\uc5d0 \ub300\ud55c \uc774\uc57c\uae30\ub97c \ud558\uace0 \uc788\ub2e4.<\/p>\n

<\/p>\n

\n

The
\n following content is provided under a Creative Commons license. Your
\nsupport will help MIT OpenCourseware continue to offer high-quality
\neducational resources for free. To make a donation, or view additional
\nmaterials from hundreds of MIT courses, visit MIT OpenCourseware, at
\nocw.mit.edu.<\/p>\n

PROFESSOR: Good morning. Try it again. Good morning.<\/p>\n

STUDENTS: Good morning.<\/p>\n

PROFESSOR:
\n Thank you. This is 6.00, also known as Introduction to Computer Science
\n and Programming. My name is Eric Grimson, I have together Professor
\nJohn Guttag over here, we’re going to be lecturing the course this term.
\n I want to give you a heads up; you’re getting some serious firepower
\nthis term. John was department head for ten years, felt like a century,
\nand in course six, I’m the current department head in course six. John’s
\n been lecturing for thirty years, roughly. All right, I’m the young guy,
\n I’ve only been lecturing for twenty-five years. You can tell, I have
\nless grey hair than he does. What I’m trying to say to you is, we take
\nthis course really seriously. We hope you do as well. But we think it’s
\nreally important for the department to help everybody learn about
\ncomputation, and that’s what this course is about.<\/p>\n

What I want
\nto do today is three things: I’m going to start– actually, I shouldn’t
\nsay start, I’m going to do a little bit of administrivia, the kinds of
\nthings you need to know about how we’re going to run the course. I want
\nto talk about the goal of the course, what it is you’ll be able to do at
\n the end of this course when you get through it, and then I want to
\nbegin talking about the concepts and tools of computational thinking,
\nwhich is what we’re primarily going to focus on here. We’re going to try
\n and help you learn how to think like a computer scientist, and we’re
\ngoing to begin talking about that towards the end of this lecture and of
\n course throughout the rest of the lectures that carry on.<\/p>\n

Right,
\n let’s start with the goals. I’m going to give you goals in two levels.
\nThe strategic goals are the following: we want to help prepare freshmen
\nand sophomores who are interested in majoring in course six to get an
\neasy entry into the department, especially for those students who don’t
\nhave a lot of prior programming experience. If you’re in that category,
\ndon’t panic, you’re going to get it. We’re going to help you ramp in and
\n you’ll certainly be able to start the course six curriculum and do just
\n fine and still finish on target. We don’t expect everybody to be a
\ncourse six major, contrary to popular opinion, so for those are you not
\nin that category, the second thing we want to do is we want to help
\nstudents who don’t plan to major in course six to feel justifiably
\nconfident in their ability to write and read small pieces of code.<\/p>\n

For
\n all students, what we want to do is we want to give you an
\nunderstanding of the role computation can and cannot play in tackling
\ntechnical problems. So that you will come away with a sense of what you
\ncan do, what you can’t do, and what kinds of things you should use to
\ntackle complex problems.<\/p>\n

And finally, we want to position all
\nstudents so that you can easily, if you like, compete for things like
\nyour office and summer jobs. Because you’ll have an appropriate level of
\n confidence and competence in your ability to do computational problem
\nsolving. Those are the strategic goals.<\/p>\n

Now, this course is
\nprimarily aimed at students who have little or no prior programming
\nexperience. As a consequence, we believe that no student here is
\nunder-qualified for this course: you’re all MIT students, you’re all
\nqualified to be here. But we also hope that there aren’t any students
\nhere who are over-qualified for this course. And what do I mean by that?
\n If you’ve done a lot prior programming, this is probably not the best
\ncourse for you, and if you’re in that category, I would please encourage
\n you to talk to John or I after class about what your goals are, what
\nkind of experience you have, and how we might find you a course that
\nbetter meets your goals.<\/p>\n

Second reason we don’t want
\nover-qualified students in the class, it sounds a little nasty, but the
\nsecond reason is, an over-qualified student, somebody who’s, I don’t
\nknow, programmed for Google for the last five years, is going to have an
\n easy time in this course, but we don’t want such a student accidentally
\n intimidating the rest of you. We don’t want you to feel inadequate when
\n you’re simply inexperienced. And so, it really is a course aimed at
\nstudents with little or no prior programming experience. And again, if
\nyou’re not in that category, talk to John or I after class, and we’ll
\nhelp you figure out where you might want to go.<\/p>\n

OK. Those are
\nthe top-level goals of the course. Let’s talk sort of at a more tactical
\n level, about what do we want you to know in this course. What we want
\nyou to be able to do by the time you leave this course? So here are the
\nskills that we would like you to acquire. Right, the first skill we want
\n you to acquire, is we want you to be able to use the basic tools of
\ncomputational thinking to write small scale programs. I’m going to keep
\ncoming back to that idea, but I’m going to call it computational
\nthinking. And that’s so you can write small pieces of code. And small is
\n not derogatory here, by the way, it just says the size of things you’re
\n going to be able to do.<\/p>\n

Second skill we want you to have at the
\n end of this course is the ability to use a vocabulary of computational
\ntools in order to be able to understand programs written by others. So
\nyou’re going to be able to write, you’re going to be able to read.<\/p>\n

This
\n latter skill, by the way, is incredibly valuable. Because you won’t
\nwant to do everything from scratch yourself, you want to be able to look
\n at what is being created by somebody else and understand what is inside
\n of there, whether it works correctly and how you can build on it. This
\nis one of the few places where plagiarism is an OK thing. It’s not bad
\nto, if you like, learn from the skills of others in order to create
\nsomething you want to write. Although we’ll come back to plagiarism as a
\n bad thing later on.<\/p>\n

Third thing we want you to do, is to
\nunderstand the fundamental both capabilities and limitations of
\ncomputations, and the costs associated with them. And that latter
\nstatement sounds funny, you don’t think of computations having limits,
\nbut they do. There’re some things that cannot be computed. We want you
\nto understand where those limits are. So you’re going to be able to
\nunderstand abilities and limits.<\/p>\n

And then, finally, the last
\ntactical skill that you’re going to get out of this course is you’re
\ngoing to have the ability to map scientific problems into a
\ncomputational frame. So you’re going to be able to take a description of
\n a problem and map it into something computational.<\/p>\n

Now if you
\nthink about it, boy, it sounds like grammar school. We’re going to teach
\n you to read, we’re going to teach you to write, we’re going to teach
\nyou to understand what you can and cannot do, and most importantly,
\nwe’re going to try and give you the start of an ability to take a
\ndescription of a problem from some other domain, and figure out how to
\nmap it into that domain of computation so you can do the reading and
\nwriting that you want to do.<\/p>\n

OK, in a few minutes we’re going to
\n start talking then about what is computation, how are we going to start
\n building those tools, but that’s what you should take away, that’s what
\n you’re going to gain out of this course by the time you’re done.<\/p>\n

Now,
\n let me take a sidebar for about five minutes to talk about course
\nadministration, the administrivia, things that we’re going to do in the
\ncourse, just so you know what the rules are. Right, so, class is two
\nhours of lecture a week. You obviously know where and you know when,
\nbecause you’re here. Tuesdays and Thursdays at 11:00. One hour of
\nrecitation a week, on Fridays, and we’ll come back in a second to how
\nyou’re going to get set up for that. And nine hours a week of
\noutside-the-class work. Those nine hours are going to be primarily
\nworking on problem sets, and all the problems sets are going to involve
\nprogramming in Python, which is the language we’re going to be using
\nthis term.<\/p>\n

Now, one of the things you’re going to see is the
\nfirst problem sets are pretty easy. Actually, that’s probably wrong,
\nJohn, right? They’re very easy. And we’re going to ramp up. By the time
\nyou get to the end of the term, you’re going to be dealing with some
\nfairly complex things, so one of the things you’re going to see is,
\nwe’re going to make heavy use of libraries, or code written by others.
\nIt’ll allow you to tackle interesting problems I’ll have you to write
\nfrom scratch, but it does mean that this skill here is going to be
\nreally valuable. You need to be able to read that code and understand
\nit, as well as write your own.<\/p>\n

OK. Two quizzes. During the term,
\n the dates have already been scheduled. John, I forgot to look them up, I
\n think it’s October 2nd and November 4th, it’ll be on the course
\nwebsite. My point is, go check the course website, which by the way is
\nright there. If you have, if you know you have a conflict with one of
\nthose quiz dates now, please see John or I right away. We’ll arrange
\nsomething ahead of time. But if you– The reason I’m saying that is, you
\n know, you know that you’re getting married that day for example, we
\nwill excuse you from the quiz to get married. We’ll expect you come
\nright back to do the quiz by the way, but the– Boy, tough crowd. All
\nright. If you have a conflict, please let us know.<\/p>\n

Second thing
\nis, if you have an MIT documented special need for taking quizzes,
\nplease see John or I well in advance. At least two weeks before the
\nquiz. Again, we’ll arrange for this, but you need to give us enough
\nwarning so that we can deal with that.<\/p>\n

OK, the quizzes are open
\nbook. This course is not about memory. It’s not how well you can
\nmemorize facts: in fact, I think both John and I are a little sensitive
\nto memory tests, given our age, right John? This is not about how you
\nmemorize things, it’s about how you think. So they’re open note, open
\nbook. It’s really going to test your ability to think.<\/p>\n

The
\ngrades for the course will be assigned roughly, and I use the word
\nroughly because we reserve the right to move these numbers around a
\nlittle bit, but basically in the following percentages: 55% of your
\ngrade comes from the problem sets, the other 45% come from the quizzes.
\nAnd I should’ve said there’s two quizzes and a final exam. I forgot,
\nthat final exam during final period. So the quiz percentages are 10%,
\n15%, and 20%. Which makes up the other 45%.<\/p>\n

OK. Other
\nadministrivia. Let me just look through my list here. First problem set,
\n problem set zero, has already been posted. This is a really easy one.
\nWe intend it to be a really easy problem set. It’s basically to get you
\nto load up Python on your machine and make sure you understand how to
\ninteract with it.<\/p>\n

The first problem set will be posted shortly,
\nit’s also pretty boring– somewhat like my lectures but not John’s– and
\n that means, you know, we want you just to get going on things. Don’t
\nworry, we’re going to make them more interesting as you go along.<\/p>\n

Nonetheless,
\n I want to stress that none of these problems sets are intended to be
\nlethal. We’re not using them to weed you out, we’re using them to help
\nyou learn. So if you run into a problem set that just, you don’t get,
\nall right? Seek help. Could be psychiatric help, could be a TA. I
\nrecommend the TA. My point being, please come and talk to somebody. The
\nproblems are set up so that, if you start down the right path, it should
\n be pretty straight-forward to work it through. If you start down a
\nplausible but incorrect path, you can sometimes find yourself stuck in
\nthe weeds somewhere, and we want to bring you back in. So part of the
\ngoal here is, this should not be a grueling, exhausting kind of task,
\nit’s really something that should be helping you learn the material. If
\nyou need help, ask John, myself, or the TAs. That’s what we’re here for.<\/p>\n

OK.
\n We’re going to run primarily a paperless subject, that’s why the
\nwebsite is there. Please check it, that’s where everything’s going to be
\n posted in terms of things you need to know. In particular, please go to
\n it today, you will find a form there that you need to fill out to
\nregister for, or sign up for rather, a recitation.<\/p>\n

Recitations
\nare on Friday. Right now, we have them scheduled at 9:00, 10:00, 11:00,
\n12:00, 1:00, and 2:00. We may drop one of the recitations, just
\ndepending on course size, all right? So we reserve the right,
\nunfortunately, to have to move you around. My guess is that 9:00 is not
\ngoing to be a tremendously popular time, but maybe you’ll surprise me.
\nNonetheless, please go in and sign up. We will let you sign up for
\nwhichever recitation makes sense for you. Again, we reserve the right to
\n move people around if we have to, just to balance load, but we want you
\n to find something that fits your schedule rather than ours.<\/p>\n

OK.
\n Other things. There is no required text. If you feel exposed without a
\ntext book, you really have to have a textbook, you’ll find one
\nrecommended– actually I’m going to reuse that word, John, at least
\nsuggest it, on the course website. I don’t think either of us are
\nthrilled with the text, it’s the best we’ve probably found for Python,
\nit’s OK. If you need it, it’s there. But we’re going to basically not
\nrely on any specific text.<\/p>\n

Right. Related to that: attendance
\nhere is obviously not mandatory. You ain’t in high school anymore. I
\nthink both of us would love to see your smiling faces, or at least your
\nfaces, even if you’re not smiling at us every day. Point I want to make
\nabout this, though, is that we are going to cover a lot of material that
\n is not in the assigned readings, and we do have assigned readings
\nassociated with each one of these lectures. If you choose not to show up
\n today– or sorry, you did choose to show up today, if you choose not to
\n show up in future days– we’ll understand, but please also understand
\nthat the TAs won’t have a lot of patience with you if you’re asking a
\nquestion about something that was either covered in the readings, or
\ncovered in the lecture and is pretty straight forward. All right? We
\nexpect you to behave responsibly and we will as well. All right.<\/p>\n

I
\n think the last thing I want to say is, we will not be handing out class
\n notes. Now this sounds like a draconian measure; let me tell you why.
\nEvery study I know of, and I suspect every one John knows, about
\nlearning, stresses that students learn best when they take notes.
\nIronically, even if they never look at them. OK. The process of writing
\nis exercising both halves of your brain, and it’s actually helping you
\nlearn, and so taking notes is really valuable thing. Therefore we’re not
\n going to distribute notes. What we will distribute for most lectures is
\n a handout that’s mostly code examples that we’re going to do. I don’t
\nhappen to have one today because we’re not going to do a lot of code. We
\n will in future. Those notes are going to make no sense, I’m guessing,
\noutside of the lecture, all right? So it’s not just, you can swing by
\n11:04 and grab a copy and go off and catch some more sleep. What we
\nrecommend is you use those notes to take your own annotations to help
\nyou understand what’s going on, but we’re not going to provide class
\nnotes. We want you to take your own notes to help you, if you like, spur
\n your own learning process.<\/p>\n

All right. And then finally, I want
\nto stress that John, myself, all of the staff, our job is to help you
\nlearn. That’s what we’re here for. It’s what we get excited about. If
\nyou’re stuck, if you’re struggling, if you’re not certain about
\nsomething, please ask. We’re not mind readers, we can’t tell when you’re
\n struggling, other than sort of seeing the expression on your face, we
\nneed your help in identifying that. But all of the TAs, many of whom are
\n sitting down in the front row over here, are here to help, so come and
\nask. At the same time, remember that they’re students too. And if you
\ncome and ask a question that you could have easily answered by doing the
\n reading, coming to lecture, or using Google, they’re going to have less
\n patience. But helping you understand things that really are a
\nconceptual difficulty is what they’re here for and what we’re here for,
\nso please come and talk to us.<\/p>\n

OK. That takes care of the administrivia preamble. John, things we add?<\/p>\n

PROFESSOR
\n GUTTAG: Two more quick things. This semester, your class is being
\nvideotaped for OpenCourseware. If any of you don’t want your image
\nrecorded and posted on the web, you’re supposed to sit in the back three
\n rows.<\/p>\n

PROFESSOR GRIMSON: Ah, thank you. I forgot.<\/p>\n

PROFESSOR
\n GUTTAG: –Because the camera may pan. I think you’re all very
\ngood-looking and give MIT a good image, so please, feel free to be
\nfilmed.<\/p>\n

PROFESSOR GRIMSON: I’ll turn around, so if you want to,
\nyou know, move to the back, I won’t see who moves. Right. Great. Thank
\nyou, John.<\/p>\n

PROFESSOR GUTTAG: So that, the other thing I want to
\nmention is, recitations are also very important. We will be covering
\nmaterial in recitations that’re not in the lectures, not in the reading,
\n and we do expect you to attend recitations.<\/p>\n

PROFESSOR GRIMSON:
\nGreat. Thanks, John. Any questions about the administrivia? I know it’s
\nboring, but we need to do it so you know what the ground rules are.<\/p>\n

Good.
\n OK. Let’s talk about computation. As I said, our strategic goal, our
\ntactical goals, are to help you think like a computer scientist. Another
\n way of saying it is, we want to give you the skill so that you can make
\n the computer do what you want it to do. And we hope that at the end of
\nthe class, every time you’re confronted with some technical problem, one
\n of your first instincts is going to be, “How do I write the piece of
\ncode that’s going to help me solve that?”<\/p>\n

So we want to help you
\n think like a computer scientist. All right. And that, is an interesting
\n statement. What does it mean, to think like a computer scientist? Well,
\n let’s see. The primary knowledge you’re going to take away from this
\ncourse is this notion of computational problem solving, this ability to
\nthink in computational modes of thought. And unlike in a lot of
\nintroductory courses, as a consequence, having the ability to memorize
\nis not going to help you. It’s really learning those notions of the
\ntools that you want to use. What in the world does it mean to say
\ncomputational mode of thought? It sounds like a hifalutin phrase you use
\n when you’re trying to persuade a VC to fund you. Right. So to answer
\nthis, we really have to ask a different question, a related question;
\nso, what’s computation?<\/p>\n

It’s like a strange statement, right?
\nWhat is computation? And part of the reason for putting it up is that I
\nwant to, as much as possible, answer that question by separating out the
\n mechanism, which is the computer, from computational thinking. Right.
\nThe artifact should not be what’s driving this. It should be the notion
\nof, “What does it mean to do computation?”<\/p>\n

Now, to answer that,
\nI’m going to back up one more level. And I’m going to pose what sounds
\nlike a philosophy question, which is, “What is knowledge?” And you’ll
\nsee in about two minutes why I’m going to do this. But I’m going to
\nsuggest that I can divide knowledge into at least two categories. OK,
\nand what is knowledge? And the two categories I’m going to divide them
\ninto are declarative and imperative knowledge.<\/p>\n

Right. What in
\nthe world is declarative knowledge? Think of it as statements of fact.
\nIt’s assertions of truth. Boy, in this political season, that’s a really
\n dangerous phrase to use, right? But it’s a statement of fact. I’ll stay
\n away from the political comments. Let me give you an example of this.
\nRight. Here’s a declarative statement. The square root of x is that y
\nsuch that y squared equals x, y’s positive. You all know that. But what I
\n want you to see here, is that’s a statement of fact. It’s a definition.
\n It’s an axiom. It doesn’t help you find square roots. If I say x is 2, I
\n want to know, what’s the square root of 2, well if you’re enough of a
\ngeek, you’ll say 1.41529 or whatever the heck it is, but in general,
\nthis doesn’t help you find the square root. The closest it does is it
\nwould let you test. You know, if you’re wandering through Harvard Square
\n and you see an out-of-work Harvard grad, they’re handing out examples
\nof square roots, they’ll give you an example and you can test it to see,
\n is the square root of 2, 1.41529 or whatever. I don’t even get laughs
\nat Harvard jokes, John, I’m going to stop in a second here, all right?
\nAll right, so what am I trying to say here? It doesn’t — yeah, exactly.
\n We’re staying away from that, really quickly, especially with the
\ncameras rolling.<\/p>\n

All right. What am I trying to say? It tells you how you might test something but it doesn’t tell you how to.<\/p>\n

And
\n that’s what imperative knowledge is. Imperative knowledge is a
\ndescription of how to deduce something. So let me give you an example of
\n a piece of imperative knowledge. All right, this is actually a very old
\n piece of imperative knowledge for computing square roots, it’s
\nattributed to Heron of Alexandria, although I believe that the
\nBabylonians are suspected of knowing it beforehand. But here is a piece
\nof imperative knowledge. All right? I’m going to start with a guess, I’m
\n going to call it g. And then I’m going to say, if g squared is close to
\n x, stop. And return g. It’s a good enough answer. Otherwise, I’m going
\nto get a new guess by taking g, x over g, adding them, and dividing by
\ntwo. Then you take the average of g and x over g. Don’t worry about how
\ncame about, Heron found this out. But that gives me a new guess, and I’m
\n going to repeat.<\/p>\n

That’s a recipe. That’s a description of a set
\n of steps. Notice what it has, it has a bunch of nice things that we
\nwant to use, right? It’s a sequence of specific instructions that I do
\nin order. Along the way I have some tests, and depending on the value of
\n that test, I may change where I am in that sequence of instructions.
\nAnd it has an end test, something that tells me when I’m done and what
\nthe answer is. This tells you how to find square roots. it’s how-to
\nknowledge. It’s imperative knowledge.<\/p>\n

All right. That’s what
\ncomputation basically is about. We want to have ways of capturing this
\nprocess. OK, and that leads now to an interesting question, which would
\nbe, “How do I build a mechanical process to capture that set of
\ncomputations?” So I’m going to suggest that there’s an easy way to do
\nit– I realized I did the boards in the wrong order here– one of the
\nways I could do it is, you could imagine building a little circuit to do
\n this. If I had a couple of elements of stored values in it, I had some
\nwires to move things around, I had a little thing to do addition, little
\n thing to do division, and a something to do the testing, I could build a
\n little circuit that would actually do this computation.<\/p>\n

OK.
\nThat, strange as it sounds, is actually an example of the earliest
\ncomputers, because the earliest computers were what we call
\nfixed-program computers, meaning that they had a piece of circuitry
\ndesigned to do a specific computation. And that’s what they would do:
\nthey would do that specific computation. You’ve seen these a lot, right?
\n A good example of this: calculator. It’s basically an example of a
\nfixed-program computer. It does arithmetic. If you want play video games
\n on it, good luck. If you want to do word processing on it, good luck.
\nIt’s designed to do a specific thing. It’s a fixed-program computer.<\/p>\n

In
\n fact, a lot of the other really interesting early ones similarly have
\nthis flavor, to give an example: I never know how to pronounce this,
\nAtanasoff, 1941. One of the earliest computational things was a thing
\ndesigned by a guy named Atanasoff, and it basically solved linear
\nequations. Handy thing to do if you’re doing 1801, all right, or 1806,
\nor whatever you want to do those things in. All it could do, though, was
\n solve those equations.<\/p>\n

One of my favorite examples of an early
\ncomputer was done by Alan Turing, one of the great computer scientists
\nof all time, called the bombe, which was designed to break codes. It was
\n actually used during WWII to break German Enigma codes. And what it was
\n designed to do, was to solve that specific problem.<\/p>\n

The point
\nI’m trying to make is, fixed-program computers is where we started, but
\nit doesn’t really get us to where we’d like to be. We want to capture
\nthis idea of problem solving. So let’s see how we’d get there. So even
\nwithin this framework of, given a description of a computation as a set
\nof steps, in the idea that I could build a circuit to do it, let me
\nsuggest for you what would be a wonderful circuit to build.<\/p>\n

Suppose
\n you could build a circuit with the following property: the input to
\nthis circuit would be any other circuit diagram. Give it a circuit
\ndiagram for some computation, you give it to the circuit, and that
\ncircuit would wonderfully reconfigure itself to act like the circuits
\ndiagram. Which would mean, it could act like a calculator. Or, it could
\nact like Turing’s bombe. Or, it could act like a square root machine.<\/p>\n

So
\n what would that circuit look like? You can imagine these tiny little
\nrobots wandering around, right? Pulling wires and pulling out components
\n and stacking them together. How would you build a circuit that could
\ntake a circuit diagram in and make a machine act like that circuit?
\nSounds like a neat challenge.<\/p>\n

Let me change the game slightly.
\nSuppose instead, I want a machine that can take a recipe, the
\ndescription of a sequence of steps, take that as its input, and then
\nthat machine will now act like what is described in that recipe.
\nReconfigure itself, emulate it, however you want to use the words, it’s
\ngoing to change how it does the computation.<\/p>\n

That would be cool.
\n And that exists. It’s called an interpreter. It is the basic heart of
\nevery computer. What it is doing, is saying, change the game. This is
\nnow an example of a stored-program computer. What that means, in a
\nstored-program computer, is that I can provide to the computer a
\nsequence of instructions describing the process I want it to execute.
\nAnd inside of the machine, and things we’ll talk about, there is a
\nprocess that will allow that sequence to be executed as described in
\nthat recipe, so it can behave like any thing that I can describe in one
\nof those recipes.<\/p>\n

All right. That actually seems like a really
\nnice thing to have, and so let me show you what that would basically
\nlook like. Inside of a stored-program computer, we would have the
\nfollowing: we have a memory, it’s connected to two things; control unit,
\n in what’s called an ALU, an arithmetic logic unit, and this can take in
\n input, and spit out output, and inside this stored-program computer,
\nexcuse me, you have the following: you have a sequence of instructions.
\nAnd these all get stored in there. Notice the difference. The recipe,
\nthe sequence of instructions, is actually getting read in, and it’s
\ntreated just like data. It’s inside the memory of the machine, which
\nmeans we have access to it, we can change it, we can use it to build new
\n pieces of code, as well as we can interpret it. One other piece that
\ngoes into this computer– I never remember where to put the PC, John,
\ncontrol? ALU? Separate? I’ll put it separate– you have a thing called a
\n program counter.<\/p>\n

And here’s the basis of the computation. That
\nprogram counter points to some location in memory, typically to the
\nfirst instruction in the sequence. And those instructions, by the way,
\nare very simple: they’re things like, take the value out of two places
\nin memory, and run them through the multiplier in here, a little piece
\nof circuitry, and stick them back into someplace in memory. Or take this
\n value out of memory, run it through some other simple operation, stick
\nit back in memory. Having executed this instruction, that counter goes
\nup by one and we move to the next one. We execute that instruction, we
\nmove to the next one. Oh yeah, it looks a whole lot like that.<\/p>\n

Some
\n of those instructions will involve tests: they’ll say, is something
\ntrue? And if the test is true, it will change the value of this program
\ncounter to point to some other place in the memory, some other point in
\nthat sequence of instructions, and you’ll keep processing. Eventually
\nyou’ll hopefully stop, and a value gets spit out, and you’re done.<\/p>\n

That’s
\n the heart of a computer. Now that’s a slight misstatement. The process
\nto control it is intriguing and interesting, but the heart of the
\ncomputer is simply this notion that we build our descriptions, our
\nrecipes, on a sequence of primitive instructions. And then we have a
\nflow of control. And that flow of control is what I just described. It’s
\n moving through a sequence of instructions, occasionally changing where
\nwe are as we move around.<\/p>\n

OK. The thing I want you to take away
\nfrom this, then, is to think of this as, this is, if you like, a recipe.
\n And that’s really what a program is. It’s a sequence of instructions.
\nNow, one of things I left hanging is, I said, OK, you build it out of
\nprimitives. So one of the questions is, well, what are the right
\nprimitives to use? And one of the things that was useful here is, that
\nwe actually know that the set of primitives that you want to use is very
\n straight-forward.<\/p>\n

OK, but before I do that, let me drive home
\nthis idea of why this is a recipe. Assuming I have a set of primitive
\ninstructions that I can describe everything on, I want to know what can I
\n build. Well, I’m going to do the same analogy to a real recipe. So,
\nreal recipe. I don’t know. Separate six eggs. Do something. Beat until
\nthe– sorry, beat the whites until they’re stiff. Do something until an
\nend test is true. Take the yolks and mix them in with the sugar and
\nwater– No. Sugar and flour I guess is probably what I want, sugar and
\nwater is not going to do anything interesting for me here– mix them
\ninto something else. Do a sequence of things.<\/p>\n

A traditional
\nrecipe actually is based on a small set of primitives, and a good chef
\nwith, or good cook, I should say, with that set of primitives, can
\ncreate an unbounded number of great dishes. Same thing holds true in
\nprogramming. Right. Given a fixed set of primitives, all right, a good
\nprogrammer can program anything. And by that, I mean anything that can
\nbe described in one of these process, you can capture in that set of
\nprimitives.<\/p>\n

All right, the question is, as I started to say, is,
\n “What are the right primitives?” So there’s a little bit of, a little
\npiece of history here, if you like. In 1936, that same guy, Alan Turing,
\n showed that with six simple primitives, anything that could be
\ndescribed in a mechanical process, it’s actually algorithmically, could
\nbe programmed just using those six primitives.<\/p>\n

Think about that
\nfor a second. That’s an incredible statement. It says, with six
\nprimitives, I can rule the world. With six primitives, I can program
\nanything. A couple of really interesting consequences of that, by the
\nway, one of them is, it says, anything you can do in one programming
\nlanguage, you can do in another programming language. And there is no
\nprogramming language that is better– well actually, that’s not quite
\ntrue, there are some better at doing certain kinds of things– but
\nthere’s nothing that you can do in C that you can’t do in Fortran. It’s
\ncalled Turing compatibility. Anything you can do with one, you can do
\nwith another, it’s based on that fundamental result.<\/p>\n

OK. Now,
\nfortunately we’re not going to start with Turing’s six primitives, this
\nwould be really painful programming, because they’re down at the level
\nof, “take this value and write it onto this tape.” First of all, we
\ndon’t have tapes anymore in computers, and even if we did, you don’t
\nwant to be programming at that level. What we’re going to see with
\nprogramming language is that we’re going to use higher-level abstracts. A
\n broader set of primitives, but nonetheless the same fundamental thing
\nholds. With those six primitives, you can do it.<\/p>\n

OK. So where
\nare we here? What we’re saying is, in order to do computation, we want
\nto describe recipes, we want to describe this sequence of steps built on
\n some primitives, and we want to describe the flow of control that goes
\nthrough those sequence of steps as we carry on.<\/p>\n

So the last
\nthing we need before we can start talking about real programming is, we
\nneed to describe those recipes. All right, And to describe the recipes,
\nwe’re going to want a language. We need to know not only what are the
\nprimitives, but how do we make things meaningful in that language.
\nLanguage. There we go. All right. Now, it turns out there are– I don’t
\nknow, John, hundreds? Thousands? Of programming languages? At least
\nhundreds– of programming languages around.<\/p>\n

PROFESSOR JOHN GUTTAG: [UNINTELLIGIBLE]<\/p>\n

PROFESSOR
\n ERIC GRIMSON: True. Thank you. You know, they all have, you know, their
\n pluses and minuses. I have to admit, in my career here, I think I’ve
\ntaught in at least three languages, I suspect you’ve taught more, five
\nor six, John? Both of us have probably programmed in more than those
\nnumber of languages, at least programmed that many, since we taught in
\nthose languages.<\/p>\n

One of the things you want to realize is, there
\n is no best language. At least I would argue that, I think John would
\nagree. We might both agree we have our own nominees for worst language,
\nthere are some of those. There is no best language. All right? They all
\nare describing different things. Having said that, some of them are
\nbetter suited for some things than others.<\/p>\n

Anybody here heard of
\n MATLAB Maybe programmed in MATLAB? It’s great for doing things with
\nvectors and matrices and things that are easily captured in that
\nframework. But there’s some things that are a real pain to do in MATLAB.
\n So MATLAB’s great for that kind of thing.<\/p>\n

C is a great language for programming things that control data networks, for example.<\/p>\n

I
\n happen to be, and John teases me about this regularly, I’m an old-time
\nLisp programmer, and that’s how I was trained. And I happen to like Lisp
\n and Scheme, it’s a great language when you’re trying to deal with
\nproblems where you have arbitrarily structured data sets. It’s
\nparticularly good at that.<\/p>\n

So the point I want to make here is
\nthat there’s no particularly best language. What we’re going to do is
\nsimply use a language that helps us understand. So in this course, the
\nlanguage we’re going to use is Python. Which is a pretty new language,
\nit’s growing in popularity, it has a lot of the elements of some other
\nlanguages because it’s more recent, it inherits things from it’s
\npregenitors, if you like.<\/p>\n

But one of the things I want to stress
\n is, this course is not about Python. Strange statement. You do need to
\nknow how to use it, but it’s not about the details of, where do the
\nsemi-colons go in Python. All right? It’s about using it to think.<\/p>\n

And
\n what you should take away from this course is having learned how to
\ndesign recipes, how to structure recipes, how to do things in modes in
\nPython. Those same tools easily transfer to any other language. You can
\npick up another language in a week, couple of weeks at most, once you
\nknow how to do Python.<\/p>\n

OK. In order to talk about Python and
\nlanguages, I want to do one last thing to set the stage for what we’re
\ngoing to do here, and that’s to talk about the different dimensions of a
\n language. And there’re three I want to deal with.<\/p>\n

The first one
\n is, whether this is a high-level or low-level language. That basically
\nsays, how close are you the guts of the machine? A low-level language,
\nwe used to call this assembly programming, you’re down at the level of,
\nyour primitives are literally moving pieces of data from one location of
\n memory to another, through a very simple operation. A high-level
\nlanguage, the designer has created a much richer set of primitive
\nthings. In a high-level language, square root might simply be a
\nprimitive that you can use, rather than you having to go over and code
\nit. And there’re trade-offs between both.<\/p>\n

Second dimension is,
\nwhether this is a general versus a targeted language. And by that I
\nmean, do the set of primitives support a broad range of applications, or
\n is it really aimed at a very specific set of applications? I’d argue
\nthat MATLAB is basically a targeted language, it’s targeted at matrices
\nand vectors and things like that.<\/p>\n

And the third one I want to
\npoint out is, whether this is an interpreted versus a compiled language.
\n What that basically says is the following: in an interpreted language,
\nyou take what’s called the source code, the thing you write, it may go
\nthrough a simple checker but it basically goes to the interpreter, that
\nthing inside the machine that’s going to control the flow of going
\nthrough each one of the instructions, and give you an output. So the
\ninterpreter is simply operating directly on your code at run time.<\/p>\n

In
\n a compiled language, you have an intermediate step, in which you take
\nthe source code, it runs through what’s called a checker or a compiler
\nor both, and it creates what’s called object code. And that does two
\nthings: one, it helps catch bugs in your code, and secondly it often
\nconverts it into a more efficient sequence of instructions before you
\nactually go off and run it. All right?<\/p>\n

And there’s trade-offs
\nbetween both. I mean, an interpreted language is often easier to debug,
\nbecause you can still see your raw code there, but it’s not always as
\nfast. A compiled language is usually much faster in terms of its
\nexecution. And it’s one of the things you may want to trade off.<\/p>\n

Right.
\n In the case of Python, it’s a high-level language. I would argue, I
\nthink John would agree with me, it’s basically a general-purpose
\nlanguage. It happens to be better suited for manipulating strings than
\nnumbers, for example, but it’s really a general-purpose language. And
\nit’s primarily– I shouldn’t say primarily, it is an interpreted
\nlanguage. OK?<\/p>\n

As a consequence, it’s not as good as helping
\ndebug, but it does let you– sorry, that’s the wrong way of saying–
\nit’s not as good at catching some things before you run them, it is
\neasier at some times in debugging as you go along on the fly.<\/p>\n

OK.
\n So what does Python look like? In order to talk about Python–
\nactually, I’m going to do it this way– we need to talk about how to
\nwrite things in Python. Again, you have to let me back up slightly and
\nset the stage.<\/p>\n

Our goal is to build recipes. You’re all going to
\n be great chefs by the time you’re done here. All right? Our goal is to
\ntake problems and break them down into these computational steps, these
\nsequence of instructions that’ll allow us to capture that process.<\/p>\n

To
\n do that, we need to describe: not only, what are the primitives, but
\nhow do we capture things legally in that language, and interact with the
\n computer? And so for that, we need a language. We’re about to start
\ntalking about the elements of the language, but to do that, we also need
\n to separate out one last piece of distinction. Just like with a natural
\n language, we’re going to separate out syntax versus semantics.<\/p>\n

So
\n what’s syntax? Syntax basically says, what are the legal expressions in
\n this language? Boy, my handwriting is atrocious, isn’t it? There’s a
\nEnglish sequence of words. It’s not since syntactically correct, right?
\nIt’s not a sentence. There’s no verb in there anywhere, it’s just a
\nsequence of nouns. Same thing in our languages. We have to describe how
\ndo you put together legally formed expressions. OK? And as we add
\nconstructs to the language, we’re going to talk about.<\/p>\n

Second
\nthing we want to talk about very briefly as we go along is the semantics
\n of the language. And here we’re going to break out two pieces; static
\nsemantics and full semantics. Static semantics basically says which
\nprograms are meaningful. Which expressions make sense. Here’s an English
\n sentence. It’s syntactically correct. Right? Noun phrase, verb, noun
\nphrase. I’m not certain it’s meaningful, unless you are in the habit of
\ngiving your furniture personal names.<\/p>\n

What’s the point? Again,
\nyou can have things that are syntactically legal but not semantically
\nmeaningful, and static semantics is going to be a way of helping us
\ndecide what expressions, what pieces of code, actually have real meaning
\n to it. All right?<\/p>\n

The last piece of it is, in addition to
\nhaving static semantics, we have sort of full semantics. Which is, what
\ndoes the program mean? Or, said a different way, what’s going to happen
\nwhen I run it? That’s the meaning of the expression. That’s what you
\nwant. All right? You want to know, what’s the meaning of this piece of
\ncode? When I run it, what’s going to happen? That’s what I want to
\nbuild.<\/p>\n

The reason for pulling this out is, what you’re going to
\nsee is, that in most languages, and certainly in Python– we got lots of
\n help here– all right, Python comes built-in with something that will
\ncheck your static, sorry, your syntax for you. And in fact, as a
\nsidebar, if you turn in a problem set that is not syntactically correct,
\n there’s a simple button that you push that will check your syntax. If
\nyou’ve turned in a program that’s not syntactically correct, the TAs
\ngive you a zero. Because it said you didn’t even take the time to make
\nsure the syntax is correct. The system will help you find it. In Python,
\n it’ll find it, I think one bug at a time, right John? It finds one
\nsyntax error at a time, so you have to be a little patient to do it, but
\n you can check that the syntax is right.<\/p>\n

You’re going to see
\nthat we get some help here on the static semantics, and I’m going to do
\nan example in a second, meaning that the system, some languages are
\nbetter than others on it, but it will try and help you catch some things
\n that are not semantically correct statically. In the case of Python, it
\n does that I think all at run time. I’m looking to you again, John, I
\nthink there’s no pre-time checks. Its– sorry?<\/p>\n

PROFESSOR JOHN GUTTAG: [UNINTELLIGIBLE]<\/p>\n

PROFESSOR
\n ERIC GRIMSON: There is some. OK. Most of them, I think though, are
\nprimarily caught at run time, and that’s a little bit of a pain because
\nyou don’t see it until you go and run the code, and there are some,
\nactually we’re going to see an example I think in a second where you
\nfind it, but you do get some help there.<\/p>\n

The problem is, things
\nthat you catch here are actually the least worrisome bugs. They’re easy
\nto spot, you can’t run the program with them there, so you’re not going
\nto get weird answers. Not everything is going to get caught in static
\nsemantics checking. Some things are going to slide through, and that’s
\nactually a bother. It’s a problem. Because it says, your program will
\nstill give you a value, but it may not be what you intended, and you
\ncan’t always tell, and that may propagate it’s way down through a whole
\nbunch of other computations before it causes some catastrophic failure.
\nSo actually, the problem with static semantics is you’d like it to catch
\n everything, you don’t always get it. Sadly we don’t get much help here.
\n Which is where we’d like it. But that’s part of your job.<\/p>\n

OK.
\nWhat happens if you actually have something that’s both syntactically
\ncorrect, and appears to have correct static semantics, and you run it?
\nIt could run and give you the right answer, it could crash, it could
\nloop forever, it could run and apparently give you the right answer. And
\n you’re not always going to be able to tell. Well, you’ll know when it
\ncrashes, that doesn’t help you very much, but you can’t always tell
\nwhether something’s stuck in an infinite loop or whether it’s simply
\ntaking a long time to compute. You’d love to have a system that spots
\nthat for you, but it’s not possible.<\/p>\n

And so to deal with this
\nlast one, you need to develop style. All right? Meaning, we’re going to
\ntry to help you with how to develop good programming style, but you need
\n to write in a way in which it is going to be easy for you to spot the
\nplaces that cause those semantic bugs to occur.<\/p>\n

All right. If
\nthat sounds like a really long preamble, it is. Let’s start with Python.
\n But again, my goal here is to let you see what computation’s about, why
\n we need to do it, I’m going to remind you one last time, our goal is to
\n be able to have a set of primitives that we combine into complex
\nexpressions, which we can then abstract to treat as primitives, and we
\nwant to use that sequence of instructions in this flow of control
\ncomputing, in order to deduce new information. That imperative knowledge
\n that we talked about right there. So I’m going to start today, we have
\nabout five or ten minutes left, I think, in order– sorry, five minutes
\nleft– in order to do this with some beginnings of Python, and we’re
\ngoing to pick this up obviously, next time, so; simple parts of Python.<\/p>\n

In
\n order to create any kinds of expressions, we’re going to need values.
\nPrimitive data elements. And in Python, we have two to start with; we
\nhave numbers, and we have strings. Numbers is what you’d expect. There’s
\n a number. There’s another number. All right? Strings are captured in
\nPython with an open quote and some sequence of characters followed by a
\nclosed quote.<\/p>\n

Associated with every data type in Python is a
\ntype, which identifies the kind of thing it is. Some of these are
\nobvious. Strings are just a type on their own. But for numbers, for
\nexample, we can have a variety of types. So this is something that we
\nwould call an integer, or an INT. And this is something we would call a
\nfloating point, or a float. Or if you want to think of it as a real
\nnumber. And there’s some others that we can see.<\/p>\n

We’re going to
\nbuild up this taxonomy if you like, but the reason it’s relevant is,
\nassociated with each one of those types is a set of operators that
\nexpect certain types of input in order to do their job. And given those
\ntypes of input, will get back output.<\/p>\n

All right. In order to
\ndeal with this, let me show you an example, and I hope that comes up,
\ngreat. What I have here is a Python shell, and I’m going to just show
\nyou some simple examples of how we start building expressions. And
\nthis’ll lead into what you’re going to see next time as well as what
\nyou’re going to do tomorrow. So. Starting with the shell, I can type in
\nexpressions.<\/p>\n

Actually, let me back up and do this in video. I
\ncan type in a number, I get back a number, I can type in a string, I get
\n back the string. Strings, by the way, can have spaces in them, they can
\n have other characters, it’s simply a sequence of things, and notice, by
\n the way, that the string five– sorry, the string’s digit five digit
\ntwo is different than the number 52. The quotes are around them to make
\nthat distinction. We’re going to see why in a second.<\/p>\n

What I’m
\ndoing, by the way, here is I’m simply typing in expressions to that
\ninterpreter. It’s using its set of rules to deduce the value and print
\nthem back out. Things I might like to do in here is, I might like to do
\ncombinations of things with these. So we have associated with simple
\nthings, a set of operations. So for numbers, we have the things you’d
\nexpect, the arithmetics. And let me show you some examples of that.<\/p>\n

And
\n actually, I’m going to do one other distinction here. What I typed in,
\nthings like– well, let me start this way– there’s an expression. And
\nin Python the expression is, operand, operator, operand, when we’re
\ndoing simple expressions like this, and if I give it to the interpreter,
\n it gives me back exactly what you’d expect, which is that value. OK?<\/p>\n

The
\n distinction I’m going to make is, that’s an expression. The interpreter
\n is going to get a value for it. When we start building up code, we’re
\ngoing to use commands. Or statements. Which are actually things that
\ntake in a value and ask the computer to do something with it. So I can
\nsimilarly do this, which is going to look strange because it’s going to
\ngive me the same value back out, but it actually did a slightly
\ndifferent thing.<\/p>\n

And notice, by the way, when I typed it how
\nprint showed up in a different color? That’s the Python saying, that is a
\n command, that is a specific command to get the value of the expression
\nand print it back out. When we start writing code, you’re going to see
\nthat difference, but for now, don’t worry about it, I just want to plant
\n that idea.<\/p>\n

OK. Once we’ve got that, we can certainly, though,
\ndo things like this. Notice the quotes around it. And it treats it as a
\nstring, it’s simply getting me back the value of that string, 52 times
\n7, rather than the value of it. Now, once we’ve got that, we can start
\ndoing things. And I’m going to use print here– if I could type, in
\norder to just to get into that, I can’t type, here we go– in order to
\nget into the habit. I can print out a string. I can print out– Ah!–
\nHere’s a first example of something that caught one of my things. This
\nis a static semantic error.<\/p>\n

So what went on here? I gave it an
\nexpression that had an operand in there. It expected arithmetic types.
\nBut I gave two strings. And so it’s complaining at me, saying, you can’t
\n do this. I don’t know how to take two strings and multiply them
\ntogether. Unfortunately– now John you may disagree with me on this
\none– unfortunately in Python you can, however, do things like this.
\nWhat do you figure that’s going to do? Look legal? The string three
\ntimes the number three? Well it happens to give me three threes in a
\nrow.<\/p>\n

I hate this. I’m sorry, John, I hate this. Because this is
\noverloading that multiplication operator with two different tasks. It’s
\nsaying, if you give me two numbers, I’ll do the right thing. If you give
\n me a number and a string, I’m going to concatenate them together, it’s
\nreally different operations, but nonetheless, it’s what it’s going to
\ndo.<\/p>\n

STUDENT: [UNINTELLIGIBLE]<\/p>\n

PROFESSOR ERIC GRIMSON:
\nThere you go. You know, there will be a rebuttal phase a little later
\non, just like with the political debates, and he likes it as a feature, I
\n don’t like it, you can tell he’s not a Lisp programmer and I am.<\/p>\n

All
\n right. I want to do just a couple more quick examples. Here’s another
\none. Ah-ha! Give you an example of a syntax error. Because 52A doesn’t
\nmake sense. And you might say, wait a minute, isn’t that a string, and
\nthe answer’s no, I didn’t say it’s a string by putting quotes around it.
\n And notice how the machine responds differently to it. In this case it
\nsays, this is a syntax error, and it’s actually highlighting where it
\ncame from so I can go back and fix it.<\/p>\n

All right. Let’s do a
\ncouple of other simple examples. All right? I can do multiplication.
\nI’ve already seen that. I can do addition. Three plus five. I can take
\nsomething to a power, double star, just take three to the fifth power. I
\n can do division, right? Whoa. Right? Three divided by five is zero?
\nMaybe in Bush econom– no, I’m not going to do any political comments
\ntoday, I will not say that, all right?<\/p>\n

What happened? Well, this
\n is one of the places where you have to be careful. It’s doing integer
\ndivision. So, three divided by five is zero, with a remainder of three.
\nSo this is the correct answer. If I wanted to get full, real division, I
\n should make one of them a float. And yes, you can look at that and say,
\n well is that right? Well, up to some level of accuracy, yeah, that’s .6
\n is what I’d like to get out.<\/p>\n

All right. I can do other things.
\nIn a particular, I have similar operations on strings. OK, I can
\ncertainly print out strings, but I can actually add strings together,
\nand just as you saw, I can multiply strings, you can kind of guess what
\nthis is going to do. It is going to merge them together into one thing. I
\n want– I know I’m running you slightly over, I want to do one last
\nexample, it’s, I also want to be able to do, have variables to store
\nthings. And to do that, in this it says, if I have a value, I want to
\nkeep it around, to do that, I can do things like this.<\/p>\n

What does
\n that statement do? It says, create a name for a variable– which I just
\n did there, in fact, let me type it in– mystring, with an equal sign,
\nwhich is saying, assign or bind to that name the value of the following
\nexpression. As a consequence, I can now refer to that just by its name.
\nIf I get the value of mystring, there it is, or if I say, take mystring
\nand add to it the string, mylastname, and print it back out.<\/p>\n

So
\nthis is the first start of this. What have we done? We’ve got values,
\nnumbers and strings. We have operations to associate with them. I just
\nthrew a couple up here. You’re going to get a chance to explore them,
\nand you’ll see not only are there the standard numerics for strings,
\nthere are things like length or plus or other things you can do with
\nthem. And once I have values, I want to get a hold of them so I can give
\n them names. And that’s what I just did when I bound that. I said, use
\nthe name mystring to be bound to or have the value of Eric, so I can
\nrefer to it anywhere else that I want to use it.<\/p>\n

And I apologize
\n for taking you over, we’ll come back to this next time, please go to
\nthe website to sign up for recitation for tomorrow.<\/p>\n<\/div>\n

<\/p>\n","protected":false},"excerpt":{"rendered":"

 \uccab \uc2dc\uac04. \uc218\uc5c5\uc758 \ub0b4\uc6a9\uacfc \uc55e\uc73c\ub85c \uc5b4\ub5a4 \uacf5\ubd80\ub4e4\uc744 \ud558\uac8c \ub420 \uac83\uc778\uc9c0\uc5d0 \ub300\ud55c \uc124\uba85\uc744 \ud558\uace0 \uc788\ub2e4.  \ud30c\uc774\uc36c\uc744 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4\ub85c \uc0ac\uc6a9\ud560 \uac83\uc774\uba70, \uadf8\uc678 \uae30\ud0c0 \ub4f1\ub4f1\uc5d0 \ub300\ud55c \uc774\uc57c\uae30\ub97c \ud558\uace0 \uc788\ub2e4. The following content is provided under a Creative Commons license. Your support will help … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[27],"tags":[259,260],"_links":{"self":[{"href":"http:\/\/pchero21.com\/index.php?rest_route=\/wp\/v2\/posts\/958"}],"collection":[{"href":"http:\/\/pchero21.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/pchero21.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/pchero21.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/pchero21.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=958"}],"version-history":[{"count":0,"href":"http:\/\/pchero21.com\/index.php?rest_route=\/wp\/v2\/posts\/958\/revisions"}],"wp:attachment":[{"href":"http:\/\/pchero21.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=958"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/pchero21.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=958"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/pchero21.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=958"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}