Latest / DevQuestions with Tim Corey / 302. Why Do Developers Use the Command Line

Transcript

302. Why Do Developers Use the Command Line · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Why do developers use the command line so much?
• 0:03
  SPEAKER_00: If you watch any older developer, you will probably see them drop into the terminal to execute git commands, to launch programs, or even to edit documents.
• 0:12
  SPEAKER_00: Even with the advent of AI and advanced coding techniques, the TUI or terminal user interface is seeing a huge rise in popularity.
• 0:21
  SPEAKER_00: Claude code primarily runs in the terminal.
• 0:25
  SPEAKER_00: Why don't they develop modern GUIs instead?
• 0:28
  SPEAKER_00: That's what we're going to talk about in today's episode of DevQuestions.
• 0:40
  SPEAKER_01: Welcome to the DevQuesti podcast with Tim Corey.
• 0:44
  SPEAKER_00: Software development is more than just writing code.
• 0:47
  SPEAKER_00: So let's talk about the rest of it.
• 0:48
  SPEAKER_00: Specifically, let's talk about the purpose and value of command line applications.
• 0:54
  SPEAKER_00: Now, whenever I show off the terminal application or a set of commands in the terminal, inevitably someone pushes back, complaining that the terminal is outdated.
• 1:04
  SPEAKER_00: But there's a very important reason why software development has so many tools and systems that work on the command line.
• 1:12
  SPEAKER_00: Here are just some of the benefits.
• 1:14
  SPEAKER_00: Number one, predictability.
• 1:17
  SPEAKER_00: Things don't move around.
• 1:19
  SPEAKER_00: If you have to use Microsoft Word today, it's different than Microsoft Word was five years ago.
• 1:27
  SPEAKER_00: But a command line, unless they have deprecated commands, the command line stays the same.
• 1:34
  SPEAKER_00: That means a script that ran five years ago probably will still run today.
• 1:40
  SPEAKER_00: Now, yes, things are deprecated or changed, but for the most part, for example, git, those git commands still work.
• 1:47
  SPEAKER_00: So when it comes to predictability, you know that the command will run on this machine, will run on that machine, will run the next machine, because it's going to do the same exact thing the same exact way.
• 2:01
  SPEAKER_00: Things don't move around.
• 2:03
  SPEAKER_00: Buttons don't have to adjust based upon the screen resolution.
• 2:06
  SPEAKER_00: So you don't have to say, well, click this menu, then go down to here, then click these options, then scale down to just say run this command and it will work.
• 2:17
  SPEAKER_00: So predictability, number one.
• 2:19
  SPEAKER_00: Number two kind of goes along with that, and that's repeatability.
• 2:23
  SPEAKER_00: If I run this specific command, it will do this specific thing.
• 2:27
  SPEAKER_00: If I run that same command later or on a different machine, it will do that same exact thing.
• 2:34
  SPEAKER_00: Having something that's repeatable is really valuable.
• 2:38
  SPEAKER_00: If you're installing a server and you set things up, you set things up manually, you're going to install Windows and you install this software and that software, that's okay because it's one server.
• 2:50
  SPEAKER_00: But imagine you have a hundred servers to do, and they're all the same.
• 2:55
  SPEAKER_00: Well, if you write a script, then you can say, hey, this is a script that installs all these things.
• 3:02
  SPEAKER_00: And then just run that a hundred times.
• 3:05
  SPEAKER_00: Guess what?
• 3:06
  SPEAKER_00: All 100 instances will be exactly the same.
• 3:09
  SPEAKER_00: Now, you can have exactly the same problem if you're not careful, but that's on you.
• 3:13
  SPEAKER_00: So repeatability is number two.
• 3:15
  SPEAKER_00: Number three, again, kind of goes along with these first two, and that's automation.
• 3:21
  SPEAKER_00: Having a predictable, repeatable process that you can run without having to use your mouse allows you to automate these things, allows you to create repeatable commands that you can execute over and over again.
• 3:38
  SPEAKER_00: This is the entire foundation of CI CD, the continuous integration and continuous deployment process.
