Whatcha Working On

Series Episodes

1. Episodes (41)
   1. Laravel Test Helpers for Selenium

      24m 48s

      The test helpers in Laravel 5.2 provide a beautiful, fluent API for integration testing your applications. However, these tests are triggered in memory, which means you don't get JavaScript execution out of the deal. When such tests are necessary, you'll likely need to use something like Selenium.
   2. Elixir Refactoring

      21m 10s

      Today, I'm working on a bit of refactoring for the Laravel Elixir codebase. In this lesson, come along, as I experiment with a particular refactor - which will hopefully organize things a bit more cleanly.
   3. Adding Featured Content

      8m 06s

      There's nothing too fancy in this episode. We need to take the "most recent series" section on the Laracasts home page, and turn it into a curated, featured list. Along the way, we'll discuss the value in not over-doing tasks like this. While we could whip up a UI with a bunch of drag and drop goodness, the reality is that all of that takes time. Why not opt for the simplest possible implementation first, and then you can always expand upon it in the future - if and only if you decide it's necessary. As such, we'll simply hardcode a list of series ids that we wish to feature within a config file. Easy!
   4. Turbolinks with Laravel

      14m 43s

      Today, I'm tinkering around with Turbolinks, which was recently - at the time of this writing - extracted to its own library that may be used anywhere. It's pretty sweet! Drop it in, and it instantly begins working. All anchor links clicks will be intercepted, and AJAX requests will be sent in their place. This allows for a signifiant performance boost, as the user only needs to download relevant scripts and stylesheets once on the initial page load.
   5. Elixir Webpack Plugins

      20m 18s

      Today, I'm personally working on a particular GitHub issue that revolves around hooking into Elixir's default Webpack configuration. Want to come along?
   6. How to Animate an Object Along a Circle With CSS

      19m 26s

      Why don't all Laracasts videos focus on PHP and Laravel? Because that's not real life. Sure, sometimes you need to write server-side code. But, at other times, you're tasked with animating an object along a freaking circle. So let's figure out how.. ;)
   7. Working With the Simplecast API

      12m 05s

      As part of the Laracasts refresh that I'm currently working on at the time of this recording, I need a dedicated page for my "Laracasts Snippet" podcast. In this episode, as an example, we'll create a brand new project, fetch my podcast feed using Simplecast's API, cache it, and then render it in a view.
   8. A Webpack-Only Elixir

      9m 20s

      What I'm working on today is a potential new/separate version of Laravel Elixir that exclusively uses Webpack, rather than Elixir. In this episode, rather than writing code, we'll talk about why I'm working on this, and what the potential benefits are.
   9. Dynamic Asset Paths Using TDD

      18m 29s

      For this new version of Laravel Mix (the evolution of Laravel Elixir) that I'm working on, I need to create a single PHP function that can dynamically calculate the correct path to an asset, such as a script or stylesheet. This should work, regardless of whether hot reloading or file versioning have been enabled/requested. Let's knock it out together, using TDD.
   10. How I Personally Learn: Dusk Edition

       35m 48s

       This episode will be a bit different. Come along, as I personally learn how to use Laravel Dusk (Laravel's new acceptance testing package) completely from scratch. While most lessons at Laracasts are edited to be as succinct as possible, this one is a bit more realistic, and reflects how I personally learn a new tool.
   11. Testing Implementation Details

       9m 26s

       It's very easy to fall into one particular testing trap. Are you testing your public interface, or the underlying implementation details? If you've ever noticed that any change to your code requires updates to their respective tests, take a moment and ask yourself why that is.
   12. An Ad Component

       13m 21s

       Today, I'm implementing a small ad-strip below Laracasts videos for guest users who aren't officially subscribed to Laracasts. Hey, it helps pay the bills, okay? Now, I've received basic instructions about the company's JSON API, but haven't implemented a single line of code yet. Come along, as I work through the process! I think we'll need to create a dedicated Vue component.
   13. Coupon Generation With TDD

       21m 46s

       In this episode, I'm working on the Laracasts codebase. Specifically, I need a simple way to quickly generate single-use coupon codes, save them to the database, push them to Stripe.com, and then fire off an email to the recipient of the coupon. Let's use TDD to implement this functionality, and then, once we're at green, perform a round of refactoring to clean things up. Ready?
   14. Make Sure the Dang Thing Works

       11m 14s

       Today, I'm finishing up the 1.0 release of Laravel Mix. If you'd like to come along, I need to flesh out a few more end-to-end tests for the project. In many ways, these are far and away the most important tests you can write. Nobody cares that your unit tests pass, if the system doesn't work for the user!
   15. Vue and Turbolinks Sitting in a Tree

       8m 20s

       Vue is fantastic. Turbolinks is, too. So what if we could find a way to use them together seamlessly. Well, out of the box that can be a bit tricky, due to a few reactivity and caching issues. Luckily, though, this problem seems to have been solved. In this episode, come along as I test it out.
   16. Incredibly Fast Instant Search With Algolia and Vue

       14m 12s

       During Laracon 2017, Maxime Locqueville demoed Algolia's excellent new Vue InstantSearch package. After watching this presentation, very quickly, I realized that I needed to improve the forum search functionality here at Laracasts. So come along as I get my feet wet and figure out how to use this new Vue plugin from scratch.
   17. High-Level Overview of the Laracasts Search Integration

       13m 31s

       In the previous episode, together, we figured out how to use Algolia's Vue InstantSearch component package. At the conclusion, I noted that I would implement it for Laracasts. That process is now done, so come along as I provide a high-level overview of the integration and how it all pieces together.
   18. Please Come Back

       9m 38s

       Today, I'm working on the Laracasts codebase, itself. We need to fire off a "Please Come Back" email, each day, to all users who canceled their account two months ago. In this episode, we'll use TDD to drive out this logic from scratch.
   19. Refactoring in the Real World

       22m 18s

       Today, I'm working on an old package of mine that converts PHP variables to the proper JavaScript syntax. There are a number of refactorings we can perform to clean up the codebase a good bit. Why don't you come along, and we'll work through the codebase together? We'll focus on naming, class extraction, and general readability.
   20. Refactoring in the Real World: Part 2

       18m 14s

       In the previous episode, we took a few good steps toward cleaning up the codebase. But I bet, if we think hard, we can take things even further. Let's finish up our full refactor in this episode.
   21. Learn Vuex With Me: Part 1

       21m 03s

       Far and away, the most frequently requested subject material at Laracasts is a review of Vuex. However, I've been hesitant to oblige in the last year. I'm not sold yet. As such, these next few videos will be a bit unique. Rather than serving as an endorsement from an "expert," I'll be taking the role of the student. Come along as I review the documentation, try things out, make mistakes, and work my way through the learning process. Together, we'll come out the other side with a much better understanding of the pros and cons to this approach to state management, as well as when we might reach for it in future projects.
   22. Learn Vuex With Me: Part 2

       10m 33s

       We're starting to wrap our heads around the basic concept of Vuex, so let's continue on in this episode with a review of getters and actions.
   23. Learn Vuex With Me: Part 3

       19m 59s

       Now that we have a firmer grasp of the fundamentals, let's work through one of the vuex example projects. We'll build your typical, boring todo app. This should give us a better understanding of how to organize the Vuex store, and delegate to it from our Vue components.
   24. Filling In Missing Tests

       11m 55s

       Today, I need to add a missing test for a recent Laravel Mix PR that we merged. Even though I'm sure the PR code is correct, it's important that we fill it in with a test to ensure, for the lifetime of the project, that this piece of functionality does exactly what we expect it to.
   25. A Countdown Vue Component

       15m 33s

       Today, I need to whip up a countdown timer for an upcoming sale. While we could pull in a dedicated plugin for this functionality, it's fairly simple to implement on our own with Vue. Come along, as I knock it out in this episode.
   26. Vue Modals, Spinners, and Tailwind

       19m 01s

       In this episode, come along as I prepare a login modal from scratch. As it turns out, this will provide a number of useful real world examples for us to work through. How do you display and hide a modal from anywhere in your app? Can we display validation errors without manually performing a full page refresh? What can we use to rapidly style our form? And might we implement one of those fancy loading spinners after the "Log In" button is pressed? All of these questions (and more) will be answered.
   27. Refactoring to Mix Plugins

       16m 48s

       In this episode, I'll outline my thought process behind a Laravel Mix codebase refactor that I'm currently working. We'll address the areas that I've determined to be problematic, and then discuss and review the solution I've come up with to make each component of the API more cohesive.
   28. Feature Testing Real JavaScript

       16m 06s

       If you don't mind, let's continue on from the previous episode, where we reviewed a plugin refactoring for the Laravel Mix codebase. In this episode, I'd like to verify that this approach can be used by any author to introduce new functionality into Mix. It sounds like we need to prepare a feature test to declare each ability that the code should offer. Come along!
   29. Custom 404 Pages and the Borg

       19m 29s

       Come along, as I upgrade the Laracasts 404 page from Laravel's default view to something a bit more special. In this episode, you'll learn how to override the default 404 view, render AfterEffects animations with Airbnb's Lottie library, and then write the necessary page CSS with Tailwind. ...And we'll do it all in less than twenty minutes.
   30. Improved Refactoring and Responsibilities

       22m 03s

       Today, I'd like you to come along as I refactor a class with too many responsibilities. Once we've found and addressed the issue, we'll prepare a series of tests to confirm our new desired public API and protect our refactoring against any potential regressions.
   31. Focus on Small Refactors

       25m 17s

       In this episode, we'll work through a refactor of the "Browse" page here at Laracasts. I've tweaked the code just enough to give us a variety of small refactors to work on. And "small" is key for this lesson. Specifically, we'll focus on indentation, variable names, and clarity.
   32. Vue Convenience Components

       11m 58s

       In this lesson, come along as I refactor my "slide up" modal Vue components. The goal will be to ensure that future modals will be as simple and intuitive as possible to construct and configure.
   33. Mentionable Usernames with TDD

       24m 31s

       For the next version of the Laracasts forum, we offer a small feature that provides @username autocompletion when writing a new reply. To populate this list of usernames, we reference the conversation owner, every person who has left a reply, and all usernames who have been mentioned within those replies. Let me show you how to construct this very logic from scratch, using TDD. This lesson will give us a chance to flex our regex and refactoring muscles, so it should be fun! Let's get started.
   34. Publishing Beta Releases to NPM

       8m 49s

       In this episode, come along as I, in real-time, publish the beta release of Laravel Mix 4 to GitHub and NPM. This new version of Mix catches us up to webpack 4, Babel 7, and vue-loader 15. As part of that update, however, a number of code changes were necessary. With that in mind, I'd like to do a round or two of beta releases before we pull the trigger and officially release Laravel Mix 4 to the public.
   35. Commentable Workshop

       26m 39s

       To save time, Laracasts originally used Disqus for its video comments section. However, it's time to migrate to a native solution that is better connected to your user profile. Come along as I use TDD to begin constructing the API for a new threaded comments section.
   36. Frontend Authorization Brainstorming

       17m 03s

       Laravel's Policy classes are incredibly useful for managing authorization logic for your models. But what happens when we require authorization on the frontend - perhaps within a Vue component? Let's review three approaches that you might consider.
   37. The Smallest Feature We Can Implement in Seven Minutes

       7m 17s

       I thought you might like to come along, as I implement a tiny feature for the Laracasts video page. If a user edits their comment, we need to track this change and display a (edited) flag next to their username. This provides a small heads-up that the comment has changed since its original publish date.
   38. How to Dynamically Inline SVG Files in Vue Components

       16m 09s

       Imagine that you need to iterate over a list of items and render the contents of an SVG icon for each. With PHP, this is a cinch. We only need to append the .blade.php extension to each file. Then, we can dynamically @include the necessary SVG file. However, when inside a Vue component, things get a bit more tricky. I recently hit a roadblock when working on this very issue. In this episode, we'll review how to solve this problem with webpack and Laravel Mix. A special hat tip goes out to Caleb Porzio, who documented the solution we review in this episode.
   39. Learn Cypress with Laravel Integration

       33m 23s

       I dedicate half of most Fridays to learning new techniques, tools, and libraries. This week, that tool is Cypress: an excellent acceptance testing framework. In this episode, if you'd like to hang out with me, come along as I discuss what I learned and how I wired it up to work nicely with Laravel. This way, we can easily create Eloquent factories or set the authenticated user without returning to the login form for every test.
   40. What I Learned About Cypress on Day 2

       18m 29s

       In the previous episode, we discussed everything I learned about Cypress.io on my first day. In this lesson, we'll move on to day two. I learned about additional assertions, contexts, database seeding, custom HTML data attributes, the Cypress dashboard, and more.
   41. Beware of the Filtered Array

       9m 57s

       I recently ran into a nasty little bug in the Laracasts codebase that took me a while to track down. Once I realized what the problem was, the solution only required a few characters. In this lesson, we'll review a small demo that reproduces an issue related to casting a filtered PHP array to JSON.