No Compromises

Do you actually own the code you ship?

Joel Clermont and Aaron Saray — Sat, 09 May 2026 00:00:00 -0500

When a tool hands you a working solution, how much do you really need to understand about why it works?

In the latest episode of the No Compromises podcast, we discuss whether developers still care about understanding the code they ship, or whether that expectation is becoming a relic of the past.

We explore why knowing the "why" behind a solution isn't just about curiosity. It's about having enough domain knowledge to ask better questions, push back on bad answers, and ultimately produce better work.

We also walk through a real code review example involving a tricky Eloquent query, talk through the pressures that pull developers away from digging deeper, and consider what separates a line cook from a chef in how we approach our craft.

(00:16) - Are developers losing the habit of asking why
(02:16) - How AI changes the copy-paste-and-move-on cycle
(05:25) - Learning by accident while reading the manual
(06:24) - The Eloquent query neither of us could explain
(12:16) - Silly bit

Join a community of developers who still care about understanding the code they ship.

Do you actually need a multi-tenancy package?

Joel Clermont and Aaron Saray — Sat, 25 Apr 2026 00:00:00 -0500

Ever feel like a project requirement says "we need multi-tenancy," and you're not even sure what that means in your specific context?

In the latest episode of the No Compromises podcast, we discuss how to evaluate multi-tenancy needs before committing to an architectural approach.

We break down what multi-tenancy actually means, from separate databases to custom domains and per-tenant configuration, and why the real question isn't which package to use, but whether you need one at all.

We also explore when hand-rolling a simple solution beats adopting a full package, what legal and compliance requirements can force your hand, and why this is one of those decisions that's genuinely hard to undo later.

00:00 Defining what multi-tenancy actually means
02:11 Different ways to structure multi-tenant systems
03:44 When separate databases are truly necessary
04:57 Questions to ask before choosing an approach
08:25 Package vs. rolling your own trade-offs
11:30 Silly bit

If you want guidance on decisions like these, check out our code review service to get expert eyes on your architecture.

Local and production should match even for Laravel tools

Joel Clermont and Aaron Saray — Sat, 11 Apr 2026 00:00:00 -0500

Ever installed a Laravel package locally and immediately accessed it, only to wonder later whether your access controls are actually working in production?

In the latest episode of the No Compromises podcast, we discuss why tools like Telescope and Horizon behave differently in local environments versus production, and why that inconsistency is a problem worth solving.

We make the case that developer convenience should never come at the cost of security confidence. If your gate logic cannot be exercised locally, you cannot truly trust it is protecting your production environment.

We also dig into how Aaron worked around the issue by overriding the package's service provider logic, and why Laravel has since made this easier to handle cleanly.

(00:00) - Why local and production environments should match
(01:42) - How Telescope's gate logic behaves differently locally
(03:01) - The risk of untestable access control logic
(07:53) - How Aaron overrode the service provider to fix it
(10:23) - Silly bit

(00:00) Why local and production environments should match
(01:42) How Telescope's gate logic behaves differently locally
(03:01) The risk of untestable access control logic
(07:53) How Aaron overrode the service provider to fix it
(10:23) Silly bit

Our courses took the production hits so your app doesn't have to.

When weird code needs to explain itself

Joel Clermont and Aaron Saray — Sat, 28 Mar 2026 00:00:00 -0500

Have you ever looked at a colleague's code and thought, "This is clearly wrong," only to find out it was actually a well-reasoned workaround for a tricky bug?

In the latest episode of the No Compromises podcast, we discuss what happened when Aaron reviewed Joel's code and couldn't make sense of a pattern spread across multiple Livewire components.

The code wasn't bad, it was solving a real UX flicker bug in an older version of Mary UI. But without context, it looked like a mistake and nearly got rejected. The fix wasn't just refactoring; it was giving the workaround a proper home: a trait with a descriptive name, clear method names, and thorough documentation explaining the bug, the reason for the pattern, and when it can eventually be removed.

We also talk about why "the explanation is in the PR note" isn't good enough, how AI coding agents can unknowingly propagate patterns they don't understand, and why strange code deserves to look strange, on purpose.

Explore Mastering Laravel resources to deepen your understanding of patterns like these.

00:00 The confusing code review that started this
01:15 Flagging the unclear pattern across components
03:54 The Mary UI toast flicker bug explained
05:45 Naming, documentation, and protecting the whole team
09:30 Silly bit

Are you testing your app or just the framework?

Joel Clermont and Aaron Saray — Sat, 14 Mar 2026 00:00:00 -0500

Do you ever finish writing a test and wonder if it is actually proving anything about your code or just confirming that Laravel works?

In the latest episode of the No Compromises podcast, we discuss how to tell the difference between tests that validate your logic and tests that merely exercise the framework.

We share a practical gut check: if you cannot make a test fail by changing something in your own application code, it probably should not be in your test suite. We also look at this idea from the other direction, asking whether the code being tested is something we actually wrote.

We also dig into why testing validation rules is worth the effort even when they feel boilerplate, how feature versus unit test style shapes these decisions, and why the real goal is simply getting to a place where your tests help you ask the right questions.

Join the Mastering Laravel community at https://masteringlaravel.io/community

00:00 Are we testing code or framework
02:00 Joel metric for framework-only tests
05:15 Bottom-up testing perspective by test type
07:36 Why validation rules still deserve tests
10:40 Silly bit

Being anti-hype does not mean being anti-AI

Joel Clermont and Aaron Saray — Sat, 28 Feb 2026 00:00:00 -0600

Does everyone need to have an AI hot take right now, or is there value in waiting until you actually know what you're talking about?

In the latest episode of the No Compromises podcast, we discuss why it took us 147 episodes to finally tackle the topic of AI.

We dig into the tension between wanting to speak with authority and feeling pressure to share before you're ready. Aaron makes the case for building deep knowledge first, while acknowledging that people at every stage of the learning curve play an important role in moving the community forward.

We also talk about how fast the AI landscape is shifting, why zooming out matters more than memorizing details, and why being a slower mover isn't something to apologize for.

(00:00) - Why we haven't talked about AI yet
(01:00) - Building deep knowledge before sharing opinions
(02:30) - AI moves faster than JavaScript frameworks
(04:30) - Zoom out before sweating the details
(06:15) - Every stage of the learning cycle matters
(07:45) - Silly bit

Want to get that new AI tip we mentioned? Sign up for the Mastering Laravel newsletter.

Three ways to plan an upgrade when your codebase is a patchwork

Joel Clermont and Aaron Saray — Sat, 14 Feb 2026 00:00:00 -0600

When your project has the same thing done three different ways, how do you bring everything up to date with a consistent approach?

In the latest episode of the No Compromises podcast, we discuss different strategies for tackling upgrades when parts of your codebase are multiple versions behind.

We walk through two main approaches and weigh the tradeoffs for both the developer doing the work and the person reviewing it.

(00:00) - Setting up the upgrade scenario
(02:15) - Approach one: upgrade each area to current
(04:00) - Why the reviewer's experience matters too
(07:30) - A third approach neither one expected
(09:00) - Silly bit

