 Let's go ahead and make a new project. We're going to choose Qt Console Application. We're going to give it a name. And this is Qt Core for Beginners. We're in section 1, video 5. And we want to create it in this folder. You can click Browse and put it any folder you want. And you can even say Use as Default, meaning this will always be the location by default every time you make a new project. I'm going to hit Next. Build System. Leave it as QMake, even though there are other options. We're going to be going over QMake. Kit Selection. This is where I get a ton of mail. Kit Selection is extremely easy to understand, but it's very deceiving. Kit Selection is the platform you want to deploy on. Notice how I have the desktop checked, but I also have Android in here. You might not have Android listed. You may even have other options. Point is, make sure desktop is checked, because that's what we're developing on and that's what we want to deploy to. If we were doing Android programming, we'd have Android in here. If you were Mac, you may see something different. Windows, you may see something different. Just make sure it says Desktop. Version Control, we're not going to use any, but you could add in Version Control if you really wanted to. And click Finish. All right, a couple things happen in the background here. You see how we've got some breakpoints? Just going to clear those out. And we've got a project file. Project file is pretty interesting. What it says is we are not using the graphic user interface, that's the minus equals. The configuration, we are using the C++11 and console, and we're not using an app bundle. Notice how it's plus equals or minus equals for adding and subtracting. Wouldn't really recommend you go in and play around with the project file too much. One thing you want to really look at is sources. As you add more files to your project, you'll see more sources in there. Let's go ahead and close that. And here is our application in all of its splendor. And I realize it's pretty bare, but if you're brand new to programming, this may look like some foreign language. This is what's really going on. Pound include. What that means is this is a compile directive. We're saying, hey, we want to include, and we want to include that file. Int, main, and then some gobbly cook. What does this mean? Main is the starting point for any C++ application. We're returning an integer, which is just a number, and when the application starts, it's getting some arguments. Q core application, notice it's this thing right here, means we're actually creating an instance of this, named as a variable, and we're passing these arguments over to it. Return a.exeq. What does that mean? Return means we're returning this value here, and we're using a.exeq. A is this object here. I know this is very confusing, and we're gonna cover all of this. So if you're completely lost, take a deep breath and just understand we're gonna go over it. But anyways, a.exeq, so we're just returning a number. We're gonna do the obligatory hello world, and we're just going to include, and we want the Q debug. You notice this little thing pops down. That's called IntelliSense, and this is a life saver. You're gonna love this. You can either type it out, or you can just select it from a list. We're gonna include Q debug. In Q debug, there's a function called Q info, which just lets us print things out. So we're gonna say hello world, we're gonna save it, and let's go ahead and run this. Now that happened very quickly, but a few things happened. You notice this progress bar, that's our built status. Then application output lit up, and compile output lit up. We also have a terminal, says hello world. Your screen may be a little different. You may actually see that hello world down here. That's dependent on how your project is actually set up, and you may actually have to Google on how to set this up, and how to make it run the way you want it. See how the run, it's run in terminal. If that's not checked, it'll run right in the IDE. Okay, so let's go back to edit, and you can see our compile output. There was a lot that happened in the background here. What we're doing here is we're essentially taking these files, and we're running something called Qmake. See this Qmake all? And we're taking those files and crunching them into objects, meaning we're turning it in machine language. And what's really happening is this object here is being created. Main.o is being created from main.cpp. We can go in here and see, this is our directory where we put our code. There's our code, and a new directory is created. You see how it's blah, blah, blah, blah, blah, blah, blah, 64-debug, because we're in debug mode over here. Cracking this open, you see there's our main object, our make file, and our actual program. Our program is 331 kilobytes in size. That's pretty chunky for a small application like this. Let's go back out here. And let's change this from debug to release. I wanna talk very briefly about the difference between the two. Notice how nothing in our code has actually changed, and when we run this, the same application pops up. But we actually have two versions of this running now. One's in debug, one's in release. Let's close both of these and talk about this. What just happened? Well, you can see now we have two folders, the debug and release. Debug is 331, and release is 13, vastly smaller than the debug. So what's really going on under the hood? The debug version has debug symbols in it. So if you want to run your application and see what's going on under the hood in real time, use the debug version. However, it gets pretty complex. For example, if we want to put a breakpoint, we just simply click on the line, we want the application to stop. And we can go ahead and click this little debug icon. Notice how we had a problem. This does not seem to be a debug build. So everything's going to be ignored, and that's because we're in release. So let's switch to debug. May take just a second for it to parse it. There we go. And let's kill this. And let's rerun it. So what's really going on? You notice how you didn't see your application pop up and it's right here, but nothing's actually printed on the screen yet. That's because this little yellow arrow is stopped at that red breakpoint on line nine right there. So before this is executed, it hits the breakpoint and stops. It gives you our argument inspector. So you can see there's our little object here, which is actually this guy, the QCore application. And we have arguments one, arguments two, which are these guys here in here. We can also see where our breakpoints are and where we are in the file. You can see how it is vastly unhelpful for the newbie. And we're just gonna step right over that. When we do, you notice how bang, suddenly hello, we're executed, but our application stopped right here. That's called using breakpoints. And you may see that in other videos. It can be very helpful and it can be very, very confusing. We're probably gonna stay away from this just because of how confusing it is. I may use it once or twice, but I want you to understand the fundamental difference between running and debugging. We're currently debugging and you can tell because we have all this stuff on the screen and we have that little debug icon. So let's go ahead and kill this. And you notice how you can run and the debug stuff still stays up. Even though we're not debugging, that's also very confusing. Just simply click on edit and it all goes away. If you wanna go back, you can go to debug and back and forth. So we can run, there we go, close that. And if you accidentally hit debug, it will flip you into debug mode. So just understand that those things exist. I'm gonna go ahead and clear those breakpoints by clicking on them and save by work. I hope you enjoyed the video you just watched. That was a preview of one of the videos out in the cute core for beginners with C++ course I have out on Udemy. I am going to be making an intermediate in advance and then we're gonna start working on GUI technologies. For example, showing buttons, lists, tree views, you name it and then moving on to things like QML. The reason why I've restarted this whole thing is if you're watching these videos out on YouTube, they are a little old. This one was done in 2011 and the technology's changed over time. So because the technology's changed some of these videos as good as they are, really don't line up with the current cute technology stack anymore. So I wanted to start from scratch. I hope to see you out on Udemy and also in the Voidrums Facebook group. See you there.