• 3:46
  SPEAKER_00: We use automation to run commands, run things that are predictable, that are repeatable.
• 3:53
  SPEAKER_00: That way we know that if it worked the first time, the second time, the third time, it's going to work the fourth time.
• 4:00
  SPEAKER_00: And that's really what CI CD is.
• 4:03
  SPEAKER_00: We deploy locally, deploy to our dev box, we deploy to our testing box, our staging box, our QA box, and then finally to our production box.
• 4:14
  SPEAKER_00: And what do we get?
• 4:15
  SPEAKER_00: The same results every time.
• 4:17
  SPEAKER_00: Which means by the time we get to production, we're happy with results.
• 4:22
  SPEAKER_00: That's number three.
• 4:23
  SPEAKER_00: Number four is speed.
• 4:31
  SPEAKER_00: If I say, go ahead and create a new project for.NET, I'm gonna create a new console app.
• 4:39
  SPEAKER_00: Well, if you look at command line, that's.NET New Console, I believe.
• 4:45
  SPEAKER_00: And then you can give it a name in the switches.
• 4:48
  SPEAKER_00: If I say I do that in Visual Studio, okay, file, new project, and then you're gonna search for console, you're gonna find that, click on it, then you're gonna fill out all the fields, or at least look at them because they're all there.
• 5:00
  SPEAKER_00: But they're probably the defaults, which would be the default in the command line, by the way.
• 5:04
  SPEAKER_00: And then you fill the name, and then you hit next, and then you hit complete, and it and it creates the the application.
• 5:11
  SPEAKER_00: Well, that's a whole lot more steps, and it's more click here and go there and search this and do that, instead of just.NET New Console.
• 5:21
  SPEAKER_00: Right?
• 5:22
  SPEAKER_00: Much faster to execute, much easier to execute.
• 5:27
  SPEAKER_00: And it's also actually faster in terms of actual processing, too, because Visual Studio has to load the GUI and it has to load the lists and it has to show you things and process things.
• 5:39
  SPEAKER_00: Whereas on the terminal, all it's doing is running the actual commands.
• 5:45
  SPEAKER_00: So the GUI is on top of those commands.
• 5:47
  SPEAKER_00: So it's only gonna be faster to run on the terminal.
• 5:51
  SPEAKER_00: Same is true for Git.
• 5:52
  SPEAKER_00: If you're using a Git client, well, you can visually do things.
• 5:56
  SPEAKER_00: And quite frankly, the GUIs are nice for Git because some of it's rather confusing.
• 6:01
  SPEAKER_00: But when you drop down to the terminal and run the Git commands, they can be much faster because of the fact that GUI doesn't have to render all that, at the very least.
• 6:11
  SPEAKER_00: So terminal is both faster for you as a human, but also faster in terms of CPU cycles as well.
• 6:18
  SPEAKER_00: Number five, it's easy to use.
• 6:21
  SPEAKER_00: Now you may push back and say, I can't remember the commands.
• 6:24
  SPEAKER_00: I can't either.
• 6:25
  SPEAKER_00: I actually made a mouse mat that has commands for Git and the shortcuts for VS code and all these other things because of the fact that I can't remember it all.
• 6:36
  SPEAKER_00: So, yes, I get that.
• 6:38
  SPEAKER_00: But at the same time, it's easy to use in the fact that I can train you to say, hey, write this down in your notebook or write this down in a notepad somewhere that says.NET New Console.
• 6:51
  SPEAKER_00: That's easy to understand, as opposed to install this application, make sure these settings are installed as well, then go here and do this.
• 6:59
  SPEAKER_00: Oh, they said an update.
• 7:01
  SPEAKER_00: It's actually now over here.
• 7:02
  SPEAKER_00: That's more problematic.
• 7:05
  SPEAKER_00: Number six, it requires less or no installation.
• 7:11
  SPEAKER_00: So this allows for much easier work.
• 7:14
  SPEAKER_00: If you've got the.NET 10 SDK installed, for example, well, by having that installed, you can just say.NET and then whatever command you want, and it's already there.