Want help upgrading your Laravel project?

Stop doing math in your config files

Joel Clermont and Aaron Saray — Sat, 31 Jan 2026 00:00:00 -0600

Ever feel the urge to write out calculations in your code to make them "self-documenting"?

In the latest episode of the No Compromises podcast, we discuss why inline math in configuration values is a habit worth breaking.

Aaron argues that if a value never changes, there's no reason to calculate it every time. A well-placed comment can explain how you got the number without the unnecessary overhead.

We also cover how comments can clarify units like seconds versus milliseconds, why this thinking applies beyond config files, and how questioning small habits can improve your code overall.

(00:00) - How many seconds is five minutes?
(01:45) - The problem with inline config math
(03:45) - Using comments instead of runtime calculations
(05:30) - Why questioning habits improves code
(07:00) - Silly bit

Want a second set of eyes on your Laravel project?

What could be worse than having no tests?

Joel Clermont and Aaron Saray — Sat, 17 Jan 2026 00:00:00 -0600

Found a cool package on Laravel News? But how do you know if it's actually worth installing?

In the latest episode of the No Compromises podcast, we discuss what we look for when evaluating third-party packages before bringing them into a project.

Aaron makes the case that what he finds in the tests folder is essentially a deal-breaker: no tests means no trust, but leaving default example tests behind is somehow even worse. Tests reveal whether the maintainer thought through edge cases and serve as living documentation when the README falls short.

We also cover the other signals we weigh: GitHub stars, download counts, issue responsiveness, and how quickly maintainers keep up with new Laravel versions.

(00:00) - Evaluating packages you stumble across
(01:30) - Why leftover example tests frustrate Aaron
(03:45) - Tests as documentation and edge case proof
(05:00) - Checking issues and Laravel version history
(08:00) - Silly bit

Want to work with us on your project?

Why I changed my mind about down migrations

Joel Clermont and Aaron Saray — Sat, 03 Jan 2026 19:20:55 -0600

Have you ever built a strong case for something, only to realize later you were solving the wrong problem?

In the latest episode of the No Compromises podcast, we discuss Aaron's surprising reversal on down migrations, a topic we've publicly discussed on this podcast.

We walk through the original arguments for writing down migrations and deconstruct each one.

(00:00) - The original case for down migrations
(03:45) - Aaron changes his stance
(05:15) - Why seeders beat rollbacks for local dev
(10:30) - Rethinking the production rollback scenario
(14:45) - Silly bit

Keep your knowledge fresh, check out Mastering Laravel.

Why senior developers feel wrong more often

Joel Clermont and Aaron Saray — Sat, 20 Dec 2025 00:00:00 -0600

Ever 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, and how to reframe architectural decisions as a spectrum rather than binary choices.

(00:00) - Feeling wrong more often as a senior dev
(01:45) - Knowledge plateaus and how growth resets them
(04:45) - How feedback sources change with experience
(07:00) - Binary thinking versus nuanced decision-making
(09:15) - Silly bit

Want two Laravel experts to review your code?

Should you ever hand-format code?

Joel Clermont and Aaron Saray — Sat, 06 Dec 2025 00:00:00 -0600

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) - Auto-formatters vs subjective style choices
(01:15) - Edge cases tools miss and human tweaks
(03:15) - Using light formatting to unlock hard problems
(05:15) - A tiered break strategy for focus
(07:00) - Silly bit

Want two Laravel experts to review your code?

Discussing different ways to model data

Joel Clermont and Aaron Saray — Sat, 22 Nov 2025 00:00:00 -0600

It'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) - Filtering and validation considerations
(07:15) - Deciding on the best approach
(09:50) - Silly bit

Would you like us to review your code or application architecture?

Read outside tech to expand your horizons

Joel Clermont and Aaron Saray — Sat, 08 Nov 2025 00:00:00 -0600

It'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 though.

Rewriting without a map: shipping an MVP from a legacy app

Joel Clermont and Aaron Saray — Sat, 25 Oct 2025 00:00:00 -0500

Multiple times we have encountered the messy reality of rebuilding a decade-old system: stale specs, missing specs, and stakeholders who want "the same… but better."

In the latest episode of the No Compromises podcast, we share a lightweight framework for agreeing on an MVP, tagging "post-MVP" ideas, and negotiating trade-offs while still making progress.

We walk through practical tactics for parallelizing work and learning as you go.

(00:00) - Rebuilding an old system without copying its flaws
(02:00) - Two extremes: too many specs or none at all
(03:00) - MVP tension: ship value vs. future wishes
(04:45) - Define MVP, capture unknowns as post-MVP tickets
(05:30) - Build the first slice and learn
(07:00) - Code foundations while refining scope
(08:30) - Trade-offs as collaboration, not confrontation
(09:30) - Takeaway: progress, check-ins, iterate together
(10:00) - Silly bit

Want to join one of our community dev calls?

A composable, versioned toolkit for Laravel projects

Joel Clermont and Aaron Saray — Sat, 11 Oct 2025 00:00:00 -0500

We join a fair number of projects, and we often help teams bring their project up to our standard. This means bringing a lot of the same small pieces from project to project.

In the latest episode of the No Compromises podcast, we rethink our “project standard” repo. Instead of a full Laravel skeleton, we propose a composable library of tool-specific, versioned configs (PHPUnit, Docker, etc.).

We walk through the benefits for greenfield and legacy work, open questions about test organization, and how this approach scales as tools evolve.

(00:00) - Why we keep our tooling current
(00:15) - The “project standard” repo is aging
(01:30) - Reference guide vs installable skeleton
(02:30) - Supporting old and new stacks (versions, tags)
(03:30) - Pivot: organize by tool and version, not app
(04:30) - Example plan: folders for PHPUnit 11/12 (and beyond)
(05:15) - What belongs where? Tests, traits, and context
(10:00) - Docker-first thinking; where Horizon config lives
(11:15) - Open questions: PHPUnit vs Pest vs “testing” folder
(12:15) - Takeaway: evolve the repo as the tools evolve
(12:45) - Silly bit

Want help making your project as organized as one of our projects?

Should you use DTOs in Laravel?

Joel Clermont and Aaron Saray — Sat, 27 Sep 2025 00:00:00 -0500

DTOs (Data Transfer Objects) aren't mentioned anywhere in the Laravel docs, but some devs use them heavily in their applications, whereas other devs never use them at all.

In the latest episode of the No Compromises podcast, we weigh the pros and cons of DTOs in everyday Laravel apps, comparing them to form requests, PHPDoc-typed arrays, and service-layer boundaries, and share one area where DTOs truly shine.

The takeaway: keep DTOs in the toolbox, but reach for them intentionally, not by habit.

(00:00) - Framing DTOs in a stricter PHP world
(01:15) - Our current practice: hybrids, few true DTOs
(02:45) - Form requests, `safe()`, and typed inputs
(03:45) - Reuse across API and form layers rarely aligns
(04:30) - Where DTOs shine: normalizing multiple APIs
(05:45) - Service boundaries: wrapping vendor objects (e.g., Stripe)
(06:15) - PHPDoc-typed arrays vs DTO overhead
(06:45) - Conventions, Larastan levels, and avoiding ceremony
(07:45) - Treat DTOs as a tool, not a rule
(09:15) - Silly bit

