Learn Enough Developer Tools to Be Dangerous: Git Version Control, Command Line, and Text Editors Essentials

Learn Enough Developer Tools to Be Dangerous: Git Version Control, Command Line, and Text Editors Essentials

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 70 Lessons (4h 45m) | 761 MB

In Learn Enough Developer Tools to Be Dangerous LiveLessons: Command Line, Text Editor, and Git Version Control Essentials, renowned instructor Michael Hartl teaches the foundational tools and skills you need to to work with developers or become a developer yourself.

Learn Enough Developer Tools to Be Dangerous teaches you three essential tools for modern software development: the Unix command line, a text editor, and version control with Git. All three are ubiquitous in the contemporary technology landscape, and yet there are surprisingly few resources for learning them from scratch and seeing how they all fit together. Learn Enough Developer Tools to Be Dangerous, which assumes no prerequisites other than general computer knowledge, fills this gap.

The skills you’ll learn are valuable whether your interest is in collaborating with developers or becoming a developer yourself. No matter what you want to do–level up in your current job, start a new career, or even start your own company–Learn Enough Developer Tools to Be Dangerous is a great place to start.

And staying true to the Learn Enough philosophy, the course focuses on the most important aspects of the respective technologies. You don’t have to learn everything to get started–you just have to learn enough to be dangerous.

Michael Hartl is the creator of the Ruby on Rails Tutorial, one of the leading introductions to web development, and is cofounder and principal author at Learn Enough. Previously, he was a physics instructor at the California Institute of Technology (Caltech), where he received a Lifetime Achievement Award for Excellence in Teaching. He is a graduate of Harvard College, has a PhD in Physics from Caltech, and is an alumnus of the Y Combinator entrepreneur program.

Learn How To

  • Run a terminal
  • Manipulate, inspect, and search through files
  • Understand directories, including making, navigating, renaming, copying, and deleting them
  • Understand text-editor basics, including Minimum Viable Vim
  • Use a modern text editor
  • Use advanced techniques, including writing source code and executable scripts
  • Use Git version control
  • Use GitHub for remote version control
  • Branch and merge
  • Recover from errors
  • Collaborate with others on software projects

Who Should Take This Course

Those wishing to work with developers on projects or who want to become developers themselves. The course can serve as a base from which to learn how to make modern websites with HTML and CSS and how to develop software with JavaScript or Ruby.

Course Requirements

  • No prerequisites other than general computer knowledge
  • A willingness to learn new things

Lesson 1: Basics
In Lesson 1, you learn the basics of the Unix command line. Using a command line interface, or CLI, involves typing commands that tell the computer to perform particular tasks, like renaming or deleting files, making directories, or launching other programs. Unix refers to a family of operating systems that includes Linux, Android, and iOS (iPhone and iPad, and Mac OS). Unix systems serve most of the software on the World Wide Web, run most mobile and tablet devices, and power many of the world’s desktop computers as well. As a result, understanding the basics of the command line is absolutely essential to becoming a skilled developer. You start by launching and using a terminal, which is the program that gets you to the command line. After an introduction to the command line prompt, you begin learning how to execute simple Unix commands. You also see how to use so-called man pages to let you use the command line itself to learn more about any given command. The lesson ends with some tricks for editing the command line, and then you learn how to exit it when you are done.

Lesson 2: Manipulating Files
In Lesson 2, you learn how to manipulate files, one of the most important tasks of the command line. Because Module 1 assumes no technical prerequisites, you are not assumed to have any familiarity with a text editor, which is covered in Module 2. This means that you need to create files by hand at the command line. But this is a feature, not a bug, because learning to create files at the command line is a valuable skill in itself. You begin by learning how to redirect output, which will enable you to use the echo command from the previous lesson to create a new file at the command line. You also learn how to add more lines to the end of a file, a process known as appending. Next, you learn various ways to list the details of files, including both short and long forms, and reverse by modification time. Finally, you see how to rename, copy and delete files, including how to use wildcards to make changes that can be hard to make using a graphical user interface but are easy using a CLI.

Lesson 3: Inspecting Files
Having seen how to create and manipulate files in Lesson 2, in Lesson 3 it is time to learn how to examine their contents. This is especially important for files that are too long to fit on a single screen. In particular, you saw in the last lesson how to use the cat command to dump the file contents to the screen, but this doesn’t work well for longer files. To get started with a file too long to cat, you use a powerful program called curl, which lets you interact with the Internet via the command line. You use curl to download a long text file from the web and then use the head and tail commands to examine its beginning and end, respectively. You then use the interactive less command to examine your files contents more thoroughly. Finally, you use the important grep command to search for patterns inside your file using both ordinary strings and so-called regular expressions.

