Unstarted Trails

Design

The Playbook: Video Edition

How to plan, design, develop, and launch a successful web application.

?

How to plan, design, develop, and launch a successful web application.

1 hour 51 minutes
Next Up

Planning

Unstarted

Team

Unstarted

Design

Unstarted

Development

Unstarted

Launch!

5 steps remaining
Visit trail
Vim

Onramp to Vim

Get up and running with the world's best text editor. No Vim experience is required, but you'll be productive in no time (and blazing-fast, soon).

?

Get up and running with the world's best text editor. No Vim experience is required, but you'll be productive in no time (and blazing-fast, soon).

1 hour 55 minutes
Next Up

Surviving Your First Week

Vim is notorious for having a steep learning curve, but we think this is a myth. This video will give you the base knowledge you need to get up and running for your first week.

Unstarted

Motions and Moving

Getting around is half the battle and Vim provides many ways to fly through a file. In this video you'll learn the motions that power so much of Vim's awesomeness.

Unstarted

Command Language

Vim's power and unique approach to editing comes from its language for editing text. In this video you'll learn how to speak the Vim language and become an editing master.

Unstarted

Windows & Tabs

Vim has an amazing amount of flexibility in how you lay out your windows and tabs. In this video you'll learn how to create, resize, and organize any layout you need.

Unstarted

Modes

Vim is a "modal" editor meaning that it has multiple different modes you can use to control it. In this video you'll learn about the different modes and how you can use them to maximize your efficiency.

Unstarted

Configuration

Vim has an impressive array of configuration options and customization points. In this video you'll learn what sort of configurations are possible and see examples of some powerful options you can set to level up your Vim.

Unstarted

Plugins

Vim is the best, but it can be even better with plugins. In this video you'll learn how to use plugins and see a selection of some of the most useful and powerful plugins available.

7 steps remaining
Visit trail
Vim

Navigating Ruby Files with Vim

Stop scrolling and searching! Start precision jumping and change the way you navigate Ruby files with Vim. Like a lot of Vim techniques it’s not as tricky as it seems and it can save serious time and effort once you’ve mastered the basics. Your coding experience will never be the same.

?

Stop scrolling and searching! Start precision jumping and change the way you navigate Ruby files with Vim. Like a lot of Vim techniques it’s not as tricky as it seems and it can save serious time and effort once you’ve mastered the basics. Your coding experience will never be the same.

42 minutes
Next Up

Navigating Within Ruby Files

Unstarted

Navigation Between Ruby Files

Unstarted

Intelligent Navigation With ctags

3 steps remaining
Visit trail
Testing

Test Doubles

Learn to use stubs, mocks, spies, and fakes with RSpec.

?

Learn to use stubs, mocks, spies, and fakes with RSpec.

6 hours
Next Up

Simple Stubs

Use rspec-mocks to stub out an object in a test.

Unstarted

Stubs with Constraints

Learn to set constraints on stubbed methods using RSpec.

Unstarted

Setting Expectations with Mocks

Learn to unit test methods with side effects and mutation using mocks.

Unstarted

Verifying Expectations with Spies

Learn how to keep your unit tests tidy with an alternative to mocks: spies.

Unstarted

Testing Flexible Interactions with Fakes

Learn how to test complex or flexible interactions by using fakes.

Unstarted

Verifying Mailers with Test Doubles

Now that you've learned how to use stubs, mocks, spies, and fakes, it's time to pull it all together.

6 steps remaining
Visit trail
Foundations

Ruby Challenges

Open-ended challenges designed to test your problem-solving skills. These start easy, but get hard. Watch out!

?

Open-ended challenges designed to test your problem-solving skills. These start easy, but get hard. Watch out!

5 hours
Next Up

Analyzing Shakespeare

Write a command-line program that prints the number of lines spoken by each character in Macbeth.

Unstarted

Sudoku Validator

Write a program that reads a file containing a Sudoku grid and validates it.

Unstarted

Ranking Poker Hands

