Most programming languages developed in the last 30 years are what are called object-oriented languages. Now this wasn't always the way. My first programming job over 25 years ago was writing assembly language, FORTRAN, and COBOL on ICL mainframes. Now these languages were not object-oriented languages. They were instead straight procedural languages where the program really is written as one long procedure. Even though it might contain functions and subroutines to make it more modular and maintainable, it's really a long piece of code combining data and logic all mixed in together.
Now in an object-oriented language, this program would instead be split apart into self-contained objects, almost like having several mini programs. Each object is representing a different part of the application and each object contains its own data and its own logic and they communicate between themselves. Now if that sounds like it could be a little bit confusing, the idea here is that these objects represent the way you would talk and think about the actual problem.
It's meant to make thinking about your program easier. The objects don't represent mysterious abstract ideas. They first represent things like employees, images, bank accounts, player objects, car objects, whatever actually exists in your program. So object orientation is an idea and it's an idea that it's supported in many languages. And for you it's a shift to thinking about the objects in your program are not just the process. And while object-oriented programming can bring a lot of jargon into the table, there are really only a couple of terms we need to be comfortable with to move forward with it.
The first two terms we need to understand is the difference between a class and an object. And these two terms go hand in hand with object-oriented languages. A class is a blueprint. It's an idea, it's a description, it's a definition. It describes what something is, but it isn't the thing itself. It's a well-defined idea, like say a blueprint for house. And classes will exist for different parts of your program. So if you are writing a restaurant review website, you might create classes that represent a restaurant and a review or a user.
Classes could also represent visual parts of your program, things like TextBox and Button and Window. And they can also represent invisible things like dates and times and anything that can be a well-defined idea. A lot of languages come with many classes already defined, even advanced things like VideoPlayer classes, and you can also define your own. Now all classes describe and define two things: Attributes and Behavior.
What are some things characteristics, its attributes, and what can it do, what's its behavior. So in this case, let's say we are describing a class to describe a person. We might say that the person attributes are name, height, weight, gender, and age, whereas the person's behavior is walk, run, jump, speak, sleep. Think about it this way that the attributes are really your data, your variables. And the behavior is what can you do, your functions. And actually attributes and behavior in most object-oriented languages are actually described with other names, which is properties and methods.
These are the most common ways of describing these. But the class is describing these things in abstract. And what I mean by that is it says that a person has a name and it has a height, but it doesn't say what the name is because the class is just the description of something. But just like there's no point creating a blueprint if you never intend to make a house, there's no point defining a class unless you're going to make an object. So that's the relationship between the two.
The class is the idea and the object is the thing itself. We create objects based on the class like creating a house based on the blueprint. Not only that, but you can create multiple objects based on one class in the same way you could create multiple houses based on one single blueprint. Now while there is a lot of jargon associated with object orientation, encapsulation is the key idea.
Finally, the course compares how code is written in several different languages, the libraries and frameworks that have grown around them, and the reasons to choose each one.
- Writing source code
- Understanding compiled and interpreted languages
- Requesting input
- Working with numbers, characters, strings, and operators
- Writing conditional code
- Making the code modular
- Writing loops
- Finding patterns in strings
- Working with arrays and collections
- Adopting a programming style
- Reading and writing to various locations
- Managing memory usage
- Learning about other languages