Want to discuss how we can help you with an architecture review?

Sunsetting a company app without loose ends

Joel Clermont and Aaron Saray — Sat, 13 Sep 2025 00:00:00 -0500

Business change and projects end, but how do you wrap up and sunset an app, especially one you've worked on for years?

In the latest episode of the No Compromises podcast, we share a practical checklist for winding down an app when the whole company is closing. From documenting services and dependencies to deciding what data to retain, we cover backups, credentials, and why deleting local copies matters for security and sanity.

(00:00) - Sunsetting a company vs project handoff
(02:15) - First goals: stop charges, purge data
(03:45) - Document before shutting anything off
(04:15) - Use README/PRODUCTION.md and password manager
(05:45) - Decide on retaining code, DB, uploads
(07:15) - Hunt secrets in .gitignore and dotfiles
(09:15) - Delete local containers and repos by default
(11:30) - Silly bit

Want peace of mind that your project is ready for whatever happens in the future. Schedule a call with us today.

When building a UI makes more sense than bloating your seeders

Joel Clermont and Aaron Saray — Sat, 30 Aug 2025 00:00:00 -0500

What do you do when you need to create some data but you haven't built out the UI for that data yet? A seeder is a great approach, but is it always the right one?

In the latest episode of the No Compromises podcast, we dive into a real project where starting with the most complex feature made test data management painful. Instead of exploding the complexity of our seeders, we built a minimal UI to manage test data.

We also talk about some other unexpected benefits, and talk through the trade-offs and why detours like this should feel uncomfortable (and be tightly scoped).

(00:00) - Starting deep exposes messy user permutations
(02:45) - Seeder explosion vs. a minimal UI
(03:45) - Reframing the “detour” after using it
(05:30) - Why the mini-UI helped: faster iteration, fewer seed resets
(07:45) - Dogfooding + tester debugging benefits
(08:00) - Guardrails: detours should feel uneasy and stay tight
(09:00) - Silly bit

Need help on your Laravel project? Hire two experts and accelerate your progress.

Blade includes vs components: how we decide

Joel Clermont and Aaron Saray — Sat, 16 Aug 2025 00:00:00 -0500

Blade gives you two big levers for keeping views maintainable: @include and Blade components.
When should you use one versus the other?
Does it matter?

In the latest episode of the No Compromises podcast, we lay out a clear heuristic for when to extract markup for organization (includes) versus when to encapsulate and reuse with controlled scope (components).

We also touch on scope pitfalls, “passing for documentation,” and why performance worries usually lie elsewhere.

Changing your mind about when() and unless() in Eloquent

Joel Clermont and Aaron Saray — Sat, 02 Aug 2025 00:00:00 -0500

Aaron 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() for readability
(06:45) - Seeing the same helper everywhere changes minds
(08:30) - Takeaways – keep revisiting old habits as Laravel evolves
(09:30) - Silly bit

Want help learning how to more quickly refactor and standardize your app with Rector?

Finding a code-review style that fits your brain

Joel Clermont and Aaron Saray — Sat, 19 Jul 2025 00:00:00 -0500

Joel 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-notes)
(07:45) - When atomic commits backfire and trust becomes a factor
(08:45) - Silly bit

Never take hostages: give clients control from day one

Joel Clermont and Aaron Saray — Sat, 05 Jul 2025 00:00:00 -0500

Joel 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

Want to level up your skills as a Laravel developer?

Balancing test coverage without chasing 100 percent

Joel Clermont and Aaron Saray — Sat, 21 Jun 2025 00:00:00 -0500

Joel 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 coverage? Going from 0% to 1% is the hardest step. We can help!

Exploratory coding when requirements are fuzzy

Joel Clermont and Aaron Saray — Sat, 07 Jun 2025 00:00:00 -0500

Joel 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

Understanding how Stringable works inside Blade views

Joel Clermont and Aaron Saray — Sat, 24 May 2025 00:00:00 -0500

Joel 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

Finishing up our discussion on not having time

Joel Clermont and Aaron Saray — Sat, 10 May 2025 00:00:00 -0500

Picking 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 gains
(08:30) - Reframe tasks with a priority‑shift exercise
(10:30) - Silly bit

Reading one of our awesome books "takes time" but will make you a better developer.

Why “no time” really means “no priority”

Joel Clermont and Aaron Saray — Sat, 26 Apr 2025 00:00:00 -0500

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 https://masteringlaravel.io

When validation can protect your app's performance

Joel Clermont and Aaron Saray — Sat, 12 Apr 2025 00:00:00 -0500

Joel 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

Stick with conventions and avoid overengineering your Laravel app

Joel Clermont and Aaron Saray — Sat, 29 Mar 2025 00:00:00 -0500

Joel 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!

When to bring in outside help

Joel Clermont and Aaron Saray — Sat, 15 Mar 2025 00:00:00 -0500

Joel 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

Why two databases are better than one

Joel Clermont and Aaron Saray — Sat, 01 Mar 2025 00:00:00 -0600

Joel 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

Dealing with being a beginner again

Joel Clermont and Aaron Saray — Sat, 15 Feb 2025 00:00:00 -0600

In 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.

Making short demo videos count

Joel Clermont and Aaron Saray — Sat, 01 Feb 2025 00:00:00 -0600

Joel 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

Examining test layering in multi-tenant requests

Joel Clermont and Aaron Saray — Sat, 18 Jan 2025 00:00:00 -0600

Joel 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.

When to step outside of Eloquent's comfort zone

Joel Clermont and Aaron Saray — Sat, 04 Jan 2025 08:16:06 -0600

Joel 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.

Feature flags: Temporary tool or permanent solution?

Joel Clermont and Aaron Saray — Sat, 21 Dec 2024 00:00:00 -0600

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

Deciding when to use a new piece of technology

Joel Clermont and Aaron Saray — Sat, 07 Dec 2024 00:00:00 -0600

Ooh, 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

Want calm, reasonable developers like us to help with your project?

Taking liberties with value objects

Joel Clermont and Aaron Saray — Sat, 23 Nov 2024 00:00:00 -0600

Programmers love geeking out and creating specialized terms and vocabulary. Well I can do that too. In today's episode, we talk about "value objects", put our own special definition on it, and discuss when we might use these in a Laravel project.

(00:00) - What I mean by "value object"
(03:00) - Nicer to do in newer PHP versions
(04:00) - Main use case for value objects
(05:30) - Use them for everything then?
(09:00) - A second reason to use a value object
(10:45) - Silly bit

How to deal with things outside your control on a dev project

Joel Clermont and Aaron Saray — Sat, 09 Nov 2024 00:00:00 -0600

Have 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!

Should we use a JSON field for this?

Joel Clermont and Aaron Saray — Tue, 29 Oct 2024 00:00:00 -0500

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.

A balanced approach to static analysis in Laravel apps

Joel Clermont and Aaron Saray — Tue, 15 Oct 2024 00:00:00 -0500