Lesson 4: Directories
Having examined many of the Unix utilities for dealing with files, in Lesson 4 you learn about directories, sometimes known as folders. As you’ll see, many of the ideas developed in the context of files also apply to directories, but there are many differences as well. The lesson starts with a big-picture overview of the Unix directory structure. You then learn how to make directories ourselves. Next, you learn how to change directories. Then, as with files, you learn how to rename, copy, and delete directories. Finally, you learn how to use the grep utility, introduced in the previous lesson, to search inside some or all of the files in a directory.

Lesson 5: Introduction to Text Editors
In Lesson 5, the first lesson of Module 2, “Learn Enough Text Editor to Be Dangerous,” you learn the basics of how to use a text editor. Unlike most other text-editor tutorials, which are typically tied to a specific editor, Learn Enough Developer Tools to Be Dangerous introduces the entire category of application, a category many people do not even know exists. A text editor is an application used to edit plain text, often called just text for short, which is the most common document format for code, markup, configuration files, and many other things. After a general overview of what text editors are and what they can do, the lesson dives into the important, if somewhat obscure, Vim editor. The lesson includes only Minimum Viable Vim, not even really enough to be dangerous, but enough to get started. You begin by learning how to launch Vim right at the command line and then how to exit it safely using the Most Important Vim CommandTM. You then learn how to use Vim to edit, save, and quit small files and how to delete content in files. The lesson ends by teaching you how to use Vim to navigate, search, and edit larger files as well.

Lesson 6: Modern Text Editors
Lesson 6 builds on the basic Vim text editing you learned in Lesson 5 to introduce so-called modern text editors such as Sublime Text, Visual Studio Code, and Atom. Modern editors are distinguished by their combination of power and ease of use. You can do fancy things like global search-and-replace, but unlike Vim, they let you just click in a window and start typing. In addition, many modern editors include an option to run in Vim compatibility mode. So even if you end up loving Vim, you can still use a modern editor without having to give Vim up entirely. Although we’ll mainly be using the Atom editor in the videos, the ideas covered in this lesson and the next broadly apply to any modern editor. You learn how to open files, how to move around inside them, how to select text, and how to cut, copy, and paste. You then learn how to delete text, and perhaps most importantly, how to undo such deletions. Next, you learn how to save files, and the lesson ends by teaching you how to find and replace text based on exact string matches. As part of all this, you also get an introduction to Markdown, a useful human-readable markup language designed to be easy to convert to HTML, the language of the World Wide Web.

Lesson 7: Advanced Text Editing
Having covered the basic functions of modern text editors in Lesson 6, in Lesson 7 you learn about a few of the most common advanced topics. Even more than in Lesson 6, details will vary based on the exact editor you choose. So use your growing technical sophistication to figure out any necessary details. The most important point is that the advanced functions in this lesson are all things that any professional editor can do. So you should be able to figure out how to do them no matter which editor you are using. The lesson begins with autocomplete and tab triggers, which are two powerful techniques for generating longer strings of text automatically. Next, you learn some tricks and techniques for writing source code. You apply this knowledge to write a working executable script, which extends the capabilities of the command line introduced in Module 1. The lesson ends with a discussion of how to use a text editor to work on an entire project consisting of many files and directories, such as a Ruby on Rails web application, including how to find and replace using the regular expressions introduced in Lesson 3.

Lesson 8: Getting Started with Git
In Lesson 8, the first lesson of Module 3, “Learn Enough Git to Be Dangerous,” you’ll learn the basics of the Git Version Control System, or VCS, which provides an automatic way to track changes in software and other text-based projects. Fluency in at least one VCS is an essential component of technical sophistication. Nowadays, by far the most popular choice of VCS is Git, designed by Linux creator Linus Torvalds. Because Git runs as a command-line program and tracks changes in plain text files, you will have a chance to apply many of the things you learned in Modules 1 and 2. You begin by covering the installation and initial setup needed to get started with Git. You then initialize a new Git repository to contain our project consisting of a simple website, create a new file, and record the change by making our first commit. Next you make a change to the file and view the change using Git’s version of the diff command introduced in Lesson 2. You then make and commit several more changes. Along the way you learn a little about Hypertext Markup Language, or HTML, the language of the World Wide Web.

