No Compromises
Two seasoned programming veterans, Joel Clermont and Aaron Saray, share best practices and insights from years of working with Laravel SaaS teams. The podcast focuses on practical advice for developers building and maintaining software-as-a-service applications using the Laravel framework.
Episodes
Running AI agents on your production server is the new FTP
Have you ever let an AI agent run commands on your production server because you were stuck, telling yourself it would be fine?In the latest episode of the No Compromises podcast, we discuss why giving AI agents access to your production environment is as reckless as the bad old days of FTPing code straight to your server.We make the case that AI agents are non-deterministic and carry no
Why having a human partner still beats relying on AI alone
Have you ever been stuck on a problem and instinctively reached out to a real person instead of an AI, and found that was exactly the right call?In the latest episode of the No Compromises podcast, we discuss why human collaboration still matters in a world where AI seems to have all the answers.Aaron shares a late-night hardware crisis that a blog post from a real human solved, something
What is really inside the AI tools you blindly install
When you install a package, you probably skip the source code. But what about the AI skills and CLAUDE.md files you are feeding directly into your agent?In the latest episode of the No Compromises podcast, we discuss whether developers are reading the AI skills they install and why it actually matters.We make the case that unread skills are riskier than unread packages because they quietl
How much logic is too much logic in a PHP enum
Have you ever added a method to an enum and then wondered if you just turned it into something it was never meant to be?In the latest episode of the No Compromises podcast, we discuss where to draw the line when adding methods and logic to PHP enums.We trace the evolution from magic strings to constants to interfaces, and explain why enums were the missing piece PHP needed all along.We al
Your codebase is not a museum for old code
Have you ever opened a file to make a quick change, only to find dozens of lines of commented-out code making it nearly impossible to understand what's actually running?In the latest episode of the No Compromises podcast, we discuss why keeping dead code around is slowing your whole team down.We make the case that commented-out or unused code creates real confusion when searching a codeba
Do you actually own the code you ship?
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 havi
Do you actually need a multi-tenancy package?
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 confi
Local and production should match even for Laravel tools
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
When weird code needs to explain itself
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
Are you testing your app or just the framework?
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 somethi
Being anti-hype does not mean being anti-AI
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 ca
Three ways to plan an upgrade when your codebase is a patchwork
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
Stop doing math in your config files
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
What could be worse than having no tests?
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 t
Why I changed my mind about down migrations
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
Why senior developers feel wrong more often
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
Should 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
Discussing different ways to model data
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 imp
Read outside tech to expand your horizons
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 examp
Rewriting without a map: shipping an MVP from a legacy app
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
A composable, versioned toolkit for Laravel projects
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, et
Should you use DTOs in Laravel?
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 whe
Sunsetting a company app without loose ends
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
When building a UI makes more sense than bloating your seeders
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 mini
Blade includes vs components: how we decide
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,
Changing your mind about when() and unless() in Eloquent
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.(0
Finding a code-review style that fits your brain
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 cha
Never take hostages: give clients control from day one
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:1
Balancing test coverage without chasing 100 percent
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
Exploratory coding when requirements are fuzzy
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) - Choos
Understanding how Stringable works inside Blade views
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) - D
Finishing up our discussion on not having time
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 elevati
Why “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 tim
When validation can protect your app's performance
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 la
Stick with conventions and avoid overengineering your Laravel app
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
When to bring in outside help
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) - Pinpoint
Why two databases are better than one
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 s
Dealing with being a beginner again
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
Making short demo videos count
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
Examining test layering in multi-tenant requests
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
When to step outside of Eloquent's comfort zone
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
Feature 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 archite
Deciding when to use a new piece of technology
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
Taking liberties with value objects
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 th
How to deal with things outside your control on a dev project
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
Should 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
A balanced approach to static analysis in Laravel apps
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 La
Why do we like testing so much?
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) - Shifti
What does it mean to "know" something?
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
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
Where do you go when you need help?
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) - Op
What does it mean if someone says your app is slow?
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
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 sui
API specs aren't just for giant teams
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) - Bala
Slowly introducing static analysis without changing everything
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,
Troubleshooting an empty session
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.I
Magic methods are okay in the right context
"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
Should you let your admin do that?
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
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 err
Does it matter how your code looks?
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
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?
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
(
Should you change application code to support a test?
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
What is the point of design patterns?
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.Sign up for our free Laravel newsletter and learn something new in 2 minutes or less.
Move that logic out of your view
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
Is it worth switching to another tool?
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 decisionsWant to see what our coding standard looks like?Toss a coin in the jar if you
How we use seeders in our applications
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:5
Don'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) -
Making a case for consistency
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
Different approaches to upgrading to a new major Laravel version
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
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
Should you manage roles and permissions with a UI?
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?
The changing value of books throughout your career
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 resource01:59 Changing perspectives as you gain experience03:05 Recognizing real-world applications of what you read05:45 Balancing enthusiasm with ex
Some reasons to write a down method in your migrations
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
Managing a micro-manager
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
A couple handy features in PHPStorm
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
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 bug
Harnessing that post-conference excitement
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
How do you tell a teammate they might be wrong?
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
Lots of different ways to test record creation
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
Recommended
Giants Talk: A San Francisco Giants Podcast
The Handlebar Podcast
رختکن بازندهها
Deadline: White House
Thrilling Threads - Conspiracy Theories, Strange Phenomena, True Crime, Unsolved Mysteries, etc!
The Daily Conspiracy Podcast
Talk About Talk - Executive & Leadership Communication Skills
The Daily
The Joe Rogan Experience
The Church of What's Happening Now: The New Testament
This Past Weekend w/ Theo Von
The Bread and Banter Podcast