Static types and tooling have increased the quality of our apps, but sometimes certain features in your Laravel app don't play nicely with static analysis.

In today's episode, we talk about how we approach the tradeoffs around making a tool happy without changing how you write code.

(00:00) - Our approach to static analysis in a Laravel app
(01:30) - Using PHPDoc inline
(03:00) - When Laravel doesn't quite give you the type you want
(05:00) - A different approach than inline types
(06:30) - Are you just making the tool happy?
(07:45) - An example of going too far
(10:10) - Silly bit

Check out the newly published volumes of Laravel tips. Collect them all!

Why do we like testing so much?

Joel Clermont and Aaron Saray — Tue, 01 Oct 2024 00:00:00 -0500

I write a lot about testing in the Mastering Laravel newsletter. Ever wonder why it's a topic I care so much about?

In today's episode, we discuss that question and come up with a few different reasons.

(00:00) - Why do we like testing so much?
(01:20) - Looking back at how we learned
(02:30) - Making it easier to join a project
(05:45) - Tests make you more productive
(07:45) - Shifting your thinking
(10:10) - Silly bit

Let us help you add tests to your project.

What does it mean to "know" something?

Joel Clermont and Aaron Saray — Tue, 17 Sep 2024 00:00:00 -0500

What does it really mean when you say you know a particular technology? On today's episode, we discuss this using TypeScript as a specific example.

(00:00) - What does it mean to "know" something?
(03:15) - Thinking about TypeScript vs strict types in PHP
(05:30) - Are you fluent?
(06:50) - Silly bit

Want help with your Laravel or PHP project? We really know that!

How to approach being wrong

Joel Clermont and Aaron Saray — Tue, 03 Sep 2024 00:00:00 -0500

Programmers 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

Where do you go when you need help?

Joel Clermont and Aaron Saray — Tue, 20 Aug 2024 00:00:00 -0500

We can't know everything, so throughout each day we inevitably have questions. On today's episode, we discuss different approaches we have used when we need a little help.

(00:00) - Where do you go when you need help?
(01:30) - Option 1 - search engines
(03:30) - Getting the most out of search results
(05:00) - Option 2 - talk to AI
(07:00) - Using AI in the right context
(09:10) - Option 3 - talk to a person
(11:30) - What if you work alone?
(12:55) - Silly bit

Looking for a community of smart Laravel developers that you can ask for help?

What does it mean if someone says your app is slow?

Joel Clermont and Aaron Saray — Tue, 06 Aug 2024 00:00:00 -0500

The dreaded bug report: this app is slow. Ok, but what is slow? I have so many questions!

In today's episode, we discuss our approach to getting more information out of that initial bug report, and a methodical approach to locate and quantify the slowness.

If you'd like help setting up tools like Xdebug profiling, send us a message.

Why we have a separate test suite for external services

Joel Clermont and Aaron Saray — Tue, 23 Jul 2024 00:00:00 -0500

Writing tests that communicate with a third party can be a little tricky, but we've found an approach that balances speed and confidence.

In today's episode, we share that approach and talk through a strategy of how frequently to run tests that talk to the outside world.

(00:00) - Why would your tests ever talk to an external service?
(02:30) - What does it mean to have a separate test suite?
(06:00) - Keeping them separate allows different triggers for running
(07:00) - When should you run external tests?
(08:30) - You can't always know when you'll break an external integration
(11:00) - Check on a schedule?
(13:00) - Silly bit

Would you like to take 2 - 3 minutes each day to learn a little bit about Laravel? Join for free, unsubscribe any time.

API specs aren't just for giant teams

Joel Clermont and Aaron Saray — Tue, 09 Jul 2024 00:00:00 -0500

I don't have time to write an API spec. We're not a giant team. We don't have external users of our API.

I've said all these things in the past, but in today's episode, we discuss why you should still consider writing a specification for your Laravel API.

(00:00) - Should you write a spec for your API?
(01:37) - Thinking through the requirements
(04:07) - What's in a spec?
(06:20) - Balancing detail with moving forward
(08:15) - Who is consuming the spec?
(09:30) - The spec keeps you honest

Would you like to see what over 4,000 Laravel developers like about the Mastering Laravel newsletter? It's free to sign up.

Slowly introducing static analysis without changing everything

Joel Clermont and Aaron Saray — Tue, 25 Jun 2024 00:00:00 -0500

Maybe you've tried to add static analysis to your Laravel app and got scared away by all the errors.

In this episode we discuss how we like to introduce PHPStan to large, long-lived projects in a way that doesn't introduce a lot of risk or change.

Would you like help introducing Larastan to your project? That's one of many things we can help you with!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Troubleshooting an empty session

Joel Clermont and Aaron Saray — Tue, 11 Jun 2024 00:00:00 -0500

Why isn't this working? It can be frustrating when something doesn't work as expected!

In this episode, we talk through a recent issue Joel had with sessions and oauth flows. There are a couple principles that apply more broadly.

Next time you're stuck on something, let us help!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Magic methods are okay in the right context

Joel Clermont and Aaron Saray — Tue, 28 May 2024 00:00:00 -0500

"Magic" methods and properties show up several places in Laravel, as well as third-party packages. They can make certain things easier and less verbose, but there is a trade off. In this episode, we discuss a few different contexts where we like and avoid magic accessors.

We'd really appreciate it if you share the show with other Laravel devs.

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Should you let your admin do that?

Joel Clermont and Aaron Saray — Tue, 14 May 2024 00:00:00 -0500

Admins can do everything in the app, right? Today we discuss a couple reasons why you may want to consider not letting an admin have access to every single feature in your app.

🎉️ Episode 100 is a huge milestone for us. Thank you for listening!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Don't get overwhelmed by errors in your application

Joel Clermont and Aaron Saray — Tue, 30 Apr 2024 00:00:00 -0500

Have you ever turned on error tracking in a long-lived app and then got overwhelmed by all the errors happening? We talk through some strategies to not get overwhelmed and make a case that you really should be monitoring this in production.

Would you like help with your legacy app? We have a ton of experience making legacy apps a joy to work within.

(00:00) - Your app should be tracking errors
(02:30) - Better than just parsing logs
(05:15) - Don't get overwhelmed when you first turn it on
(06:00) - How to triage and prioritize
(07:30) - Know about performance issues
(10:30) - Silly bit

Does it matter how your code looks?

Joel Clermont and Aaron Saray — Tue, 16 Apr 2024 00:00:00 -0500

We've talked about coding standards before, but this time we approach it from a slightly different angle. Does the way you're code is formatted affect your ability to understand it? Brains are interesting things.

Is your code slower than you'd like? We specialize in Laravel performance optimization and we can help! Contact us to discuss.

The life cycle of database hosting

Joel Clermont and Aaron Saray — Tue, 02 Apr 2024 00:00:00 -0500

You launched a hobby project and then it starts to get some traction. What next? How do you get a more solid foundation under your app when it comes to database hosting? In this episode, we discuss the common phases we see a database go through during an app's life.

And if you'd love some help moving your database or tackling performance issues, give us a call!