Write a program that accepts two poker hands and returns the winner.

Unstarted

Solving Every Sudoku

Write a program that can solve any Sudoku puzzle.

Unstarted

The Wiley Word Square

Write a program to find the largest possible square of letters such that every row forms a word (reading left to right) and every column forms a word (reading top to bottom).

5 steps remaining
Visit trail
Clean Code

Refactoring

Refactoring is improving the quality of code without changing its behavior. Refactoring often is one key to keeping development speed high.

?

Refactoring is improving the quality of code without changing its behavior. Refactoring often is one key to keeping development speed high.

11 hours
Next Up

Explaining Variable

Learn how to simplify a method by breaking it down using explaining variables.

Unstarted

Replace Variable with Query

Learn to replace variables with query methods.

Unstarted

Extract Method

Extracting methods makes complicated code clearer and encourages re-use. It also also encourages you to name a collection of operations, which tends to improve readability.

Unstarted

Extract Class

Learn how to safely split up classes in small steps.

Unstarted

Null Object: Part One

Learn to encapsulate logic surrounding nil by introducing Null Object classes.

Unstarted

Null Object: Part Two

Take your Null Object skills to the next level by completing this additional exercise.

Unstarted

Extract Value Object

Learn how to simplify a class by extracting a value object.

Unstarted

Introduce Parameter Object

Learn how to replace a long list of parameters with a single parameter object.

Unstarted

Extract Validator

Learn how to extract a validator into its own class with this exercise.

Unstarted

Cleaning up a Controller

Slim down a controller that's gotten a bit bloated.

Unstarted

Replace Conditional with Polymorphism

Learn how you can interact with entities of different types by replacing conditionals with polymorphism.

11 steps remaining
Visit trail
Foundations

Analytics for Developers

Build. Measure. Learn.

?

Build. Measure. Learn.

2 hours 8 minutes
Next Up

Part 1 - Big Data & Big Stories

Unstarted

2: Visualization, Applying Analytics To Your Business & Event Data Overview

Unstarted

3: Analytics Infrastructure & Modeling Events

Unstarted

4: Common Techniques, A/B Testing, Funnels, Cohort Analysis

Unstarted

5: Retention & Churn

Unstarted

6: Using Event Data to Answer Business Questions

Unstarted

Part 2 - Project Setup

Unstarted

8: Analytics Library, Events & Collections

Unstarted

9: Tracking Events & Adding Multiple Parameters

Unstarted

10: Stat Metrics & Graphing Analytics

Unstarted

11: Frontend vs Backend & Special Collection Methods

11 steps remaining
Visit trail
Design

Design for Developers

Get better at visual design and create something great.

?

Get better at visual design and create something great.

1 hour 49 minutes
Next Up

Part 1: Principles of Visual Design

Unstarted

Part 2: Grid Systems

Unstarted

Part 3: Typography

Unstarted

Part 4: Color

Unstarted

Part 5: Tips, Tricks and Trends

5 steps remaining
Visit trail
Workflow

Mastering Git

Got the basics of Git down? Master it in just a few hours with this course.

Git Wizardry is closer than you think, and your instructor Chris will help you get there rapidly with this series of 11 videos and extensive notes.

?

Got the basics of Git down? **Master it in just a few hours with this course.** Git Wizardry is closer than you think, and your instructor Chris will help you get there rapidly with this series of 11 videos and extensive notes.

3 hours 22 minutes
Next Up

Getting to Confident

This step will destroy any lingering anxiety you might have about losing data in Git. You'll learn four key techniques to increase your confidence, including a panic button to hit when things go awry.

Unstarted

Managing History

"Who the heck changed this code, and why?" Git knows the answer—we'll show you how to find it. This step covers the many ways to slice and dice your Git history when you need answers, fast.

Unstarted

Undoing

Made a typo in a commit message? Forgot to do your work in a branch? Not to fear. Chris'll show you how to easily fix up the simple errors that are (sadly) a constant in the life of a professional developer.