Lesson 9: Backing Up and Sharing
In Lesson 9, you learn how to use Git to back up and share the work you did in Lesson 8, by pushing a copy of your project up to a remote repository. This will serve as a backup of our project and its history and will also make it easier for collaborators to work with us on our site. You start by signing up for GitHub, a site designed to facilitate collaboration with Git repositories. First, you create a remote repository at GitHub and then use git add to connect it to our local repository. You then use git push to push our local copy up to GitHub. Next, you add an explanatory README file using the same Markdown formatting language covered in Module 2. After pushing up our repository again, you will discover that GitHub automatically converts Markdown to HTML and displays the result.

Lesson 10: Intermediate Workflow
In Lesson 10, you practice and extend the basic workflow introduced in Lesson 9. This includes adding a new directory to your project, learning how to tell Git to ignore certain files, how to branch and merge, and how to recover from errors. Rather than providing an encyclopedic coverage of Git’s many commands, the focus is on covering practical techniques used every day by software developers and other users of Git. You start by reviewing the process of committing and pushing covered in the previous lesson. You then discuss how to get Git to ignore things like temporary and log files that we don’t want to keep in version control. You then learn how to make an efficient copy of your code using a branch, which enables us to make changes safely without affecting the main project. Then you learn how to incorporate those changes using a merge. You end with the discussion of how Git helps you recover from errors such as accidentally deleting the files in your project.

Lesson 11: Collaborating
Now that we’ve covered some of the tools needed to use Git effectively on solo projects, in Lesson 11, you learn about what is perhaps Git’s greatest strength: making it easier to collaborate with other people. This is especially the case when using repository hosts like GitHub or Bitbucket, but it is also possible to host Git repositories on private servers, sometimes using software like GitLab to get many GitHub-like benefits. You begin by making a copy of your project’s repository using the git clone command, and then you learn how to use git pull to pull in changes pushed by your collaborators. As part of this, you learn how to deal with the inevitable conflicts that arise from having multiple people working on the same source files. You also learn how to push the kinds of branches introduced in Lesson 10 so that you can collaborate with others on possibly dangerous changes and then merge them in only when you are confident you want to keep them. The lesson ends with a special surprise bonus that will give you bragging rights with all of your friends. In a final optional section, you can learn some more advanced Git setup, such as aliases and tab completion.

Table of Contents

1 Learn Enough Developer Tools to Be Dangerous Introduction

Lesson 01 Basics
2 Topics
3 Introduction
4 Running a terminal
5 Our first command
6 Man pages
7 Editing the line
8 Cleaning up

Lesson 02 Manipulating Files
9 Topics
10 Redirecting and appending
11 Listing
12 Renaming, copying, deleting

Lesson 03 Inspecting Files
13 Topics
14 Downloading a file
15 Making heads and tails of it
16 Less is more
17 Grepping

Lesson 04 Directories
18 Topics
19 Directory structure
20 Making directories
21 Navigating directories
22 Renaming, copying, and deleting directories
23 Conclusion

Lesson 05 Introduction to Text Editors
24 Topics
25 Minimum Viable Vim
26 Starting Vim
27 Editing small files
28 Saving and quitting files
29 Deleting content
30 Editing large files

Lesson 06 Modern Text Editors
31 Topics
32 Choosing a text editor
33 Opening
34 Moving
35 Selecting text
36 Cut, copy, paste
37 Deleting and undoing
38 Saving
39 Finding and replacing

Lesson 07 Advanced Text Editing
40 Topics
41 Autocomplete and tab triggers
42 Writing source code
43 Writing an executable script
44 Editing projects
45 Customization
46 Conclusion

Lesson 08 Getting Started
47 Topics
48 Installation and setup
49 Initializing the repo
50 Our first commit
51 Viewing the diff
52 Adding an HTML tag
53 Adding HTML structure

Lesson 09 Backing Up and Sharing
54 Topics
55 Signing up for GitHub
56 Remote repo
57 Adding a README

Lesson 10 Immediate Workflow
58 Topics
59 Commit, push, repeat
60 Ignoring files
61 Branching and merging
62 Recovering from errors

Lesson 11 Collaborating
63 Topics
64 Clone, push, pull
65 Pulling and merge conflicts
66 Pushing branches
67 A surprise bonus
68 Advanced setup
69 Conclusion

70 Learn Enough Developer Tools to Be Dangerous Summary