Are you really going to need that abstraction?

Joel Clermont and Aaron Saray — Tue, 19 Mar 2024 00:00:00 -0500

Interfaces are a great tool for writing maintainable applications, but it is possible to go "too far" with abstraction. Or maybe, it's a bad use of time to write an abstraction up front before you really know you need it. We discuss some trade-offs and examples.

(00:00) - Life before interfaces in PHP
(02:30) - Going too far with interfaces
(04:45) - A discussion with payment gateways
(07:30) - Abstracting the database as another trap
(09:15) - Laravel makes good use of interfaces
(10:05) - Silly bit

Need some perspective on your Laravel project? We offer a code review service. Get in touch to learn more.

Should you change application code to support a test?

Joel Clermont and Aaron Saray — Tue, 05 Mar 2024 00:00:00 -0600

When you're writing a test it can be so tempting to just "tweak" some app code to make it easier to write that test, but we discuss why that might not be a good idea. We also talk about some app changes while writing tests that are beneficial to the overall project.

(00:00) - Sometimes changing code makes testing easier
(01:30) - Different types of code changes
(02:45) - An example with Laravel jobs
(04:30) - A time when it's okay to change code while testing
(08:50) - Avoid problems by writing tests earlier
(09:30) - Silly bit

Don't "compromise" on testing. See how we can help level up your Laravel project.

What is the point of design patterns?

Joel Clermont and Aaron Saray — Tue, 20 Feb 2024 00:00:00 -0600

Do your eyes glaze over when someone mentions singletons or factories? We'll try to not to be boring as we explain the benefits of design patterns.

Move that logic out of your view

Joel Clermont and Aaron Saray — Tue, 06 Feb 2024 00:00:00 -0600

Ever feel like your Blade views are getting too logic-heavy? What logic belongs in the view, and what logic would be better somewhere else? We use a recent PR discussion to talk through these points.

(00:00) - Trying to keep logic out of the Blade view
(02:00) - Using the simplest form of logic
(03:45) - Business logic doesn't belong in the view layer
(04:15) - Condition moved into the controller
(05:20) - Secondary benefit of testing

Check out the Mastering Laravel YouTube channel

Is it worth switching to another tool?

Joel Clermont and Aaron Saray — Tue, 23 Jan 2024 00:00:00 -0600

When new tools and packages come out, there is usually some buzz around the launch, and how it solves all the problems of the old tool. Should you switch? How do you know when it's worth it? What are the potential downsides of switching? We talk through a couple examples and share how we approach these decisions

Want to see what our coding standard looks like?

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

How we use seeders in our applications

Joel Clermont and Aaron Saray — Tue, 09 Jan 2024 00:00:00 -0600

Seeders seem pretty straightforward. It's a way to generate data. But how should you use them in your app and what different purposes do they serve? We talk through our approach to seeders and how we use them in a few different contexts.

(00:00) - Diving into how we use seeders in our applications
(01:40) - Should a seeder create users?
(04:30) - Using seeders in multiple contexts
(09:50) - The one time we might use seeders with tests
(11:50) - Silly bit

Would you like some expert help on your Laravel application?

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

Don't just get mad at some tech, dig in and learn!

Joel Clermont and Aaron Saray — Tue, 26 Dec 2023 00:00:00 -0600

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

Wow, 90 episodes in a row. Never missed one! Want to hire some super reliable Laravel developers?

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

Making a case for consistency

Joel Clermont and Aaron Saray — Tue, 12 Dec 2023 00:00:00 -0600

We see a lot of different projects, but it's pretty rare to find one that's well-documented and internally consistent. Why does that matter? And how can you make things more consistent without spending a lot of time on it?

(00:00) - We like keeping things tidy in our projects
(01:20) - Have a README, please
(03:30) - Is there a business case for consistency across projects?
(05:30) - An example with Docker build speeds in CI
(06:50) - Consistency in naming business concepts
(09:45) - Silly bit

Short, practical Laravel tips delivered fresh to your inbox. Sign up today!

Different approaches to upgrading to a new major Laravel version

Joel Clermont and Aaron Saray — Tue, 28 Nov 2023 00:00:00 -0600

How 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?

Maybe you don't need to write code this time

Joel Clermont and Aaron Saray — Tue, 14 Nov 2023 00:00:00 -0600

We're developers, we write code! But sometimes it's worth thinking if we really need to fire up our editor, or if a better solution exists. We talk through some "behind the scenes" podcast workflow, and how we decided we didn't need to write code this time.

(00:00) - Considering better ways to track topics
(01:00) - The developer brain kicks in
(03:05) - Building it in Slack without any code
(05:15) - Feeling empathy for the non-devs out there
(06:45) - Deciding not to automate everything
(09:15) - Another example with a stats dashboard
(11:25) - Silly bit

Need help with your Laravel app? We've seen it all and can get things done faster than you're used to.

Should you manage roles and permissions with a UI?

Joel Clermont and Aaron Saray — Tue, 31 Oct 2023 00:00:00 -0500

Just about every application needs the concept of roles and permissions. Often, there's a desire to allow non-developers to manage roles and permissions in the application interface, but is that a good idea?

(00:00) - Roles and permissions landscape
(01:45) - A UI for managing permissions?
(04:14) - Rolling out new permissions via migrations
(06:45) - What about managing roles in a UI?
(09:00) - Covering permissions in tests
(10:30) - Maybe a read only UI?
(10:55) - Silly bit

The validation worksheet has been retired, but check out our validation book.

The changing value of books throughout your career

Joel Clermont and Aaron Saray — Tue, 17 Oct 2023 00:00:00 -0500

You might have a book that really shaped how you write code today. Some books make more sense if you read them later in your career. We discuss the changing value of books as a learning resource as you gain experience.

00:00 Using books as a resource
01:59 Changing perspectives as you gain experience
03:05 Recognizing real-world applications of what you read
05:45 Balancing enthusiasm with experience
07:20 You don't need to learn everything
09:35 Silly bit

You could spend a few thousand dollars on books, but maybe that money is better spent working with us.

Some reasons to write a down method in your migrations

Joel Clermont and Aaron Saray — Tue, 03 Oct 2023 00:00:00 -0500

This is a surprisingly controversial topic. In this episode, we share why we write down migration methods, and it's probably not the reason you're thinking of.

(00:00) - Is writing down migration methods just a weird habit?
(02:30) - A deploy that goes horribly wrong immediately
(03:45) - Rolling forward due to database engine limitations
(05:00) - How long is too long to rollback?
(06:30) - Another use case: switching branches
(08:30) - A mental unit test for your logic
(12:35) - Silly bit

No call to action on this episode, just go enjoy some quiet time to yourself.

Managing a micro-manager

Joel Clermont and Aaron Saray — Tue, 19 Sep 2023 00:00:00 -0500

It's frustrating to have a client, boss, or even co-worker attempt to micro-manage you. We share some tips on how to make the working relationship better.

(00:00) - Uncomfortable projects and clients
(02:45) - Ask them directly "what's up"
(05:00) - Understand what they want from you
(07:00) - Let's role play
(10:30) - The extra work is worth it
(11:42) - Silly bit

