These are trails, the perfect thing to tackle on a Saturday or a wide-open evening when you're ready to write some code or watch longer videos. Some trails consist of videos, like our tmux trail. Others use our coding exercises. In those, you'll clone down a git repo and write code on your own machine. The trails are each broken down into clear steps to allow you to tackle them in manageable chunks.
Learn to use stubs, mocks, spies, and fakes with RSpec.
Learn to use stubs, mocks, spies, and fakes with RSpec.
Learn to set constraints on stubbed methods using RSpec.
Learn to unit test methods with side effects and mutation using mocks.
Learn how to keep your unit tests tidy with an alternative to mocks: spies.
Learn how to test complex or flexible interactions by using fakes.
Now that you've learned how to use stubs, mocks, spies, and fakes, it's time to pull it all together.
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!
Write a program that reads a file containing a Sudoku grid and validates it.
Write a program that accepts two poker hands and returns the winner.
Write a program that can solve any Sudoku puzzle.
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).
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.
Learn to replace variables with query methods.
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.
Learn how to safely split up classes in small steps.
Learn to encapsulate logic surrounding nil by introducing Null Object classes.
Take your Null Object skills to the next level by completing this additional exercise.
Learn how to simplify a class by extracting a value object.
Learn how to replace a long list of parameters with a single parameter object.
Learn how to extract a validator into its own class with this exercise.
Slim down a controller that's gotten a bit bloated.
Learn how you can interact with entities of different types by replacing conditionals with polymorphism.
How to plan, design, develop, and launch a successful web application.
How to plan, design, develop, and launch a successful web application.
Get better at visual design and create something great.
Get better at visual design and create something great.
Build. Measure. Learn.
Build. Measure. Learn.
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.
Use character classes to make more-general regular expressions.
Anchor your regular expression to the beginning of a line, the end of a line, or to a single word.
Use everything you've learned so far to take your regular expressions to the next level.
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.
In this exercise, you'll write an RSpec model test to verify a simple validation.
In this example, we'll be using Capybara to write an integration test.
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.
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.
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.
"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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Integrate Vim and tmux by unifying navigation within and between them, optimizing window layout, and sending commands from Vim to tmux.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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."
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.
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.
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).
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.
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.
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.
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.
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!
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.
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.
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.
Resources for further exploration of Test-Driven Development.