 If you've gotten this far in your computer science career, chances are somebody's mentioned abstraction once or twice without really bothering to explain what this is or why we care or how it works. Abstraction is fundamentally how we approach most problems in computer science. We can consider this as a general-purpose problem-solving strategy or specifically as a strategy for writing programs. The idea is that we start with some really high-level abstract idea of what our problem is. What is it that I want to do? What is it that I want to accomplish? And then we look at, okay, what do I need to actually do this? These steps that we come up with don't have to be things that I can actually do. In most cases, they'll be things that I really don't know how to do. So then I'll have this set of, say, four or five steps where I know that if I do each of these steps, then by the end, I know that I will have accomplished the original goal that I set out to do. But if I don't know how to do any of these particular problems already, I'm going to have to go back and break them down some more. So we just keep expanding our problems into a set of smaller problems, things that we have some more idea how to solve. We can basically just keep doing this until we get to something that we actually do know how to solve. Taken to the extreme, we would just start with something like the name of our program, and we would continue breaking it down into smaller and smaller pieces until we actually got down to just individual lines of code. In general, that's way more effort than we were interested in putting in. And we start taking shortcuts as we get more used to solving particular types of problems. We also start building structures that allow us to skip some of this. So our high level languages actually allow us to skip some of the lowest levels of implementation, because we don't have to worry about how a, because we don't have to worry about how a for loop actually runs on our machine, what all of the structure of our classes are. Often, we just have to know that I got this object over here, I build one, I stick some data in, I can call its operations, and it will do lots of fun stuff for me. I don't have to worry about how it's actually getting its job done. One of the things that we try to do with abstraction, we try to make it so we don't have to worry about how any individual part is getting its work done just as long as it does successfully get that work done.