Need help building your Laravel product? Hire two expert Laravel developers for less than you might think.

A couple handy features in PHPStorm

Joel Clermont and Aaron Saray — Tue, 05 Sep 2023 00:00:00 -0500

Developers spend a large part of their day inside an editor. For a full-featured editor like PHPStorm, there may be some useful features you've never noticed. We discuss a few of those.

Tools should work for you, not boss you around

Joel Clermont and Aaron Saray — Tue, 22 Aug 2023 00:00:00 -0500

PHPStan is a great tool, but if you're not careful it might push you to write code in a way you wouldn't normally write it. How can you balance a tool's strengths with your team's style of writing code?

(00:00) - We really like PHPStan
(01:30) - Can you go too far with a tool, though?
(03:40) - Things to consider if you're newer to Laravel or PHP
(05:30) - PHPStan has helped us find bugs
(06:25) - Accessing route parameters in a type-safe way
(09:22) - Know how the tool works, to make it work for you
(11:13) - Return types on controller actions
(14:22) - Silly bit

Need help getting unstuck with a Laravel issue? We can help!

Harnessing that post-conference excitement

Joel Clermont and Aaron Saray — Tue, 08 Aug 2023 00:00:00 -0500

It is so exciting to watch a conference talk announcing some new tool or feature. Now you're back at work and your fingers are itching to type `composer install` - What do you do?

(00:00) - Post-conference excitement is a real thing
(01:11) - The reality of how conferences are structured
(03:50) - Talks share things you could do not things you should do
(05:00) - How to apply new ideas in your daily work
(06:08) - Specific challenges within a team
(11:40) - Silly bit

Want to see the musical conference talk Joel mentioned?

You like short things, that's why you listen to this podcast. How about a short Laravel tip in your inbox?

How do you tell a teammate they might be wrong?

Joel Clermont and Aaron Saray — Tue, 25 Jul 2023 00:00:00 -0500

Programmers have opinions on things. Shocking, I know! How can we tell someone we think there's a better way to do something, without being counterproductive and causing needless confrontation?

(00:00) - Programmers have opinions on a lot of topics
(02:25) - Start by asking questions
(03:45) - Get smart with leading questions
(05:25) - Do you always have to call out something you think is wrong?
(07:15) - Conflict doesn't mean confrontation

Need help from some seasoned Laravel devs? Don't be shy. We don't bite.

Lots of different ways to test record creation

Joel Clermont and Aaron Saray — Tue, 11 Jul 2023 00:00:00 -0500

We get a bit nerdy here and dive deep on a few different ways to test record creation.

(00:00) - We like testing
(01:20) - One way to test creating a record
(03:00) - Limitations of fetch the record with first()
(05:30) - Considerations when using latest() in tests
(07:00) - An approach for using auto-increment IDs
(08:05) - Silly bit

Read more of our thoughts at masteringlaravel.io

How do you avoid distractions?

Joel Clermont and Aaron Saray — Tue, 27 Jun 2023 00:00:00 -0500

Do you maintain laser focus when you work, or are you a normal human being? How do you balance use of email and social media for legitimate work reasons without going down the rabbit hole of distraction? Stop your work and listen to this episode for answers. It's not a distraction, it's an investment.

(00:00) - Feeling the pull of distraction when trying to focus on work
(01:30) - Email - the biggest distraction
(03:00) - The world won't end if you keep email closed
(06:00) - Setting expectations with others
(07:45) - Being a hero might actually be unfair to others
(08:20) - Productivity is really about well-being, not cranking out work
(09:00) - Be realistic when planning
(10:00) - Experiment and find what works for you
(11:30) - Social media as a distraction
(13:00) - Silly bit

When should you use final classes or private properties?

Joel Clermont and Aaron Saray — Tue, 13 Jun 2023 00:00:00 -0500

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

Want to hire us and argue about it? Book a call

Is it ever ok to delay writing tests?

Joel Clermont and Aaron Saray — Tue, 30 May 2023 00:00:00 -0500

We always write tests, and can't imagine working without them. But is there ever a time where it might make sense to delay writing some tests until later in the project? Let us tell you a story about a recent project where we made that decision.

(00:00) - Our secret podcast agenda
(01:00) - Project setup
(02:30) - Tests are good, but they do add time
(03:15) - Some ambiguity on "is this what the user needs/wants?"
(06:00) - Discussing the decision to delay tests as a team
(07:15) - Conclusion - it's the audience, not the timeline
(08:10) - Side benefit of knowledge sharing
(09:15) - Silly bit

Become a more confident Laravel developer. Sign up for practical tips at masteringlaravel.io

Should an Eloquent relationship include soft-deleted records?

Joel Clermont and Aaron Saray — Tue, 16 May 2023 00:00:00 -0500

Show notes:

(00:00) - Relationships and trashed records
(02:00) - One-to-one relationship
(02:39) - Are soft-deletes bad then?
(03:30) - Balancing end user and developer experience
(05:00) - One-to-many relationships are even more problematic
(08:00) - Does the specific domain matter?
(10:15) - Agree on the rule as a team
(10:50) - Silly bit

Get a free ebook of Laravel security tips

Interviewing other developers like a human

Joel Clermont and Aaron Saray — Tue, 02 May 2023 00:00:00 -0500

Some interviewing techniques can be pretty disrespectful of the applicant's time or humanity. On today's episode we talk about some ways of approaching an interview to put the person at ease and help them to do their best.

Show notes:

00:00 Our different work backgrounds
01:00 How to kick off a technical discussion in an interview
03:45 How to leverage their existing experience
04:50 Learn about their communication style
06:00 Figuring out how someone thinks about a problem
09:30 Don't code review actual company code
11:50 Silly bit

The benefits of working with other developers

Joel Clermont and Aaron Saray — Tue, 18 Apr 2023 00:00:00 -0500

Maybe 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

Changing our mind about queues in testing

Joel Clermont and Aaron Saray — Tue, 04 Apr 2023 00:00:00 -0500

We'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 Notes

00:00 Sometimes we change our mind over time
02:00 Changing queue from sync to null in tests
03:45 Feature versus integration tests
04:40 Where do you test job logic?
05:30 White box versus black box testing
07:15 Laravel queue drivers and how faking works
08:55 Why use events at all?
09:30 The new approach is faster too
11:15 Silly bit

Want to make us happy with a random email? Check out our free and paid books on masteringlaravel.io

Too many rules?

Joel Clermont and Aaron Saray — Tue, 21 Mar 2023 00:00:00 -0500

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 rules
01:20 Maybe going too far with rules - the scenario
03:05 Bug explanation
05:03 A tangent on test setup
06:30 A possible rule to prevent this bug
07:17 Why this rule went too far
08:50 We still want to fix it, just not now
09:45 Another example with syntax and code standards
12:53 Silly bit

Need help to set up or improve your team's coding standards?

Keeping an open mind with other languages and tools

Joel Clermont and Aaron Saray — Tue, 07 Mar 2023 00:00:00 -0600