Unstarted

Crafting History With Rebase

You refactor your code, why not your Git history? It's time to take control and make that history squeaky clean. If you're tired of ugly merge commits, this step is definitely for you. Chris covers selective staging, cherry picking, and the many ways you can rebase.

Unstarted

Git Object Model

It's time to open the hood, pull back the covers, and participate in other revelation-related metaphors. This step does a deep dive into Git's internal object model. Madness, you say? Once you understand how Git is put together, your relationship with Git will permanently change for the better.

Unstarted

Object Model Operations

This is like part 2 of the previous step. Now that you understand the underlying objects in Git, it's time to connect the various Git commands you already know to what they do to those objects.

Unstarted

Customizing Git

While Git is awesomely powerful, it does have a number of UX rough edges. The good news is that Git is tremendously configurable. This step will teach you how to take a belt sander to the rough bits, and build a Git workflow that's smooth as butter.

Unstarted

GitHub and Remotes

Git really shines when you start to connect it to other things, like GitHub and Heroku. This step dives into useful command-line tools, aliases, and tips for managing these remote interactions.

Unstarted

Vim and Git

Git and Vim: two great tools, even better together. You're probably already writing your commit messages in Vim, but it's time to start diffing, blaming, fixing merge commits, and more. This was the lesson that Chris was born to write.

Unstarted

thoughtbot's Git Flow

You've done a lot of learning, now it's time to put it all together. This step will touch on everything covered so far in the process of developing a small feature on a Rails app. If you've ever wondered how a thoughbot developer uses Git in the real world, this one is for you.

Unstarted

Learning More

You now definitely know enough Git to be a confident, productive developer. But while we've covered a lot, you might someday need specialized knowledge on a narrow Git topic. These are our favorite resources to continue your learning.

11 steps remaining
Visit trail
Ruby on Rails

Advanced ActiveRecord Querying

The ActiveRecord query interface is an impressive feat of engineering, but often we only use a small portion of it. In this trail we'll dive deep into ActiveRecord and learn how to build complex queries taking advantage of eager loading, sub-selects, ordering across joins, and more!

?

The ActiveRecord query interface is an impressive feat of engineering, but often we only use a small portion of it. In this trail we'll dive deep into ActiveRecord and learn how to build complex queries taking advantage of eager loading, sub-selects, ordering across joins, and more!

5 hours 6 minutes
Next Up

Introduction

In this course, we're going to go on a deep dive into ActiveRecord and teach you everything you need to know to manage complex relationships and queries. Joe Ferris, thoughtbot CTO and querying master, will be guiding us on our journey to help us take full advantage of ActiveRecord.

Unstarted

Querying belongs_to Associations

Learn everything you need to work with your belongs_to relationships inside the database. Use joins, merge, and more to define concise, efficient queries that take full advantage of ActiveRecord's power.

Unstarted

Querying belongs_to Associations Exercise

Put your new querying knowledge to the test with this exercise on querying belongs_to associations. Combine joins, merge, and the rest of tactics learned in the Querying belongs_to Associations video to lock in your new knowledge.

Unstarted

Querying has_many Associations

Learn advanced techniques for querying your `has_many` associations, including a deep dive into the `joins` method and how to use `merge` to compose queries and keep them logically separated.

Unstarted

Querying has_many Associations Exercise

Practice makes perfect, so dive into this exercise on querying has_many associations to lock in what you learned in the previous video. Use joins, distinct selects, and subqueries to query your has_many associations with ease.

Unstarted

Querying with Custom Joins

In some cases ActiveRecord just can't figure out the query you need, so you'll need to write it yourself. Luckily, it's not an all or nothing proposition. In this video learn how to use custom joins to answer complex questions about your database that ActiveRecord can't do for you.

Unstarted

Querying with Custom Joins Exercise

ActiveRecord can do a lot, but not everything. With this exercise, practice giving ActiveRecord a hand by writing custom SQL statements to define a join, all within the context of a larger ActiveRecord query.

