If you're seeing this message, it means we're having trouble loading external resources on our website.

If you're behind a web filter, please make sure that the domains ***.kastatic.org** and ***.kasandbox.org** are unblocked.

Main content

Current time:0:00Total duration:12:06

Voiceover: What I want to do in this video is look at the data from the last video and make sure we understand it in maybe a more visual way. What I've done is, in
this graph over here, I used the lines of code per month, so this right over here. I used this, or this was what I used on my horizontal axis, so I kind of, if you view it in terms of independent and dependent variables, I kind of made this the
independent variable now. Given a certain number of lines of code you want to produce per month, what is the fixed cost, the variable cost, and the total cost, so this is on this axis right over here. This is lines of code, lines of code per month per month, right over there, and then you see it
goes up to about 12,000, and we see that covers
the entire range of data that we would have to worry
about right over here. On the vertical axis, as I just alluded to, we are plotting the cost, so we're going to plot the fixed cost, the variable cost, and the total cost. We see that there in our little legend. The fixed cost, no matter how many lines
of code we've produced, this is a little bit different than the way we thought
about it in the last video. In the last video, we said, "How many programmers do we have, "and what is going to be our fixed cost, "our variable cost, our total cost?" Now we're thinking about it in terms of lines of code per month, but no matter how many lines of code per month we produce within reason, our fixed costs are the same, $15,000 per month for the office space, the food in the office, the water cooler, the project manager, things like that. We see it right over here. This pale green line,
that is our fixed cost. That is our fixed cost. No matter how many lines
of code we produce, we are using exactly $15,000 per month. This is $15,000 right over there. Then you have your variable costs in this orange color, so the variable costs in the orange color, and we can see how the points are plotted. When you have no lines of code per month, your variable costs are 0. That's this point right over there. When you have 4,000 lines of code, your variable costs are 10,000. That's that point right over there. When you have, let me pick up a random point over here, when you have 11,400
lines of code per month, your variable costs are 70,000. 11,400, let's see. This is about 11,000, 11,400, and your costs are $70,000. That's that point right over there. Then, finally, your total costs, or the sum of the fixed
plus the variable costs, and we've plotted this in this blue color, so the total costs, which is in blue right over here, it's really just the sum of
this green horizontal line and this orange line. Another way of thinking about it, take this orange line at any given point. That's the variable cost. Add the fixed cost, which is 15,000. It shifts you up to that blue line. So at any point, that
blue line is exactly, is exactly $15,000 higher. $15,000 higher than the orange line. You see it even over here, where it kind of bends back on itself. Then you're probably saying, "Well, why is it bending
back on itself like that?" And this goes straight
to what we talked about in the last video. That as we add more and more programmers, the average productivity
per programmer goes down because they have to
start meeting each other and coordinate with each other, and maybe they undo each other's work, and then there's some point at which, even when you add more resources, it actually decreases productivity. So we're adding more and more resources, and I don't have them plotted here, but we keep adding more
and more developers, and we get to this point where we're able to generate 11,400 lines of code per month, but then all of a sudden, as we add more developers, it still adds cost, because obviously they're
going to cost something. We have to pay their salaries and their insurance and all of that, but then our total productivity starts going down again. That's what we're seeing here when both the variable cost curve and our total cost curve
start curving back on itself. Now, with this plotted, what I want to think about visually, and especially in terms of slope, I encourage you to, if the term slope seems a
little bit foreign to you, there's tons of videos
on the idea of slope in the algebra playlist, but the slope is really
just how inclined a line is. For example, this line has a higher slope than this line right over there. That the way we measure it is our change in our vertical axis, so our change in our vertical axis, often given by a change in y, the triangles, that's the delta, Greek letter Δ, means change in Y divided by our change in, divided by our change
in our horizontal axis, that is change in X. So, slope is equal to Δy over Δx, and when you measure it this way, this line over here, it looks like it has about
the same change in x, but has a much lower change in y, lower change in y. So when you take this lower change in y divided by the same change in x, you're going to get a lower slope. If you had a line that
looked something like, if you had a line that looked something like this, then you have a much higher change in y, so your numerator is higher, a higher change in y, and you have a lower change in x. Your denominator's lower. That'll increase the
value of the quantity, so your change in x. This right over here is
going to be a high slope, a high slope. With that little primer out of the way on what a slope is, what I want to do is think about these average fixed costs, average variable costs, average total costs, and marginal costs in terms of slopes of these lines right over here. When you're looking at average, if we look at this point right over here, average fixed cost, $3.75. What that means is when we're producing 4,000 lines of code, 4,000 lines of code, our average fixed cost is $3.75, so I'm on the green line, actually. Let me use a green color right here. I'm on this green line right over here. To find that average, so that's our, that is our, that is our fixed cost. To find our average fixed cost, we want to divide our fixed cost, which is that height right over there. You want to divide it by
the total lines of code, and that gives us our fixed cost, our average fixed cost per line of code. We're taking a change in the vertical axis divided by our change in a
horizontal axis right there, so it's essentially giving
the slope of this line, just like that. It's giving the slope of that line, and that's this point right over here. When you go to this point right over here, you're saying, "Okay. "I'm producing 7,000 lines of code, "and it still costs me $15,000." That's $15,000. I divide my total change in fixed costs, divided by my or my total fixed cost divided by my total lines of code, divided by my total lines of code. I'm essentially getting the slope of, I know it's getting hard to see, the way I'm doing it. I'm essentially giving you the slope of, let me draw a little bit neater, this line right over here. You could see this line has a lower slope than the previous one, and that makes sense because the average fixed
cost per line of code should be going down. We have the same fixed cost and we're dividing it amongst more and more and more code. You can see if you go out here, and you do the slope from this point all the way over here, it's going to have even a little, even a lower slope, so let me clear this out of the way, so hopefully that makes sense. The fixed cost, at least for me, is maybe the easiest to understand. You're taking the same quantity, dividing it by more and more code, or by more and more developers. Now, the variable cost,
average variable cost, at any given point over here, we're taking the variable cost, and we're dividing it by
the total amount of code. So variable costs, over there it is $10,000, and we're dividing it
by 4,000 lines of code, so it is the slope of
this line right over here. When you go to 7,000 lines of code, you say, "Well, my total
variable cost is $20,000, "and I'm going to divide
it by 7,000 lines of code." So it is the slope of this
entire line right over here. I'm having trouble drawing these lines. It is the slope of this
line right over here. This is a curve, so the slope is different
here than it is over there. This line, when we're measuring the
average variable costs, we're measuring, you can imagine the average slope across from the beginning all
the way to this point right over here. Now, when you're doing
the average total cost, you're doing the same thing. The average total cost at that point is our total, total cost, so it's that, divided by, divided by the total code, so the total code. So it is the slope of this
line right over there. We see that, that slope,
when you start over here, when you start from this
point to that point, the slope goes down, but then we see the slope start going, it starts to go up again because we saw that the variables cost start increasing because we get less and less efficiency as we add more and more developers and attempt, at least, to write more code. Now, the marginal cost
is an interesting one. All of these other ones, we're taking our total cost, our total variable cost, our total total cost, our total fixed cost, and dividing by the total amount of code, so we're essentially
finding the slope of a line between these points and our origin. When you're doing the marginal cost, you're doing something different. Let me clear all of this out so that we can clear things up. Your marginal cost is you're measuring your change in total cost divided by, not your total total cost, you're doing your change in total cost divided by your change
in the lines of code. So, for example, that right over, let me do that in a more vibrant color. That marginal cost, that's at this point right over here, so let's say we're going to, we can do it with the variable cost curve or we could do it with
the total cost curve. i'll do it with the total cost curve, so it's this point right over here. What we're doing is, we're taking the change in total cost between the previous point. The previous point was there, so our change in total cost is just this part right over here, so this is our change in total cost, and we're dividing it by our change in the amount of code we produce. So we're dividing it by the change in, change in lines of code. So essentially, it's giving
us the slope of the line between the previous point
and the current point on the total cost curve. We could do it, so if we go right over here. Let me go to another arbitrary point that doesn't start from the beginning. Let's say we're looking
at this marginal cost. This was when we're talking about 10,600 lines of code, and our total cost was $65,000. So our total cost is $65,000, 10,600 lines of code. That's that point right over there. What this is measuring, it's our change in total cost since the last increment, so since the last increment, since the last point. It's our change in total cost. it's our change in total cost divided by the change in lines of code since the last point, so the change of lines
of code is just that, change in lines of code. Our marginal cost is this quantity divided by this quantity. It's the slope between these
two consecutive points. What the marginal cost is giving us, so I just want to make sure
we get everything clear, these average fixed, average variable, average total cost, that gives us a slope of the line between any of the points and the origin. The marginal cost is essentially giving us the slope of the curve between any two consecutive points on the total cost curve, or you could also view, because it's really just a shifted version of the variable cost curve, or you could do this as the same as the slope of the line between any two points on
the variable cost curve. This is an approximation you could do this as the average, and that's why I wrote average over here. This is the average slope of the curve between these two points.