Before 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 use
01:02 Why are there different kinds of tools?
03:30 Is it "bad" because we don't understand it?
04:42 Learn from other communities
07:10 Don't be a jerk
07:55 Silly bit

Need some help with your Laravel application?

What we look for in a package

Joel Clermont and Aaron Saray — Tue, 21 Feb 2023 00:00:00 -0600

We 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 packages
01:02 Too much of a good thing?
02:48 Risks to consider
04:13 Other ways to share
05:34 Think before you promote
08:02 Consider the friction
08:39 Silly bit

Would you like help auditing the packages in your Laravel application?

Blogging versus tweeting

Joel Clermont and Aaron Saray — Tue, 07 Feb 2023 00:00:00 -0600

Laravel 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 beneficial
02:43 Slowing down before you publish
04:30 Tips that provide value
08:11 Platforms can go away
09:36 Silly bit

Check out the new articles section on masteringlaravel.io

Knowing when to use new language or framework features

Joel Clermont and Aaron Saray — Tue, 24 Jan 2023 00:00:00 -0600

New 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.

Going on a bug hunt

Joel Clermont and Aaron Saray — Tue, 10 Jan 2023 00:00:00 -0600

How 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

Thinking about the user, even in the details

Joel Clermont and Aaron Saray — Tue, 27 Dec 2022 00:00:00 -0600

User 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 experience
02:54 A specific example of user-focused thinking
04:34 Choosing the most helpful HTTP status code
05:44 What if it’s an API response?
07:17 How much detail in an error is useful to a user?
08:35 Silly bit

Move from competent to confident - become a better Laravel developer with the free resources available at masteringlaravel.io

Why do you write your tests like that?

Joel Clermont and Aaron Saray — Tue, 13 Dec 2022 12:00:00 -0600

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 tests
2: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 thing
6:30 - Is it okay to have code duplication in tests?
8:20 - How tests are different from application code
11:16 - Don’t add application code just for your tests
13:06 - Silly bit

Need help building a test suite for your Laravel app or making your existing tests more reliable? Click the link and book a free call to see how we can help.

Avoid painting yourself into a corner

Joel Clermont and Aaron Saray — Tue, 29 Nov 2022 00:00:00 -0600

We'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 it
01:17 What we mean by "I don't like this code"
02:22 A specific example of code I didn't like
03:52 Code review sparks a discussion, and a solution
05:20 Principle: don't get locked in to your first approach
06:03 Principle: the benefits of code review
07:22 Don't be defensive, and the code reviewer isn't always right
08:03 Silly bit

Look before you leap

Joel Clermont and Aaron Saray — Tue, 15 Nov 2022 00:00:00 -0600

Hear 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.

Don't plan to do too much

Joel Clermont and Aaron Saray — Tue, 01 Nov 2022 00:00:00 -0500

Do 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!

Isolate the problem

Joel Clermont and Aaron Saray — Tue, 18 Oct 2022 00:00:00 -0500

What 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.

What should I test?

Joel Clermont and Aaron Saray — Tue, 04 Oct 2022 00:00:00 -0500

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!

Picking a strategy for translation in Laravel

Joel Clermont and Aaron Saray — Tue, 20 Sep 2022 00:00:00 -0500

There 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.

Should a factory follow all business rules?

Joel Clermont and Aaron Saray — Tue, 06 Sep 2022 00:00:00 -0500

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.

Understanding different learning styles

Joel Clermont and Aaron Saray — Tue, 23 Aug 2022 00:00:00 -0500

What 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

Sometimes it's good to be boring

Joel Clermont and Aaron Saray — Tue, 09 Aug 2022 00:00:00 -0500

Do 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

What was this developer thinking??

Joel Clermont and Aaron Saray — Tue, 26 Jul 2022 00:00:00 -0500

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.

Should you fix all bugs in a legacy project?

Joel Clermont and Aaron Saray — Tue, 12 Jul 2022 00:00:00 -0500

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

Learning from other communities

Joel Clermont and Aaron Saray — Tue, 28 Jun 2022 00:00:00 -0500

Can 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.

Uh-oh, that proof of concept is going into production. Now what?

Joel Clermont and Aaron Saray — Tue, 14 Jun 2022 00:00:00 -0500

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.

The benefits of sharing what you learn

Joel Clermont and Aaron Saray — Tue, 31 May 2022 00:00:00 -0500

If 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

How to deal with interruptions

Joel Clermont and Aaron Saray — Tue, 17 May 2022 00:00:00 -0500

How 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.

Should I write this weird code or is there a Laravel feature I can use instead?

Joel Clermont and Aaron Saray — Tue, 03 May 2022 00:00:00 -0500

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.

Take time to look back and review

Joel Clermont and Aaron Saray — Tue, 19 Apr 2022 00:00:00 -0500

It 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.

The benefits of testing, even under a deadline

Joel Clermont and Aaron Saray — Tue, 05 Apr 2022 00:00:00 -0500

We 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

When to calculate a value versus when to store it in the database

Joel Clermont and Aaron Saray — Tue, 22 Mar 2022 00:00:00 -0500

For 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 decision

Download our free Laravel tips ebook.

Should I use an event/listener or a model observer?

Joel Clermont and Aaron Saray — Tue, 08 Mar 2022 00:00:00 -0600

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.

How we wrap up a project

Joel Clermont and Aaron Saray — Tue, 22 Feb 2022 00:00:00 -0600

Wrapping 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

Don't be afraid to change your mind

Joel Clermont and Aaron Saray — Tue, 08 Feb 2022 00:00:00 -0600

You 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

The proper way to argue

Joel Clermont and Aaron Saray — Tue, 25 Jan 2022 00:00:00 -0600

We'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

What makes a good staging environment?

Joel Clermont and Aaron Saray — Tue, 11 Jan 2022 00:00:00 -0600

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.

Your project is not special

Joel Clermont and Aaron Saray — Tue, 28 Dec 2021 00:00:00 -0600

This 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.

Planning out a week of work

Joel Clermont and Aaron Saray — Tue, 14 Dec 2021 00:00:00 -0600

Continuing 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

A few things to watch for with Laravel policies

Joel Clermont and Aaron Saray — Tue, 30 Nov 2021 00:00:00 -0600

Aaron 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.

Onboarding a new project

Joel Clermont and Aaron Saray — Tue, 16 Nov 2021 00:00:00 -0600

When 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

Paying down technical debt

Joel Clermont and Aaron Saray — Tue, 02 Nov 2021 00:00:00 -0500

Have 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.

Knowing when and how to try something new

Joel Clermont and Aaron Saray — Tue, 19 Oct 2021 00:00:00 -0500

You 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

Wireframe before coding

Joel Clermont and Aaron Saray — Tue, 05 Oct 2021 00:00:00 -0500

As 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

Continuous integration doesn't have to be hard

Joel Clermont and Aaron Saray — Tue, 21 Sep 2021 00:00:00 -0500

* Github Actions by Michael Heap (50% discount for podcast listeners)
* masteringlaravel.io - get a jump start on validation with our free worksheet

Deciding what to build

Joel Clermont and Aaron Saray — Tue, 07 Sep 2021 00:00:00 -0500