Unstarted

Querying with Aggregations

After watching this video you'll attain querying master status. With this last installment, Joe teaches how to do some counts, minimums, maximums, averages, and sums. We'll even see how to perform these aggregations after grouping rows according to certain criteria and how to filter based on the results of these calculations, all via the database.

Unstarted

Querying with Aggregations Exercise

With this final exercise we'll bring everything together and even perform calculations and aggregations in the database. Complete this and you'll truly be a querying master.

9 steps remaining
Visit trail
Ruby on Rails Testing

Test-Driven Rails

Learn Test-Driven Rails Development using RSpec and Capybara in this series of tutorials. As part of the course, you can follow along with Josh as he lets his test drive through each of the steps needed to build out an application.

?

Learn Test-Driven Rails Development using RSpec and Capybara in this series of tutorials. As part of the course, you can follow along with Josh as he lets his test drive through each of the steps needed to build out an application.

2 hours 18 minutes
Next Up

Introduction

The Ruby and Rails communities have begun to embrace test-driven design, and for many employers, it's a skill expected of developers. At thoughtbot, we consider it a core competency and drive all development through tests. For developers new to testing, however, the most common question asked is, "Why test?" Josh discusses the goals of testing, forms of testing, and the tools we commonly use when testing Rails applications.

Unstarted

Setting Up the App and Initial Test

Time to write our first test! In this video, Josh discusses how to lay the foundation of a test suite within a Rails application, outlines the structure of an acceptance test, and writes an initial test ensuring we can interact with the application itself.

Unstarted

Creating the First Todo

With an understanding of basic browser interactions, we're now equipped to dig deeper into the Todo application. We'll discuss new test assertions and how to interact with forms by creating a todo.

Unstarted

Signing In and Todo Ownership

A list of todos is arguably valuable only when the list is owned by one person (or a group of people), but not everyone in the world. In this video, Josh introduces a simple User model and ensures that the todos created are assigned to the person who's "signed in."

Unstarted

Refactor to User Model

We've gone over "Red, Green, Refactor", but haven't performed a larger refactor in the todo codebase. In this video, Josh refactors the controllers to isolate interaction of `session` and introduces a `User` class which mimics a basic authentication library.

Unstarted

Completing a Todo

Managing a list of tasks to accomplish is great, but you know what's even cooler? Being able to mark things as done. In this video, Josh drives tracking completion of todos through acceptance and unit tests, and covers the intricacies of RESTful actions within the todo application.

Unstarted

Refactoring Todo Completions

Tests are code too, and as such, they can be refactored during the "Refactor" step of "Red, Green, Refactor." In this video, Josh covers how to extract common interactions and assertions in the test suite (having introduced similar paths through todo creation, todo ownership, and todo completion).

Unstarted

Marking Todos Incomplete

What happens when you incorrectly mark a todo complete? You mark it incomplete, of course! In this video, Josh introduces functionality to mark completed todos as incomplete, and refactors the controller to leverage a similar interface to marking a todo as complete.

8 steps remaining
Visit trail
Workflow

tmux

It's time to take control of your terminal! This course teaches you about tmux's pane and window management, session management, copy-paste, and more. You might be surprised how quickly you can learn to use tmux effectively, and how much it can add to your everyday efficiency.

?

It's time to take control of your terminal! This course teaches you about tmux's pane and window management, session management, copy-paste, and more. You might be surprised how quickly you can learn to use tmux effectively, and how much it can add to your everyday efficiency.

1 hour 31 minutes
Next Up

Part 1: Introduction

Learn about tmux's interface including panes, windows, and sessions and the handful of commands needed to get started.

Unstarted

Part 2: Configuration

Learn about the various ways to configure and extend tmux's behavior including defining custom key-bindings, tweaking the interface, and setting options to match your desired workflow.

Unstarted

Part 3: Navigation

Learn to create, organize, and efficiently navigate between tmux's panes, windows, and sessions as well as how to interact with scroll back and copy & paste.

