Shows
No CompromisesWhy senior developers feel wrong more oftenEver catch yourself second-guessing decisions you were confident about just months ago? Does that mean you're getting worse at your job?In the latest episode of the No Compromises podcast, we explore why senior developers often feel "wrong" more frequently than they did earlier in their careers.Aaron makes the case that this isn't a sign of declining skill—it's evidence of a richer mental model that reveals nuance where things once seemed black and white.We discuss how feedback sources shift with experience, why changing your mind signals growth rather than failure, an...
2025-12-2010 minNo CompromisesShould you ever hand-format code?Ever feel like you're wasting your time tweaking a section of code to get it just right? We have tools for that, don't we? In the latest episode of the No Compromises podcast, we discuss when to trust auto-formatters and when to nudge code by hand. Aaron makes the case that a few mindful minutes of “prettying up” can unblock harder thinking, without surrendering judgment to tools. We set limits on this approach, share a tiered break strategy, and make it clear why you still own what the formatter changes.(00:00) - Aut...
2025-12-0607 minNo CompromisesDiscussing different ways to model dataIt's easy to overcomplicate data modeling, especially when enums, relationships, and future requirements are in play. In the latest episode of the No Compromises podcast, Joel brings Aaron a real-world technical dilemma: how to model a relationship between two models when types are stored as enums, not models. We discuss the pros and cons of pivot tables versus JSON columns, the importance of context before jumping to solutions, and how developer instincts can sometimes get in the way of clarity.(00:00) - Setting up the technical problem
(02:00) - Pivot tables vs JSON columns
(05:15) - Fi...
2025-11-2211 minNo CompromisesRead outside tech to expand your horizonsIt's easy to get so laser-focused on programming and tech, that you close yourself off to other avenues of learning.In the latest episode of the No Compromises podcast, Aaron argues that non-tech reading can sharpen your engineering thinking.We discuss balancing breadth without diluting focus, and how to turn casual reading into active learning with quick capture habits.(00:00) - An example from a book on business
(03:30) - Don’t go too broad
(05:15) - Practice active learning
(07:15) - Read something different
(07:30) - Silly bit
You should still read our Laravel books th...
2025-11-0809 minNo CompromisesChanging your mind about when() and unless() in EloquentAaron admits he used to wrap every query in plain old if-statements—until Laravel’s when()/unless() helpers (and arrow functions) won him over. He and Joel compare their journeys, debate readability trade-offs, and share guidelines for deciding which style to use. Along the way they discuss false assumptions, evolving “code grammar,” and how tools such as Rector can automate the switch.(00:00) - Intro – refining long-held opinions
(00:45) - Aaron’s original “query-then-if” pattern
(01:45) - Why when() first felt clumsy (closures, scopes, extra params)
(03:45) - Arrow functions & smaller conditions make when() nicer
(05:00) - Joel’s lingering objection: avoiding unless...
2025-08-0211 minNo CompromisesFinding a code-review style that fits your brainJoel and Aaron compare two very different ways to tackle pull-requests—reviewing them commit-by-commit or scanning the whole thing at once. They dig into when each approach shines, how “atomic” commits can help (or hurt) reviewers, and why understanding how your teammate’s brain works is a super-power. Along the way they share practical tips for leaving yourself notes, spotting hidden changes, and keeping large refactors under control.(00:00) - The “gift” of a pull request and the pain of huge PRs
(02:30) - Joel’s commit-by-commit strategy and where it helps
(04:50) - Aaron’s Tetris-style holistic review (and leaving self...
2025-07-1916 minNo CompromisesNever take hostages: give clients control from day oneJoel and Aaron explain why every project should start in the client’s own GitHub organization—even when the client has never heard of Git. They share scripts, onboarding tips, and war-stories that show how small setup shortcuts turn into big headaches later. You’ll learn a repeatable way to protect both your reputation and your client’s code base.(00:00) - Intro & episode setup
(01:15) - Create the repo in their org
(02:15) - Quick hack versus right process
(03:30) - Project-setup technical-debt risks
(05:00) - Declaring non-negotiables to clients
(06:45) - Docs that survive “hit-by-bus” events
(08:00) - Solo-dev reputation boosters
(08:45) - Silly bit
...
2025-07-0510 minNo CompromisesBalancing test coverage without chasing 100 percentJoel and Aaron unpack how they use code-coverage numbers as a starting signal rather than a finish line. They discuss realistic thresholds, choosing the right tool for each test layer, and why coverage metrics can double as negotiation leverage inside big organizations. Listen in for practical ways to decide what to test—and when to stop.(00:00) - Testing passion vs. shipping work
(01:00) - Coverage tells you what’s missing
(03:45) - Picking a baseline metric that grows
(06:15) - Draw the line between logic and UI tests
(12:45) - Silly bit
Want help getting started with your test cove...
2025-06-2115 minNo CompromisesExploratory coding when requirements are fuzzyJoel and Aaron unpack a recent client project where the only spec was “make these two systems talk.” They share how console-level prototypes helped them clarify data mapping, test tricky scenarios, and keep the client looped in without over-building a UI. If you’ve ever had to code first and document later, this one’s for you.(00:00) - Bridging two APIs with minimal specs
(03:30) - Choosing an exploratory workflow over full UI
(06:00) - Console closures for quick, testable steps
(09:15) - Hand-off strategy: letting others poke the prototype
(11:45) - Silly bit
2025-06-0715 minNo CompromisesUnderstanding how Stringable works inside Blade viewsJoel and Aaron dig into Laravel’s `Stringable` class and uncover how it can silently skip Blade’s automatic HTML escaping. They explain why that’s both a convenient feature and a potential security pitfall if user input isn’t properly sanitized. You’ll hear practical ways to keep your views safe without losing the API’s fluency.(00:00) - Stringable can sidestep Blade escaping
(03:45) - Dangers of outputting unsanitized HTML
(05:45) - Defensive strategies for safe rendering
(08:45) - Silly bit
Sign up for a short, but useful, Laravel tip each day in our newsletter
2025-05-2410 minNo CompromisesFinishing up our discussion on not having timePicking up where last week’s “Why ‘no time’ really means ‘no priority’” left off, Joel and Aaron tackle the next hurdle: what to do once the benefits are crystal‑clear but you (or your team) still hesitate. They unpack the hidden frictions—fear of discomfort, stakeholder pushback, or sheer inertia—that keep valuable tasks on the back burner. You’ll hear a quick mental exercise for elevating true priorities and concrete tactics for transforming “someday” into forward motion today.(00:00) - “No time” excuses hide real priorities
(01:45) - Sell improvements by proving clear payoff
(04:15) - Face hidden conflicts and track gai...
2025-05-1011 minNo CompromisesWhy “no time” really means “no priority”Joel and Aaron tackle the common objection, “We don’t have time,” and show why it usually hides a priority problem. They discuss how to convey the true payoff of process improvements by sharing honest before‑and‑after stories instead of vague promises. You’ll leave with practical ideas for getting buy‑in—whether you’re pitching tests, planning habits, or any other change.(00:00) - “No time” excuse versus priorities
(01:45) - Selling the value of improvements
(03:45) - Sharing real before‑and‑after stories
(05:15) - Balancing honesty with motivation
(09:15) - Silly bit
Stay tuned for part 2... Until then, there's always...
2025-04-2611 minNo CompromisesWhen validation can protect your app's performanceJoel and Aaron show how ignoring GET request validation can cause performance issues and open your application to abuse. They highlight the importance of bounding pagination and share tips for using form requests to handle unexpected user input.Now go check out the best/only Laravel validation book(00:00) - Quiz on Laravel’s default pagination limit
(01:00) - Performance concerns with large datasets
(03:20) - Validating per-page requests in controllers
(05:45) - Why you should block negative page numbers
(09:20) - Silly bit
2025-04-1212 minNo CompromisesStick with conventions and avoid overengineering your Laravel appJoel and Aaron explore why pushing too many layers of abstraction can backfire in a Laravel application. They highlight the benefits of sticking to the framework’s conventions for long-term maintainability and simpler handoff to future developers.(00:00) - Why framework paradigms really matter
(01:00) - When extra abstractions become burdens
(03:00) - Balancing creativity with Laravel’s conventions
(05:15) - Keeping code easy to revisit
(06:45) - silly bit
Need help digging your project out of technical debt? We can help!
2025-03-2908 minNo CompromisesWhen to bring in outside helpJoel and Aaron explore the decision-making process behind hiring or consulting an expert for technical challenges. They discuss examples like adding tests to a large codebase and understanding what questions you need to ask. They also reveal how coaching can help teams avoid common pitfalls and reach solutions faster.(00:00) - Determining why you need outside expertise
(02:15) - Pinpointing the real problem (skill gap or strategy)
(05:00) - Deciding between hands-on help or coaching
(08:30) - Learning to ask the right questions
(09:15) - Silly bit
Here is a way to explore how we could help your project
2025-03-1510 minNo CompromisesWhy two databases are better than oneJoel and Aaron discuss the benefits of having distinct databases for testing and local development. They share how this approach ensures a reliable test suite and avoids conflicts with day-to-day dev work. In the process, they reveal a simpler workflow for setting up new environments and keeping projects stable.(00:00) - Why separate dev and test databases
(02:15) - Automating database setup with seeders
(05:00) - Avoiding flaky tests and migration pitfalls
(09:00) - Reimagining old habits with new practices
(12:00) - Silly bit
Sign up for the free Mastering Laravel newsletter
2025-03-0114 minNo CompromisesDealing with being a beginner againIn this episode, Joel and Aaron discuss the struggles of learning new technology on a late-night side project. They share tips for handling frustration and managing expectations.(00:00) - Late-night MicroPython struggles and revelations
(02:15) - Overcoming complex hardware and language hurdles
(05:15) - Balancing side projects with realistic expectations
(10:30) - Silly bit
Don't be a stranger. Check out the Mastering Laravel community.
2025-02-1514 minNo CompromisesMaking short demo videos countJoel and Aaron explore the value of using concise video demos instead of long emails or scattered screenshots. They discuss which clients benefit from quick visuals and when text is still best.Want to see us on camera? Join the Mastering Laravel community for our live dev calls.(00:00) - Recording brief Loom demos for updates
(02:15) - Considering audience and communication style
(05:00) - Video calls vs. text-based explanations
(07:45) - Silly bit
2025-02-0109 minNo CompromisesExamining test layering in multi-tenant requestsJoel and Aaron debate how to structure multi-tenant API requests and tests. They explore the interplay between authentication, tenant headers, and different levels of validation. In the end, they reminisce about old infomercial freebies and wonder if they still exist.(00:00) - Debating authentication vs. tenant header priority
(02:15) - Handling unusual requirements in request tests
(05:00) - Navigating multi-layer middleware concerns
(08:30) - Balancing thoroughness and test coverage
(12:00) - Silly bit
Want some advice on writing better tests for your app? Contact us.
2025-01-1813 minNo CompromisesWhen to step outside of Eloquent's comfort zoneJoel and Aaron explore the nuances of when to venture beyond Eloquent in Laravel applications. They discuss specific scenarios where using lower-level database tools might be necessary, while emphasizing the importance of not abandoning Eloquent entirely. The conversation provides practical insights into balancing framework features with performance needs.(00:00) - Exploring when to step outside framework defaults
(02:30) - Handling complex sorting with related tables
(05:25) - Balancing Eloquent features with DB builder tools
(07:15) - Important considerations when dropping to lower level DB access
(10:00) - Silly Bit
Check out the Mastering Laravel community.
2025-01-0412 minNo CompromisesFeature flags: Temporary tool or permanent solution?Joel and Aaron dive into a friendly debate about the true nature of feature flags in software development. Drawing from their varied experiences across different programming languages and environments, they explore whether feature flags should always be temporary or can serve permanent purposes. The discussion evolves from a simple disagreement into deeper insights about different architectural approaches.(00:00) - Newsletter tips undergo careful peer review process
(02:15) - Debating if feature flags should be temporary
(05:25) - Different uses of feature flags across languages
(07:20) - Feature flags in modern Laravel applications
(08:35) - Silly Bit
Sign up for free...
2024-12-2110 minNo CompromisesDeciding when to use a new piece of technologyOoh, something new was just announced. And I have this project coming up. It could be perfect! But should I use it?On today's episode of No Compromises, Aaron and Joel share a conversation they had along these lines on a recent client project and considering the new Flux library from the creator of Livewire.(00:00) - Discussing potential Flux adoption in Bootstrap project
(01:00) - Flux explained: Livewire-based UI component library
(04:45) - Risk assessment of adding new technologies
(06:00) - Extra risk for a 1.0
(08:45) - When new tech might be worth the risk
(11:50) - Silly Bit
2024-12-0714 minNo CompromisesHow to deal with things outside your control on a dev projectHave you ever struggled working with a third party on one of your developer projects? How do you handle that, keeping it professional and also still able to meet your commitments?In today's episode of No Compromises, Aaron and Joel discuss what happened on a recent project and how they think about handling those kinds of difficulties while still having boundaries.And if you're looking for help on your Laravel project, get in touch!
2024-11-0910 minNo CompromisesShould we use a JSON field for this?JSON fields can be very useful, but when is a good time to include them in your database design? In today's episode of No Compromises, Aaron and Joel use a couple examples from recent projects to talk through reasons they would and would not use a JSON field.(00:00) - Debating JSON fields in database design
(03:06) - Configuration options: JSON vs. relational tables
(07:05) - Real-world example: label customization dilemma
(11:30) - Silly bit
Want a place to ask any question related to Laravel development? Check out the Mastering Laravel community.
2024-10-2914 minNo CompromisesHow to approach being wrongProgrammers are not shy about telling other programmers when they're wrong. But what can we learn in a situation like his? How can we be wrong with style? In this episode, Aaron and Joel talk about times they've been wrong throughout their career and what they've learned.(00:00) - Aaron admits he was wrong
(02:00) - What can I learn from this?
(05:30) - Being wrong in public with style
(07:00) - Being wrong throughout your career
(08:45) - Two people can both be right for their context
(10:10) - Silly bit
Sign up for the free Mastering Laravel newsletter and...
2024-09-0312 minNo CompromisesDon't just get mad at some tech, dig in and learn!Is there some particular tool or technology that just makes you mad? Maybe it's the way CSS behaves or how some browsers work. Don't just get mad, dig in and learn it thoroughly. We talk about how we've done that and how it helped.(00:00) - Once again, Aaron reads the docs
(02:30) - Recognizing when you don't know something
(03:30) - Approaches for learning Javascript and CSS
(04:20) - What is the manual for Javascript/CSS?
(07:13) - Joel learning CSS hands-on
(09:55) - Learning through repetition
(12:00) - Keep an eye on tech that makes you annoyed
(13:23) - Silly bit
...
2023-12-2615 minNo CompromisesDifferent approaches to upgrading to a new major Laravel versionHow do you like to upgrade your app when the next new major version of Laravel comes out? Aaron and Joel share two different approaches they've used, and what added benefits you get from doing a version upgrade.Need help getting tests on your Laravel app before upgrading?
2023-11-2816 minNo CompromisesWhen should you use final classes or private properties?The discussion of final classes was a hot topic recently. We had planned on discussing this even before it came up on Twitter, but here is our unsolicited opinion.Is there some use case we missed? Aaron wants to hear about it.Show notes(00:00) - Final classes, the hot topic on Twitter
(01:00) - Aaron's opinion has evolved over the years
(03:15) - Packages vs applications
(04:00) - What about making PHPStan happy?
(06:45) - What about reducing support burden on package maintainers?
(10:05) - What about private properties?
(11:15) - Aaron wants to be wrong
(11:45) - Silly bit
2023-06-1313 minNo CompromisesThe benefits of working with other developersMaybe you're a solo dev or working on a small team. What benefits are there in widening your circle of developers? We talk through our own personal experiences in this episode.Show notes:(00:00) - Topic intro: the benefits of working with someone else
(02:46) - Code review can actually be nice
(04:45) - The benefits of being "challenged"
(06:20) - Picking up tips just seeing how someone else works
(06:53) - Human skills are important too
2023-04-1812 minNo CompromisesChanging our mind about queues in testingWe'll admit it: sometimes we change our mind. In this episode, we discuss how we used to setup queues in Laravel tests, and why we changed it.Show Notes00:00 Sometimes we change our mind over time02:00 Changing queue from sync to null in tests03:45 Feature versus integration tests04:40 Where do you test job logic?05:30 White box versus black box testing07:15 Laravel queue drivers and how faking works08:55 Why use events at all?09:30 The new approach is faster too11:15 Silly bitWant to make us happy with a random email? Check out our free and paid...
2023-04-0413 minNo CompromisesToo many rules?Rules in programming can be extremely helpful, especially on a team. But is it possible to go too far with rules? We discuss a couple recent scenarios where we could have made a rule, but decided not to.00:00 I like rules01:20 Maybe going too far with rules - the scenario03:05 Bug explanation05:03 A tangent on test setup06:30 A possible rule to prevent this bug07:17 Why this rule went too far08:50 We still want to fix it, just not now09:45 Another example with syntax and code standards12:53 Silly bitNeed help to set up or improve your team's...
2023-03-2115 minNo CompromisesKeeping an open mind with other languages and toolsBefore you vent some frustration on another tool or programming community, take a deep breath and think about why you're irritated? We talk about our own reactions to some technologies and how it's good to keep an open mind or, at a minimum, to not be a jerk.00:00 It's easy to hate on tools you don't use01:02 Why are there different kinds of tools?03:30 Is it "bad" because we don't understand it?04:42 Learn from other communities07:10 Don't be a jerk07:55 Silly bitNeed some help with your Laravel application?
2023-03-0711 minNo CompromisesWhat we look for in a packageWe have such a rich ecosystem of packages in the Laravel and PHP community. But can there be too much of a good thing? What do we consider before adding a small package to our projects?00:00 A healthy ecosystem of packages01:02 Too much of a good thing?02:48 Risks to consider04:13 Other ways to share05:34 Think before you promote08:02 Consider the friction08:39 Silly bitWould you like help auditing the packages in your Laravel application?
2023-02-2110 minNo CompromisesBlogging versus tweetingLaravel has a vibrant community of people teaching and sharing what they've learned. What makes a good tip? Should you tweet or blog or both?00:00 Why blogging is beneficial02:43 Slowing down before you publish04:30 Tips that provide value08:11 Platforms can go away09:36 Silly bitCheck out the new articles section on masteringlaravel.io
2023-02-0711 minNo CompromisesKnowing when to use new language or framework featuresNew PHP version! New Laravel version! So exciting! But when does it make sense to upgrade, and when does it make sense to start using new language or framework features?PHP marches forward (00:00)Upgrade strategy depends on team size (01:20)Considerations for new language features (02:33)Performance gains (03:27)Readability (04:56)How to adopt new features (06:16)Depends on the project's maturity (08:14)Upgrading for security (09:30)Silly bit (11:17)If you enjoy this podcast, we'd really appreciate help spreading the word. Share it with your fellow PHP and Laravel developers.
2023-01-2414 minNo CompromisesGoing on a bug huntHow can a bug be fun, and not frustrating? When you treat it like a puzzle. Let's walk through a recent bug with CSV mime type validation and go deep down the rabbit hole.Think of a bug like a fun code puzzle (00:00)Don't get stuck for too long (01:22)The confusing CSV bug (02:35)Diffing the files (06:05)Digging deeper into Symfony and PHP (08:07)Getting stubborn about fixing this (11:29)Silly bit (12:26)Why would you validate your MIME types? Learn that and a whole lot more with our validation book: Mastering Laravel Validation Rules
2023-01-1013 minNo CompromisesThinking about the user, even in the detailsUser experience is a term we hear a lot as developers, but it can mean different things depending on the context. We discuss a recent project where decisions around which HTTP status code to return was focused on improving the user's experience and trust in the application.00:16 Why do we write code?01:39 The importance of user experience02:54 A specific example of user-focused thinking04:34 Choosing the most helpful HTTP status code05:44 What if it’s an API response?07:17 How much detail in an error is useful to a user?08:35 Silly bitMove from competent to confident - become a...
2022-12-2712 minNo CompromisesWhy do you write your tests like that?We discuss two "interesting" patterns we've observed in a number of Laravel projects. Let's take a step back and think about why we write tests the way we do.1:06 - One weird pattern we’ve seen in Laravel project tests2:23 - Can you explain why you’re doing this?3:50 - “It’s more readable”5:55 - Principle: learn a thing, do a thing, dissect a thing6:30 - Is it okay to have code duplication in tests?8:20 - How tests are different from application code11:16 - Don’t add application code just for your tests13:06 - Silly bitNeed help buildin...
2022-12-1314 minNo CompromisesAvoid painting yourself into a cornerWe've all been there: a thorny piece of code works, but it seems like there must be a better way to simplify it or make it more readable. We share one example when this happened to us, and how code review led to a better solution. Want another set of eyes on your code? We can help! Visit our site and schedule a free call with us today.00:16 The problem: this code works, but I don't like it01:17 What we mean by "I don't like this code"02:22 A specific example of code I didn't like03:52 Code...
2022-11-2910 minNo CompromisesLook before you leapHear about some cool new tool or coding technique on Twitter? Great, jump right in and use it on your biggest production app! Or . . . maybe don't. We share some thoughts on how to evaluate things critically for your particular circumstances.Do you want to blindly take our advice? Great idea! Check out our book on Laravel validation rules.
2022-11-1510 minNo CompromisesDon't plan to do too muchDo you always finish everything you plan on doing? Probably not, very few developers do. The problem isn't always how you work. Some of it is how you plan. We discuss several tips on how to plan for a more successful week.Want to get notified when we release new tools, books, and articles? Sign up for our newsletter!
2022-11-0115 minNo CompromisesIsolate the problemWhat do you do when you're stuck? Aaron shares a tip on how he breaks down a problem when he's feeling stuck.Are you stuck with your Laravel/PHP project? We can help! Book a free call.
2022-10-1810 minNo CompromisesWhat should I test?We all know we should write tests, but what should we test? Is there anything it doesn't make sense to test? We talk through a high-level approach to how we do feature testing in Laravel.Need some help or advice on your Laravel project? We can help!
2022-10-0415 minNo CompromisesPicking a strategy for translation in LaravelThere are different ways to structure your translation assets in Laravel. We discuss how we approached this on a recent project, and why we chose the method we did.Check out the validation worksheet we built. It may help jump start your Laravel validation rules.
2022-09-2014 minNo CompromisesShould a factory follow all business rules?Factories are really useful in tests, but could they give you a false sense of security if they don't generate models exactly like a user of your application would? We talk through some benefits and cautions to think about as you're designing your factories and factory states.Share the love! Tell people on Twitter about the podcast.
2022-09-0613 minNo CompromisesUnderstanding different learning stylesWhat a surprise, Joel and Aaron have a different learning style. We talk through our different approaches to learning, and what we've found useful.Did you like this? We'd appreciate a review or share of the podcast
2022-08-2315 minNo CompromisesSometimes it's good to be boringDo you like to fiddle with settings? Joel doesn't. Find out why, and hear about one example where we like deviating from the defaults.Learn more about Laravel at masteringlaravel.io
2022-08-0913 minNo CompromisesWhat was this developer thinking??Maybe you've inherited a project and just looking at how the code is organized makes your head hurt. Before you go ripping it apart and "making it better", it can be useful to take a step back and use a more measured approach.Want us to work with your team? Book a free call to see if we can help.
2022-07-2616 minNo CompromisesShould you fix all bugs in a legacy project?You've inherited a legacy app. It's "running fine" in production, but when you add an error reporting tool, you see hundreds of errors, warnings, and notices logged each day. What do you do?Check out our books and courses at masteringlaravel.io
2022-07-1213 minNo CompromisesLearning from other communitiesCan a Laravel developer learn something from the Rails or Erlang communities? We share some perspective on how to broaden your horizons, and when might be a good time in your career to do that.Download our free ebook 7 Steps to Securing Your Laravel App.
2022-06-2812 minNo CompromisesUh-oh, that proof of concept is going into production. Now what?Many of us have built something we thought was "throw-away" code, only to have someone decide it's good enough to ship to production. How can you prepare for this, and avoid problems when it happens?Check out Aaron's blog and Joel's blog for even more amazing wisdom.
2022-06-1417 minNo CompromisesThe benefits of sharing what you learnIf you are listening to this, you probably enjoy hearing other people share what they've learned. In this episode, we turn the tables and explain why you should consider sharing what you've learned as well.Listening to us is just part of the fun. You can read what we've written too at masteringlaravel.io
2022-05-3110 minNo CompromisesHow to deal with interruptionsHow can you handle an interruption to your work, especially if it is an urgent request for help? We discuss how to do this without derailing your planned work for the day.Let us know if you have a question or topic you'd like to discuss on the show. Contact us with your suggestions, or just to tell us how great we're doing.
2022-05-1709 minNo CompromisesShould I write this weird code or is there a Laravel feature I can use instead?We walk through a recent experience where Joel was about to "burn down the world," as Aaron calls it. Instead, after doing a little exploration of the Laravel framework code, we landed on a much cleaner solution.Want some help to make your Laravel SaaS better? Book a free 30 minute call.
2022-05-0316 minNo CompromisesTake time to look back and reviewIt feels good to finish a project, but before you move on, there are benefits to pausing and reflecting on what went well and what could have been better.If you're enjoying the podcast, we'd really appreciate it if you shared it with a fellow developer.
2022-04-1911 minNo CompromisesThe benefits of testing, even under a deadlineWe have to ship this feature in 2 weeks! Do we have time to test? In this episode we talk through this scenario and share some benefits of testing even under the pressure of a looming deadline.Free, practical advice on how to improve your Laravel app at masteringlaravel.io
2022-04-0512 minNo CompromisesWhen to calculate a value versus when to store it in the databaseFor some values, it can be tricky to know whether it's better to calculate it on the fly or when to calculate it once and store in the database. We talk through a recent scenario we bumped into, and what factors to weigh when making this decisionDownload our free Laravel tips ebook.
2022-03-2212 minNo CompromisesShould I use an event/listener or a model observer?We share a few rules that help guide us to determine when to manually fire an event versus when to wire up a model observer.Make my phone buzz and download a book to make you a better Laravel developer.
2022-03-0813 minNo CompromisesHow we wrap up a projectWrapping up our series on how we work, we talk through the end of a project and how to make sure there are no surprises.Download the free security tips ebook from masteringlaravel.io.It's not easy being green
2022-02-2212 minNo CompromisesDon't be afraid to change your mindYou learned a best practice, and it served you well. Is it set in stone? Or should you be open to re-evaluate later?Get those free e-books at masteringlaravel.io
2022-02-0812 minNo CompromisesThe proper way to argueWe've all had disagreements about how to write or organize code, or how a feature should work. We share some tips on how to discuss it productively.Be a Joel, not a Cole: masteringlaravel.io
2022-01-2515 minNo CompromisesWhat makes a good staging environment?Setting up a useful staging environment involves a number of choices. We discuss our preferred strategies and talk about why having a staging environment is a good thing.
2022-01-1117 minNo CompromisesYour project is not specialThis isn't meant to be an insult. It's actually a good thing that your project isn't completely unique, and you can benefit from what other people have already learned.
2021-12-2809 minNo CompromisesPlanning out a week of workContinuing our series on "how we work", today we finally get to the dev work. How we organize it, plan it, and communicate with the project stakeholders.I heard this site is cool: masteringlaravel.io
2021-12-1415 minNo CompromisesA few things to watch for with Laravel policiesAaron shares a few things that he's bumped into with policies in his apps, and we talk through some possible solutions or processes to help avoid them.Tweet @jclermont if there's something you'd like us to discuss.
2021-11-3012 minNo CompromisesOnboarding a new projectWhen you inherit a project, how do you draw a balance before making everything nice to work with and delivering value to the stakeholders?Check out masteringlaravel.io
2021-11-1615 minNo CompromisesPaying down technical debtHave a question? Want us to discuss a topic? Do you like sending email to random people on the Internet?Contact us at podcast@nocompromises.io for all of the above.
2021-11-0216 minNo CompromisesKnowing when and how to try something newYou just attended a conference or finished a book/course and you're all excited to try out some new "best practice". We discuss how to balance this enthusiasm with the needs of your team and project.* Check out masteringlaravel.io* Download our free Laravel Tips ebook
2021-10-1913 minNo CompromisesWireframe before codingAs developers, coding is the fun part, but we share why we like to slow down and take some time to wireframe before diving into the editor* Download our free Laravel Tips ebook
2021-10-0514 minNo CompromisesContinuous integration doesn't have to be hard* Github Actions by Michael Heap (50% discount for podcast listeners)* masteringlaravel.io - get a jump start on validation with our free worksheet
2021-09-2117 min2021-09-0718 minNo CompromisesAre your logs too noisy?The broken window theory of programmingNew site launch! MasteringLaravel.io
2021-08-2411 minNo CompromisesHow we decide whether or not to take on something newThis episode is a little different. We take a peek behind the scenes as to how we qualify projects, and the sorts of things you might think about before deciding whether or not to take on something new.Find out more about Mastering Laravel Validation Rules.
2021-08-1021 minNo CompromisesAre you allowed to do that?Roles and permissions are a core part of most applications. Laravel provides some tools for managing and enforcing this, and third party packages provide even more features. Aaron and Joel share their techniques for enforcing roles and permissions, in a way that won't get harder to manage over time.Download our free eBook of Laravel tips: A Little Bit of LaravelOur favorite permissions package: laravel-permission
2021-07-2717 minNo CompromisesAre you a Laravel developer or a PHP developer?When you're building a Laravel app, you're writing PHP code, but you're dealing with many patterns and conveniences provided by Laravel. So where do you draw the line between the two? Is it important? We discuss this topic and how you can get the most out of what both PHP and Laravel have to offer.Download our free eBook of Laravel tips: A Little Bit of LaravelFun game to learn/practice regular expression syntax: Regex Crossword
2021-07-1317 minNo CompromisesShould developers have access to production?> Developer: "I just need to SSH in real quick"> Server admin: "No"Have you had this discussion? Listen in as Joel and Aaron talk about their experience on teams of different sizes, and how to handle this potential conflict, while still getting your work done.Download our free eBook of Laravel tips: A Little Bit of Laravel
2021-06-2912 minNo CompromisesPick a coding standard, any one will doWhere should I place this curly brace? Trailing commas or not? Have you encountered disagreements about coding standards on your team. In this episode we explain the benefits of coding standards, how to adopt them on your project, and discuss the two most popular tools in the PHP community for enforcing them.Download our free eBook of Laravel tips: A Little Bit of Laravel
2021-06-1519 minNo CompromisesThe art of asking and answering questionsWe've all been stuck with something we didn't know. Should you ask for help? And how? Or if someone on your team asks you a question, how can you handle it best? We discuss it all.Download our free eBook of Laravel tips: A Little Bit of Laravel
2021-06-0115 minNo CompromisesTesting 1 ... 2 ... 3, let's talk testingWhat are the big 3 types of tests we use on our projects? How do we decide which to use? Listen in as we discuss this and more.Need help improving your testing strategy, or just need help to get your team started with testing? Setup a free consultation call.
2021-05-1814 minNo CompromisesGuarded vs fillable, fight!It's no tabs versus spaces, but it's close. Do you use guarded or fillable in your Laravel models? Aaron and Joel share their default approach, as well as several reasons for that choice.Sign up for our Laravel tips newsletter!Find out more about Mastering Laravel Validation Rules.
2021-05-0417 minNo CompromisesDon't ignore that pain!It's easy to get used to things that cause us friction or pain in our development process. In this episode, we discuss how to avoid that trap and how to evaluate when to invest time in fixing that pain.Sign up for our Laravel tips newsletter!Find out more about Mastering Laravel Validation Rules.
2021-04-2014 minNo CompromisesValidation is your friendValidation may seem boring, but it's a vital part of any Laravel application. Joel and Aaron share some tips on validation along with exciting news about a new resource to master Laravel validation rules.Sign up for our Laravel tips newsletter!Find out more about Mastering Laravel Validation Rules.
2021-04-0614 minNo CompromisesAlways be ready to hand off the projectWhy is it important to think about a future project hand-off at the beginning of a client relationship? Aaron and Joel share their approach.Sign up for our Laravel tips newsletter!
2021-03-2315 minNo CompromisesFinding and fixing a performance issueLast episode we discussed how to deal with a "slow app" complaint. This episode we discuss some technical approaches to find and fix the issue.Sign up for our Laravel tips newsletter!
2021-03-0915 minNo CompromisesSomeone said my app is slow. Now what?The dreaded support ticket gets filed: App is slow! Before you get defensive or close as "Won't fix", consider a few tips on how to successfully approach this situation.Sign up for our Laravel tips newsletter!Ed Balls Day wikipedia article
2021-02-2314 minNo CompromisesHow long does it take to get your project running?Aaron and Joel have joined a fair number of projects over the years. Listen as they share some tips on how to make process less painful for your team.Sign up for our Laravel tips newsletter!
2021-02-0916 minNo CompromisesIs it a good idea to install that package?Laravel and PHP have a rich ecosystem, but it's good to weigh the pros and cons before reaching for a new package. We share some things to consider.Sign up for our Laravel tips newsletter!
2021-01-2615 minNo CompromisesWhere do I start making things better?Where are some good starting points for modernizing and improving a legacy codebase? Joel and Aaron discuss a few ideas where you could start.Sign up for our Laravel tips newsletter!Does anyone read these? Tweet @jclermont if you see this.
2021-01-1215 minNo CompromisesHow long is that going to take?The eternal question that every developer hears: How long is that going to take? Aaron and Joel discuss some ways to frame that question, and how to provide an estimate that will avoid unnecessary disappointment.00:00 Accurate estimates can be difficult02:00 Disconnect between a developer and a stakeholder03:00 How Aaron approaches an estimate06:05 Pad the estimate? Ranges?07:38 The importance of open communication08:12 Translating "hours" into real world time09:50 Planning not pricing11:56 Silly bitSign up for our weekly newsletter of Laravel tips.
2020-12-2914 minNo CompromisesGetting started with a legacy codebaseStepping into an unfamiliar codebase with a long history can be a challenge. Aaron and Joel share some tips on how to get started and build confidence that you're making things better.00:00 What is a "legacy" code base?01:00 Getting those first tests in a legacy code base03:05 Starting with unit tests can be hard04:20 Be extra careful with external APIs07:15 Onboarding a new project08:35 Getting more specific on the first few tests10:38 Silly bitSign up for our newsletter of Laravel tips.
2020-12-1514 minNo CompromisesWhy even review when my code is perfect?Some shy away from code review, not wanting to be critiqued. Aaron and Joel share some tips on how to get the most out of code reviews, and things to look for as a code reviewer.00:00 The value of a code review process02:53 Look at it as a learning opportunity04:06 Approaching a pull request to review it06:05 Should we make this better?07:00 Did the programmer have a reason for what they did?09:05 Everyone on the team should get their code reviewed10:25 Silly bit
2020-12-0114 minNo CompromisesAre you testing me?Aaron and Joel talk about why they write tests and what sorts of tests they find valuable.00:00 Why do we write tests?03:05 Implied trust in packages04:15 What do you test? How do you write them?06:30 Testing the happy path07:05 Testing the "unhappy" paths08:12 It's less work than you think11:30 Testing a dumb mistake with range validators14:40 Silly bit
2020-11-1718 minNo CompromisesWhat is the one true way to do this?We discuss a couple scenarios where there's more than one way to do something, and how we think through our decision.00:00 How to pick what file to put this code in?01:51 An example of a single-action controller03:15 Should everything be single-action?04:58 How many methods on a controller is too many?06:10 Where do you put authorization logic?08:00 Consistency is important08:45 Silly bit
2020-10-2712 minNo CompromisesDid you just tell me to read the manual?How do you learn a new technology? Or how do you find out what's changed in the latest version of something you already use? Aaron and Joel share some tips on what they do.00:00 So many new things to learn00:56 Importance of reading docs02:00 Reading versus doing03:45 Be curious when reading05:20 How to get hands-on practice07:30 Learning a new release of an existing tool10:15 Improve the docs!12:15 Silly bitExercises for Programmers from Pragmatic Press
2020-10-1316 minNo CompromisesDo you have a clear mental model?The technologies we work with are extremely detailed. Without a clear mental model of how things work together, it's easy to get lost or confused.00:00 A common pattern when a dev is stuck01:12 What is a "mental model"?02:15 A concrete example of a mental model04:30 Discussing rebase versus merge06:30 A PHP specific example for rebase07:40 Mental models for queue workers10:10 Open source helps us understand11:30 Silly bit
2020-09-2916 minNo CompromisesThe best argument is no argumentDisagreements and debate can sap your team's energy. We'll talk about some ways to avoid unnecessary conflicts, and how to successfully handle a difference of opinion on your team.00:00 Developers want the "one true way" to do something01:45 Handling a difference of opinion02:33 Staying consistent within a project03:44 Using tools to help consistency06:00 Document your project standards07:37 Keep an open mind11:01 Choose your battles wisely12:25 Involve the whole team in the discussion13:05 Silly bit
2020-09-1516 minNo CompromisesWhat's with these flaky tests?Croissants are great because they're flaky, but no one likes a flaky test. We share some strategies on how to make your tests more reliable.00:00 Flaky tests are the worst02:12 Why randomization can lead to flaky tests03:10 A guideline on when to avoid randomization05:10 Trying to predict the future?06:15 Naming can be a guide07:15 Use factory states08:00 Another type of flaky test11:15 Silly bit
2020-09-0115 minNo CompromisesWhen should I upgrade my Laravel project?00:00 The desire to upgrade to a shiny new Laravel version02:20 I actually enjoy maintenance03:48 An analogy with cars04:30 The importance of communication05:30 Making it easier to upgrade06:30 Do you want to be on the bleeding edge?07:52 Silly bit
2020-08-1411 minNo CompromisesHow do you figure out why your code isn't working?00:00 The thought process when you get stuck01:40 An example with CSS03:40 Tools that can help locally06:15 Using a debugger to learn about Laravel06:30 Tools that can help in a remote environment08:22 Real talk about debugging in production09:57 Troubleshooting database performance11:16 Searching the internet for an answer13:02 Silly bit
2020-08-1415 minNo CompromisesWhen is the right time to automate a dev task?00:00 The urge to automate everything01:49 Document before you automate02:45 Weighing time spent versus time saved03:30 Automation isn't maintenance-free04:08 Types of automation05:18 The exception to the rule07:05 An example of using a command to update data08:00 Silly bit
2020-08-1410 min