• 7:25
  SPEAKER_00: Whereas if you actually want on GUI, well then you gotta figure out which GUI you want to have installed and then download it, install that, set it up, configure, and all the rest.
• 7:33
  SPEAKER_00: This is true for pretty much anything.
• 7:35
  SPEAKER_00: If you have Git installed on the device, well, you can just start using Git commands on the terminal.
• 7:41
  SPEAKER_00: But if you want to have a GUI, then you have to install a GUI on top.
• 7:45
  SPEAKER_00: Now, sometimes you may not realize that's what's happening because you're installing two things.
• 7:49
  SPEAKER_00: Like if you install Visual Studio, it installs a.NET 10 SDK.
• 7:53
  SPEAKER_00: But that's actually two things in one.
• 7:56
  SPEAKER_00: So when you're installing that bigger thing, you're usually installing the smaller thing first.
• 8:02
  SPEAKER_00: So it requires less or no installation, depending on if it's already built into the system or if it requires an install, but it's a quick install.
• 8:12
  SPEAKER_00: Okay.
• 8:13
  SPEAKER_00: So this easily works on more systems.
• 8:16
  SPEAKER_00: So it also allows you to work on different systems.
• 8:20
  SPEAKER_00: You're working on Windows today and Mac tomorrow when it comes to.NET or Linux, like we're doing our series right now.
• 8:25
  SPEAKER_00: Not a problem because the.NET command line is the same.
• 8:31
  SPEAKER_00: Easy to use.
• 8:33
  SPEAKER_00: All right, number seven, they're easier to execute remotely.
• 8:38
  SPEAKER_00: Let's say that you want to uh work on a server.
• 8:42
  SPEAKER_00: Maybe you're working on um, I don't know, remotely from your your parents' house, and they they have an old computer and nothing installed as far as your tools, but you can SSH into your server.
• 8:55
  SPEAKER_00: Well, all of a sudden you can run commands on your server that do all the work that you need to do because it's just a command line, as opposed to having to have a work laptop and everything set up on it and configured and all the rest.
• 9:09
  SPEAKER_00: You just use SSH and terminal into the server and run your commands.
• 9:14
  SPEAKER_00: It's very easy to execute commands remotely if you're using some type of terminal or command line, as opposed to the overhead that comes into trying to connect a system remotely.
• 9:27
  SPEAKER_00: Number eight is efficiency.
• 9:31
  SPEAKER_00: Terminals and terminal applications use less memory to execute commands, which means you can do more with less.
• 9:39
  SPEAKER_00: You can be more efficient and have, especially if you're using like a CI CD system, where the more you can save your memory, the better.
• 9:46
  SPEAKER_00: Well, this is where command line really comes in handy.
• 9:50
  SPEAKER_00: So that's eight.
• 9:52
  SPEAKER_00: There's a bonus one.
• 9:53
  SPEAKER_00: Um it's easier to make cross-platform.
• 9:56
  SPEAKER_00: Okay.
• 9:56
  SPEAKER_00: Um if you're a.NET developer, super easy to make cross-platform apps if you're using terminal applications, creating terminal applications, because they just work.
• 10:06
  SPEAKER_00: If you create a console application, it can run on Linux, Mac, and Windows out of the box.
• 10:12
  SPEAKER_00: You just say deploy to Linux, deploy to Mac, deploy it to Windows, and it will just work.
• 10:18
  SPEAKER_00: So it's easier to make cross-platform.
• 10:20
  SPEAKER_00: That's just a bonus.
• 10:21
  SPEAKER_00: Command line interfaces can have higher barriers to entry because yes, you have to learn the command line, you have to learn how it works.
• 10:29
  SPEAKER_00: But once you understand how to use them, they offer a lot of advantage over a full GUI system.
• 10:35
  SPEAKER_00: So that's why developers, especially experienced developers, often favor CLI applications or at least use them consistently.
• 10:44
  SPEAKER_00: The GUIs may change, but the command line is still there.
• 10:48
  SPEAKER_00: Thanks for listening.
• 10:49
  SPEAKER_00: As always, I am Tim Corey.
• 10:51
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 10:54
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.