Unstarted

Part 4: Vim Integration

Integrate Vim and tmux by unifying navigation within and between them, optimizing window layout, and sending commands from Vim to tmux.

Unstarted

Part 5: Advanced Workflow

Learn to efficiently create and destroy panes for one-off tasks, navigate between sessions with fuzzy matching, build prompted key-bindings, never leave tmux, and get a sense of what is possible beyond tmux's default behavior.

Unstarted

Part 6: Learning More

Learn how to make the best use of tmux's man page and help, as well as where to find additional online resources to continue learning your learning.

6 steps remaining
Visit trail
Foundations

Regular Expressions

Regular expressions (or regex) are a powerful way to search for text that matches a given pattern. At their best they are simple, elegant, and incredibly useful. This series of exercises will help you learn regex beyond the basics and build more sophisticated regular expressions to match complex and subtle patterns.

?

Regular expressions (or regex) are a powerful way to search for text that matches a given pattern. At their best they are simple, elegant, and incredibly useful. This series of exercises will help you learn regex beyond the basics and build more sophisticated regular expressions to match complex and subtle patterns.

4 hours
Next Up

Regular Expressions: Repeating Patterns

Avoid repetition in your regular expression by using built-in repetition operators.

Unstarted

Regular Expressions: Character Classes

Use character classes to make more-general regular expressions.

Unstarted

Regular Expressions: Anchors

Anchor your regular expression to the beginning of a line, the end of a line, or to a single word.

Unstarted

Regular Expressions: Tying it all together

Use everything you've learned so far to take your regular expressions to the next level.

4 steps remaining
Visit trail
Design

Bourbon Smash

Managing styling and front-end design can be complicated, especially if you spend most of your time as a developer. In this course you'll learn thoughtbot's Bourbon suite, a collection of tools and frameworks that make building clean, maintainable styles a breeze.

?

Managing styling and front-end design can be complicated, especially if you spend most of your time as a developer. In this course you'll learn thoughtbot's Bourbon suite, a collection of tools and frameworks that make building clean, maintainable styles a breeze.

4 hours 45 minutes
Next Up

Bourbon Smash Introduction

Wondering what exactly Bourbon and its friends are, and why you'd want to use them to build your styling? Well look no further. In this video we cover it all and explain how we think about front-end styling here at thoughtbot.

Unstarted

Sass Overview

Sass bills itself as "CSS with superpowers" and it certainly lives up to the title. In this video we introduce the most powerful and useful features of Sass to build more maintainable and clear stylesheets, and lay the foundation for Bourbon and Neat which rely on Sass for much of their magic.

Unstarted

Sass Foundations Exercise

Put your new-found Sass knowledge to the test in this exercise as we refactor a stylesheet from plain ole' CSS to Sass. In this exercise you'll get to try out great Sass features like imports, variables, nesting, and even loops, and come away with a solid grasp on how Sass can be used to clean things up.

Unstarted

Bourbon Introduction

Bourbon is our core library that helps us build maintainable stylesheets. It’s built with Sass and provides the foundation for all of our styles as well as Neat, Bitters, and Refills. In this video we explain exactly what Bourbon provides, and how you can best use it to aid your styling work.

Unstarted

Bourbon Foundations Exercise

Take advantage of Bourbon's mixins to style a login form. You'll get to work with both Sass and Bourbon in the exercise to lock in your knowledge.

Unstarted

Neat - Semantic Grids

Design a responsive grid without having to change your HTML! Neat layers onto the foundation of Sass and Bourbon, giving us the tools we need to build a semantic responsive grid with ease.

Unstarted

Neat Grids Exercise

Use Neat to build a responsive grid based layout. You'll use Neat's mixins as well as Sass variables to build a responsive grid, all without needing to change your HTML.

Unstarted

Bitters and Refills

Ok, Sass, Bourbon, and Neat all sound great, but who wants to start completely from scratch every time? With Bitters, our style foundation for building applications, and Refills, our catalog of pre-styled components, you can stick to the clean semantic design and still be up and running quickly.

