Techniques Code Reflections
Advanced Difficulty

Reflecting upon the code you've written is an important step for any developer. It's not enough to simply extract, refactor, and call it a day. No. Once complete, you must evaluate what you've done. Is the code now better? Is it more clear? Don't underestimate how difficult a question this can be. Our brains manage to trick us at every turn.

1h 10m
Play
Languages JavaScript Techniques For Server-Side Applications
Intermediate Difficulty

Many Laravel apps don’t warrant the complexity of a full front-end framework like Vue or React. In this series, we’ll walk through a handful of simple ways to add dynamic functionality to your apps. By combining various strategies, you can keep your simple Laravel stack, but still build interfaces that feel fast, fresh, and dynamic.

48m
Play
Techniques Three-Minute Tips
Intermediate Difficulty

I get it. We don't always have twenty minutes to watch a new lesson. But maybe you have three? If so, this series is for you. Each episode provides one isolated tip or technique that you might consider for your own projects.

Play
Languages Object-Oriented Principles in PHP
Intermediate Difficulty

The typical beginner, whether they realize it or not, first learns procedural programming. But, before too long, they level up. Suddenly, an entirely different paradigm is introduced: object-oriented programming. Little do they know that they'll spend years researching and learning exactly what it means to work with objects and messages. In this series, you'll be introduced to the core principles of object-oriented programming in PHP. We'll begin with the basic constructs and work our way up.

1h 33m
Play
Languages PHP Bits
Intermediate Difficulty

Because our industry advances so quickly, it's far too easy for bits and pieces to fall through the cracks. Each episode in this series provides a standalone two-minute dose of PHP knowledge. Think of them as Red Bull for your brain: a rapid surge of education.

31m
Play
Techniques 10 Techniques for Cleaner Code
Intermediate Difficulty

We've all written code that misses the mark. Sure, it works, but, still, you're left with the feeling that you've missed something. The difficult part, unfortunately, is recognizing what that "something" is. In this series, we'll review ten techniques, one per episode, to improve the clarity of your PHP code.

1h 54m
Play
Techniques Whip Monstrous Code Into Shape
Advanced Difficulty

You did your best, but somehow that User object, over time, morphed into a monstrous God object. And your controllers started out nice and clean, but now... not so much. We've all been there. In this series, we'll review a number of ideas for whipping convoluted code into shape.

3h 40m
Play
Techniques SOLID Principles in PHP
Advanced Difficulty

SOLID represents a series of guidelines that developers can use to, if done well, simplify and clarify their code. While certainly not laws, understanding these concepts will make you a better developer.

57m
Play
Techniques Design Patterns in PHP
Advanced Difficulty

A design pattern is a common solution to a common problem. Nothing more, nothing less. And, while some of these approaches might seem foreign or overwhelming to you, the important thing to remember is that, as a developer, you are in charge. That means you decide when a pattern is appropriate, and when it's completely unnecessary. That's the key.

1h 43m
Play
Techniques Simple Rules for Simpler Code
Intermediate Difficulty

If you've ever heard a developer use the term, "object calisthenics," you might have assumed that they were referring to some hugely complex topic. Luckily, though, that's not the case. It simply refers to a series of coding exercises to promote better software.

53m
Play