Check out our new website: MasteringLaravel.io

Are your logs too noisy?

Joel Clermont and Aaron Saray — Tue, 24 Aug 2021 00:00:00 -0500

The broken window theory of programming
New site launch! MasteringLaravel.io

How we decide whether or not to take on something new

Joel Clermont and Aaron Saray — Tue, 10 Aug 2021 00:00:00 -0500

This 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.

Are you allowed to do that?

Joel Clermont — Tue, 27 Jul 2021 00:00:00 -0500

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 Laravel

Our favorite permissions package: laravel-permission

Are you a Laravel developer or a PHP developer?

Joel Clermont — Tue, 13 Jul 2021 00:00:00 -0500

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 Laravel

Fun game to learn/practice regular expression syntax: Regex Crossword

Should developers have access to production?

Joel Clermont — Tue, 29 Jun 2021 16:03:06 -0500

> 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

Pick a coding standard, any one will do

Joel Clermont — Tue, 15 Jun 2021 00:00:00 -0500

Where 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

The art of asking and answering questions

Joel Clermont — Tue, 01 Jun 2021 00:00:00 -0500

We'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

Testing 1 ... 2 ... 3, let's talk testing

Joel Clermont — Tue, 18 May 2021 00:00:00 -0500

What 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.

Guarded vs fillable, fight!

Joel Clermont — Tue, 04 May 2021 00:00:00 -0500

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.

Find out more about Mastering Laravel Validation Rules.

Don't ignore that pain!

Joel Clermont — Tue, 20 Apr 2021 00:00:00 -0500

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.

Find out more about Mastering Laravel Validation Rules.

Validation is your friend

Joel Clermont — Tue, 06 Apr 2021 00:00:00 -0500

Validation 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.

Find out more about Mastering Laravel Validation Rules.

Always be ready to hand off the project

Joel Clermont — Tue, 23 Mar 2021 00:00:00 -0500

Why is it important to think about a future project hand-off at the beginning of a client relationship? Aaron and Joel share their approach.

Finding and fixing a performance issue

Joel Clermont — Tue, 09 Mar 2021 00:00:00 -0600

Last episode we discussed how to deal with a "slow app" complaint. This episode we discuss some technical approaches to find and fix the issue.

Someone said my app is slow. Now what?

Joel Clermont — Tue, 23 Feb 2021 00:00:00 -0600

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.

Ed Balls Day wikipedia article

How long does it take to get your project running?

Joel Clermont — Tue, 09 Feb 2021 00:00:00 -0600

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.

Is it a good idea to install that package?

Joel Clermont — Tue, 26 Jan 2021 00:00:00 -0600

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.

Where do I start making things better?

Joel Clermont — Tue, 12 Jan 2021 00:00:00 -0600

Where are some good starting points for modernizing and improving a legacy codebase? Joel and Aaron discuss a few ideas where you could start.

Does anyone read these? Tweet @jclermont if you see this.

How long is that going to take?

Joel Clermont — Tue, 29 Dec 2020 00:00:00 -0600

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 difficult
02:00 Disconnect between a developer and a stakeholder
03:00 How Aaron approaches an estimate
06:05 Pad the estimate? Ranges?
07:38 The importance of open communication
08:12 Translating "hours" into real world time
09:50 Planning not pricing
11:56 Silly bit

Getting started with a legacy codebase

Joel Clermont — Tue, 15 Dec 2020 00:00:00 -0600

Stepping 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 base
03:05 Starting with unit tests can be hard
04:20 Be extra careful with external APIs
07:15 Onboarding a new project
08:35 Getting more specific on the first few tests
10:38 Silly bit

Why even review when my code is perfect?

Joel Clermont — Tue, 01 Dec 2020 00:00:00 -0600

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 process
02:53 Look at it as a learning opportunity
04:06 Approaching a pull request to review it
06: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 reviewed
10:25 Silly bit

Are you testing me?

Joel Clermont — Tue, 17 Nov 2020 00:00:00 -0600

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 packages
04:15 What do you test? How do you write them?
06:30 Testing the happy path
07:05 Testing the "unhappy" paths
08:12 It's less work than you think
11:30 Testing a dumb mistake with range validators
14:40 Silly bit

What is the one true way to do this?

Joel Clermont — Tue, 27 Oct 2020 00:00:00 -0500

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 controller
03: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 important
08:45 Silly bit

Did you just tell me to read the manual?

Joel Clermont — Tue, 13 Oct 2020 00:00:00 -0500

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 learn
00:56 Importance of reading docs
02:00 Reading versus doing
03:45 Be curious when reading
05:20 How to get hands-on practice
07:30 Learning a new release of an existing tool
10:15 Improve the docs!
12:15 Silly bit

Exercises for Programmers from Pragmatic Press

Do you have a clear mental model?

Joel Clermont — Tue, 29 Sep 2020 00:00:11 -0500

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 stuck
01:12 What is a "mental model"?
02:15 A concrete example of a mental model
04:30 Discussing rebase versus merge
06:30 A PHP specific example for rebase
07:40 Mental models for queue workers
10:10 Open source helps us understand
11:30 Silly bit

The best argument is no argument

Joel Clermont — Tue, 15 Sep 2020 00:00:05 -0500

Disagreements 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 something
01:45 Handling a difference of opinion
02:33 Staying consistent within a project
03:44 Using tools to help consistency
06:00 Document your project standards
07:37 Keep an open mind
11:01 Choose your battles wisely
12:25 Involve the whole team in the discussion
13:05 Silly bit

What's with these flaky tests?

Joel Clermont — Mon, 31 Aug 2020 19:10:28 -0500

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 worst
02:12 Why randomization can lead to flaky tests
03:10 A guideline on when to avoid randomization
05:10 Trying to predict the future?
06:15 Naming can be a guide
07:15 Use factory states
08:00 Another type of flaky test
11:15 Silly bit

When should I upgrade my Laravel project?

Joel Clermont — Fri, 14 Aug 2020 16:32:34 -0500

00:00 The desire to upgrade to a shiny new Laravel version
02:20 I actually enjoy maintenance
03:48 An analogy with cars
04:30 The importance of communication
05:30 Making it easier to upgrade
06:30 Do you want to be on the bleeding edge?
07:52 Silly bit

How do you figure out why your code isn't working?

Joel Clermont — Fri, 14 Aug 2020 16:26:02 -0500

00:00 The thought process when you get stuck
01:40 An example with CSS
03:40 Tools that can help locally
06:15 Using a debugger to learn about Laravel
06:30 Tools that can help in a remote environment
08:22 Real talk about debugging in production
09:57 Troubleshooting database performance
11:16 Searching the internet for an answer
13:02 Silly bit

When is the right time to automate a dev task?

Joel Clermont — Fri, 14 Aug 2020 16:21:28 -0500

00:00 The urge to automate everything
01:49 Document before you automate
02:45 Weighing time spent versus time saved
03:30 Automation isn't maintenance-free
04:08 Types of automation
05:18 The exception to the rule
07:05 An example of using a command to update data
08:00 Silly bit