Unstarted

Bringing It All Together

In this last video, we bring together everything from Sass, Bourbon, Neat, Bitters and Refills to style a Rails application. Tyson shows us his real process, and explains the thinking and choices at each step.

9 steps remaining
Visit trail
Testing

Rails Testing Exercises

So you want to get started with Ruby testing. All the cool kids are doing it. Seriously though, testing is fundamental. In this course of tutorials you’ll learn methods for improving code quality and minimizing time required to add new features to software by ensuring that each facet of the program works as expected.

?

So you want to get started with Ruby testing. All the cool kids are doing it. Seriously though, testing is fundamental. In this course of tutorials you’ll learn methods for improving code quality and minimizing time required to add new features to software by ensuring that each facet of the program works as expected.

5 hours
Next Up

Passing Your First Test

In order to get your feet wet with testing, let's write a test for a simple Ruby class.

Unstarted

Testing ActiveRecord

In this exercise, you'll write an RSpec model test to verify a simple validation.

Unstarted

Write an Integration Test

In this example, we'll be using Capybara to write an integration test.

Unstarted

Write a controller spec

In this example, you'll write a unit test to make sure the create action for PeopleController works as expected based on the return value of save.

Unstarted

Write A Feature With Tests

Time to put it all together! In this exercise, you'll add enhance a small Rails applications by adding the ability edit existing people. You'll implement the necessary actions and views in the Rails application, writing tests as you go.

5 steps remaining
Visit trail
Ruby on Rails

Intermediate Ruby on Rails (Rails 5)

Dig deeper into Ruby on Rails. This series of video tutorials will help you move beyond the basics and start understanding and using more advanced Ruby- and creating better Ruby apps.

?

Dig deeper into Ruby on Rails. This series of video tutorials will help you move beyond the basics and start understanding and using more advanced Ruby- and creating better Ruby apps.

3 hours 31 minutes
Next Up

1: Setup & Authentication

Unstarted

2: CRUD, Validations, and Partials

Unstarted

3: Polymorphic Associations

Unstarted

4: File Uploads with Paperclip

Unstarted

5: Rails Helpers

Unstarted

6: Complex Associations

Unstarted

7: Refactoring

Unstarted

8: Advanced Refactoring

Unstarted

9: Basic Search

Unstarted

10: Advanced Search

10 steps remaining
Visit trail
Testing

Fundamentals of TDD

You've heard about testing, and even better "Test-Driven Development", but you're still not sure exactly what they are. Well now you'll know!

In this trail, thoughtbot developers Harry Schwartz and Ian C. Anderson cover core principles of writing code with Test-Driven Development. You'll learn about the benefits of testing, the way testing first applies positive design pressure to your code, and how to apply TDD to your own development.

?

You've heard about testing, and even better "Test-Driven Development", but you're still not sure exactly what they are. Well now you'll know! In this trail, thoughtbot developers Harry Schwartz and Ian C. Anderson cover core principles of writing code with Test-Driven Development. You'll learn about the benefits of testing, the way testing first applies positive design pressure to your code, and how to apply TDD to your own development.

2 hours 15 minutes
Next Up

Fundamentals of TDD - Overview

In this course, we're going to cover the core principles of TDD and how you can use it to improve the code you write and maintain. thoughtbot developers Harry Schwartz and Ian C. Anderson will be your guides throughout the course, guiding you toward more productive development through Test-Driven Development.

Unstarted

Red-Green-Refactor by Example

Learn the red-green-refactor loop, the primary principle of TDD. Write tests first, watch them fail, write code incrementally until the tests pass. With passing tests, use the opportunity to refactor.

Unstarted

Telling a Story with Your Tests

A well-written test case tells a clear story, communicating the intent of code. Learn how to write expressive tests and why duplication isn't always a bad thing in your test cases.

Unstarted

TDD Spec Cleanup Exercise

Put your new TDD knowledge into action with this exercise. You'll take an existing spec and whip it into shape, making it clear and purposeful!

Unstarted

Introducing the Unit Converter

Apply the ideas of TDD to a more complicated piece of code. Isolate specific behaviors and build incrementally, using your test failures to guide your next addition to the code.

Unstarted

Refactoring with Test Coverage

With a test suite in place, you can refactor with confidence, knowing that your tests will guard against regression. Learn how to leverage your tests while refactoring an existing piece of code.

Unstarted

Integration vs. Unit Tests

Integration and unit tests both play important roles in your application's test coverage. Learn when to use each type of tests, guidelines for when to mock collaborators in tests, and how integration and feature tests can drive the creation of unit tests.

Unstarted

Going Further with TDD

Resources for further exploration of Test-Driven Development.

8 steps remaining
Visit trail
Workflow

Mastering the Shell

Regardless of language, learning the building blocks of the command line can improve your development experience in so many ways. Whether you're using Ruby or Haskell or anything else, shell scripting will increase your speed and efficiency!

?

Regardless of language, learning the building blocks of the command line can improve your development experience in so many ways. Whether you're using Ruby or Haskell or anything else, shell scripting will increase your speed and efficiency!

1 hour 18 minutes
Next Up

Mastering the Shell - Overview

Unstarted

Slice and Dice

Unstarted

Pipes, Input, & Output

Unstarted

Shell Scripting

Unstarted

Making Your Life Easier

5 steps remaining
Visit trail
Vim

Dive Into Neovim

Join Drew Neil, host of Vimcasts, as he takes us on a tour of Vim 8 & Neovim.

?

Join Drew Neil, host of Vimcasts, as he takes us on a tour of Vim 8 & Neovim.

47 minutes
Next Up

Packages

Packages are a new feature in version 8 of Vim. In this video, we'll see how we can use packages to easily install Vim plugins. The process will be familiar if you've used `pathogen`.

Unstarted

minpac

Minpac is a minimal package manager for Vim 8. It makes it easy to add plugins, keep them up to date, and remove them. In this video, we'll see how it works.

Unstarted

Meet Neovim

In this video, we'll see how to install and set up NeoVim so that it reuses your existing Vim configuration files. Most plugins should work in NeoVim just like they do in Vim.

Unstarted

:Checkhealth

Neovim's `:CheckHealth` command can diagnose problems with your configuration. In this video, we'll run this command and follow its suggestions to enable features such as python integration and ruby integration.

Unstarted

Neat little Neovim features

In this video we're going to cover a couple of small but delightful NeoVim features. We'll see how to make NeoVim show a live preview of how the substitute command will change our document. And we'll find out how to make the yank operation highlight the range of text that it copied.

Unstarted

Neovim's Terminal Emulator

NeoVim lets us run a terminal emulator inside of a buffer. In this video, we'll cover some of the basics of how terminal buffers work, and how we can use them alongside regular buffers in our workflow.

Unstarted

Creating mappings for :terminal

Neovim lets us create mappings using the meta key. In this video, we'll set up some mappings to make it easier to exit from Terminal mode. We'll also set up mappings using the meta key with h, j, k, and l to switch between split windows.

Unstarted

Pasting into a terminal buffer

Yanking and pasting works seemlessly between Neovim's regular buffers and terminal buffers. In this video, we'll look at how the Normal mode paste command works in a terminal buffer, and we'll create a mapping to help with pasting text directly from Terminal mode.

Unstarted

Sending commands to a terminal buffer

One of the more powerful features of having a terminal integrated into Neovim is that it allows us to send commands from our Vim buffers over to the terminal for execution.

Unstarted

Neovim-remote as preferred editor

We can configure bash so that it launches Neovim as our preferred editor. What about when bash is running inside of a Neovim terminal emulator? In this video, we'll see how the neovim-remote tool lets us use the active `nvim` instance as our preferred editor.

10 steps remaining
Visit trail