Adam Wathan presents a detailed walkthrough of test-driven development (TDD) in Laravel, demonstrating how to build features from scratch using both acceptance tests and unit tests. He builds a Twitter clone called 'Tweeter' and shows how to implement features like viewing user profiles and sending follower notification emails, while explaining best practices around using mocks, spies, and fakes in testing.

A talk about YAGNI (You Aren't Gonna Need It) principle in Laravel development. The speaker discusses how to avoid over-engineering by only implementing features when they're actually needed, while maintaining balance between simplicity and necessary complexity. He covers the stages of adopting YAGNI, from initial resistance through to confidence, and provides practical examples of when to apply or not apply YAGNI in Laravel applications.

Matt Stauffer discusses how to properly customize Laravel applications while maintaining code discoverability and following best practices. He emphasizes starting with Laravel's intended customization points in the app directory before moving to more advanced container-based modifications. The talk covers both philosophical approaches to customization and practical implementation details, with a focus on making customizations that future developers can easily understand.

Jeffrey Way shares 9 code refactoring techniques to improve Laravel applications, focusing on simplicity and practical solutions. He emphasizes letting code 'grossness' guide refactoring decisions rather than premature optimization, and advocates for optimizing code for deletion rather than trying to future-proof everything. The talk provides concrete examples of patterns like decorators, query objects, and event handling while warning against over-engineering.

The speaker presents a practical guide to understanding and implementing design patterns in Laravel applications. Starting with a story about a junior developer struggling with the Gang of Four design patterns book, he demonstrates how to make patterns more accessible by showing real-world implementations of the Adapter, Strategy, and Factory patterns using Laravel examples. The talk focuses on practical refactoring techniques and how to properly structure code using these patterns.

The talk focuses on simplifying Laravel frontend development by reducing JavaScript complexity and leveraging more backend functionality. The speaker describes his journey from basic blade templates to Vue.js components, and then demonstrates how to improve frontend architecture by moving logic back to PHP, using props effectively, embracing form submissions, and not being afraid of page reloads when appropriate.

Bob Martin gives a talk about clean architecture, discussing how frameworks like Rails (and by extension Laravel) should not dominate application design. He emphasizes that web frameworks are just I/O devices and should be treated as plugins to the core business logic. He discusses the importance of proper architecture that allows deferring major decisions, separates business logic from delivery mechanisms, and enables easy testing. He also touches on the growing responsibility of software developers in society and the need for self-regulation through practices like TDD.

A comprehensive talk about design patterns in Laravel, focusing on three key patterns: Singleton, Observer, and Bridge. The speaker explains each pattern using real-world analogies (like pizza-making) and shows how Laravel implements them differently from traditional PHP implementations. The talk demonstrates how Laravel uses these patterns in its core functionality, including service containers, event systems, and database migrations.

Keith Damiani gives an introduction to graph databases and their applications in Laravel projects. He explains what graph databases are, how they differ from relational databases, and demonstrates querying using Neo4j. The talk concludes with a showcase of 'Larry Pals' - a social networking proof-of-concept application built using Laravel and Neo4j, and announces an upcoming Laravel graph database driver package.

This talk focuses on implementing event sourcing in Laravel applications using the Event Sauce library. The speaker provides a pragmatic approach to event sourcing, demonstrating how to handle pull requests as an example domain. The talk covers the basics of event sourcing, including aggregates, projections, and process managers, while emphasizing practical code examples over theoretical concepts.

Jake Bennett presents his first conference talk on implementing State Machines and the State Pattern in Laravel applications. He demonstrates how to refactor complex conditional logic around invoice status management into a cleaner, more maintainable state machine implementation using PHP classes. The talk walks through creating a state diagram, implementing state classes, and delegating behavior through a state machine pattern rather than traditional event-action controllers.

Matt Stauffer discusses how to effectively use Laravel in enterprise environments, focusing on practical considerations rather than justifying Laravel's enterprise-readiness. He emphasizes the importance of avoiding over-engineering, sticking to Laravel conventions, and managing technical debt while addressing the unique challenges of enterprise development like larger teams, complex requirements, and organizational processes.

This talk explores testing in Laravel with a focus on facades and test doubles. The speaker explains Martin Fowler's test double definitions (dummies, fakes, stubs, spies, and mocks) and demonstrates how to effectively use Laravel's built-in fakes for testing mail, events, jobs, and HTTP requests. The presentation emphasizes practical approaches to testing, showing how to avoid common pitfalls and achieve genuine confidence in tests rather than false confidence from incomplete assertions.

Luke Downing gives an insightful talk about learning lessons from Laravel's design and philosophy. He discusses how seemingly simple features like three-line comments and facades reveal deeper truths about software development. The talk emphasizes how Laravel teaches developers to balance rules and conventions with practical developer experience, using examples from routing, testing, and real-time applications.

A detailed technical talk about Laravel Octane, explaining how it works internally, its benefits and gotchas. The speaker covers how Octane allows Laravel applications to run in a long-lived process instead of bootstrapping for each request, discusses different runtime drivers like Swoole and FrankenPHP, and explains concepts like non-blocking I/O and concurrent task execution. The talk focuses on understanding the underlying architecture rather than basic usage.

A technical talk about software design patterns used in Laravel framework. The speaker covers several key design patterns including Iterators, Observers, Singletons, Facades, and Decorators, explaining how they are implemented in Laravel and their practical applications. The talk includes detailed explanations of each pattern's structure, purpose, and real-world examples from Laravel's codebase.

Fabien Potencier, creator of Symfony, discusses the history and architecture of Symfony framework, its components, and why Laravel chose to adopt several Symfony components. He explains how Symfony provides low-level building blocks for PHP applications, focusing on best practices and standards, while emphasizing the framework's modular design and HTTP abstraction layer.

Matt Machuga gives a comprehensive talk about object-oriented programming in PHP/Laravel, focusing on proper object design, testing practices, and code responsibilities. He covers the history of OOP in PHP, explains key concepts like inheritance, traits, and polymorphism, and provides practical guidance on writing testable code while emphasizing the importance of proper object composition and responsible design patterns.

Ben Corlett discusses best practices for PHP package development, focusing on framework-agnostic design and the importance of maintaining package independence from specific frameworks like Laravel. He emphasizes using interfaces, avoiding framework-specific dependencies, and making packages reusable across different PHP frameworks while maintaining clean, maintainable code.

The speaker discusses his approach to building complex Laravel applications, focusing on architecture and abstraction. He shares his journey from basic MVC to more sophisticated patterns, emphasizing the importance of proper abstraction layers, service providers, and facades. He advocates for writing clean, maintainable code that distributes complexity across well-designed structures while maintaining a beautiful API surface.

Frank Diama discusses how developers can learn from other developers, frameworks, and programming languages. He explores different approaches to solving common problems, using examples from Python and JavaScript to demonstrate how their solutions can inspire improvements in PHP. He covers topics like event handling, promises, and variadic arguments, while emphasizing the importance of choosing the right tool for each job rather than trying to solve everything in PHP.

A comprehensive talk about bringing Laravel's best practices and components to legacy PHP applications through incremental improvements rather than complete rewrites. The speaker discusses how to modernize existing codebases by gradually introducing modern PHP practices, Laravel components, and external services while maintaining operational stability.

Kirk discusses a comprehensive approach to validation in Laravel 4 applications, focusing on separating validation logic from models and controllers into dedicated validation classes. He demonstrates how to handle different validation scenarios through use-case specific validation classes and how to leverage Laravel's exception handling system to cleanly handle validation failures.

Taylor Otwell presents upcoming features and changes in Laravel 4.3, including a new folder structure, form request validation, contract interfaces, file system abstraction with Flysystem, and route caching for performance improvements. He emphasizes backward compatibility and explains how existing 4.2 applications can be upgraded smoothly.

A comprehensive talk about PHP annotations, their history, implementation, and practical usage. The speaker discusses how annotations work as metadata in code comments, their benefits for configuration and context, and demonstrates building custom annotations using different annotation engines, particularly focusing on doctrine annotations. While PHP lacks core annotation support, the talk shows how third-party libraries enable annotation functionality and explores trade-offs around their use.

The talk focuses on Test-Driven Development (TDD) and behavioral design patterns, particularly emphasizing the importance of object communication and mocking in software design. The speaker discusses how exposing object communications through tests can help identify design problems and SOLID principle violations. He argues that mocks should be used as design tools rather than just for test isolation, and presents several case studies showing how proper mocking practices can lead to better software design.

Frank de Jonge, creator of Flysystem, discusses his journey with JavaScript and presents React.js as a solution for building better frontend applications. He explains how React's declarative UI approach, combined with the Flux architecture pattern, can help PHP developers create more maintainable JavaScript code while keeping their backend logic in Laravel/PHP. The talk covers how to structure React applications, handle state management, and integrate with Laravel APIs.

The talk discusses software development costs from three perspectives: cost of introduction (writing new code), cost of change (modifying existing code), and cost of ownership (maintaining code). The speaker emphasizes the importance of understanding these costs when deciding whether to write custom code or use existing packages/tools, and advocates for only taking ownership of code that truly needs to be owned and changed frequently.

A comprehensive talk about Laravel's IOC (Inversion of Control) Container, covering dependency injection, container bindings, and service providers. The speaker explains core IOC concepts through practical examples, demonstrates how to use the container effectively, and discusses advanced topics like circular dependencies and contextual binding.

The talk introduces the Lucid Architecture for Laravel applications, which is a pattern for organizing code in large-scale applications. The speaker explains how Lucid Architecture helps maintain clean code by organizing features, jobs, and services in a structured way. The architecture aims to solve common problems like legacy code, technical debt, and code organization while remaining performant and maintainable.

A talk about implementing Event Sourcing in Laravel applications, focusing on domain events and how they can be used to track changes in business-critical data. The speaker explains how Event Sourcing differs from traditional CRUD operations, demonstrates implementing domain events for a board game shop example, and discusses projections, read models, and handling application state changes over time.

The talk discusses database denormalization in Laravel applications, focusing on improving read performance while maintaining data integrity. The speaker explains how to use materialized views and event-driven updates to create denormalized data structures that can significantly improve query performance without sacrificing the benefits of normalized databases. The presentation includes practical examples of implementing denormalization using Laravel's eloquent ORM and queue system.

The speaker presents an innovative approach to software architecture inspired by Bruce Lee's martial arts philosophy, introducing 'Bruce Lee Driven Development' (BLDD). The talk draws parallels between Bruce Lee's adaptive martial arts style and software development, encouraging developers to focus on simplicity, directness, and efficiency. The speaker emphasizes the importance of understanding core problems, recognizing value, embracing change, and experimenting with different approaches rather than rigidly following established patterns.

The talk demystifies monads by explaining them as ordinary data types with specific operations and rules, similar to stacks and collections. The speaker uses practical examples in PHP/Laravel to show how monads are already being used (like Laravel's fluent syntax, JavaScript promises, and jQuery), and demonstrates how to implement basic monads like Maybe and Many to handle null checking and collections in a functional way.

This talk focuses on design patterns in Laravel, particularly exploring the Factory Pattern, Builder Pattern, Strategy Pattern and Provider Pattern. The speaker uses a pizza ordering system as a practical example to demonstrate how these patterns can work together to create maintainable, flexible code. The talk includes concrete examples of implementing these patterns in Laravel applications and explains how they can be used to extend framework functionality.

A detailed talk about extending and customizing Laravel by understanding its core components. The speaker demonstrates how to use the IoC container, service providers, and managers to modify framework behavior - including some examples of deliberately introducing bugs and unexpected behavior to show how deeply the framework can be customized. The talk emphasizes understanding Laravel's request lifecycle and proper handling of service resolution timing.

Taylor Donnici shares his experiences building enterprise applications with Laravel at Process Maker, discussing the evolution from legacy systems to modern Laravel architecture. He covers key aspects of enterprise development including security, testing, CI/CD pipelines, and asynchronous job processing. The talk includes a live demo of Process Maker's new Laravel-based workflow management system and highlights their open source contributions to the Laravel ecosystem.

Taylor Donnici shares his experiences building enterprise applications with Laravel at Process Maker, discussing the evolution from legacy systems to modern Laravel architecture. He covers key aspects of enterprise development including security, testing, CI/CD pipelines, and asynchronous job processing. The talk includes a live demo of Process Maker's new Laravel-based workflow management system and highlights their open source contributions to the Laravel ecosystem.

This talk discusses moving beyond basic CRUD operations in Laravel applications, focusing on better ways to structure code using domain-driven design principles. The speaker emphasizes using ubiquitous language that matches business requirements rather than database structures, separating read and write operations, and implementing more meaningful actions instead of simple CRUD operations. He shares examples from large-scale projects and demonstrates how to improve code organization using commands and events.

A deep dive into dependency injection containers in Laravel and PHP, explaining how they work under the hood. The speaker demystifies 'magic' concepts like auto-wiring by building a simple DI container from scratch and explaining the recursive nature of dependency resolution. The talk focuses on making complex concepts more approachable by showing how containers use reflection to automatically resolve dependencies.

This talk discusses software architecture principles, focusing on SOLID principles at the component level. The speaker explains how to design and organize components, manage dependencies between them, and ensure good architectural practices. Key concepts covered include component cohesion rules (REP, CCP, CRP), component coupling principles (ADP, SDP, SAP), and how to measure and maintain stability and abstractness in software architecture.

The speaker demonstrates how to refactor a complex Laravel/Livewire component handling mortgage calculations into smaller, more maintainable pieces using SOLID principles and good design practices. Through several refactoring steps, he shows how to extract business logic into services, use DTOs, implement interfaces, and write proper unit tests while maintaining functionality.

This talk covers modular monoliths as an architectural approach for Laravel applications. The speaker discusses how to organize code into modules while maintaining the benefits of a monolithic application, exploring concepts like boundary definition, inter-module communication through events, and data ownership. He contrasts this with both traditional monoliths and microservices, explaining how modular monoliths can provide a middle ground that offers better code organization and team independence while avoiding the complexity of distributed systems.

A talk about learning important development lessons from Laravel's design choices. The speaker discusses how Laravel's ordinary and obvious approach leads to better developer experience, using examples like routing conventions and facades. He emphasizes how sometimes breaking traditional programming rules can be beneficial when the gains in developer productivity outweigh the theoretical drawbacks.

Bobby Balman from Hospitable discusses strategies for maintaining and surviving large Laravel applications. He shares experiences from managing a large-scale Laravel application processing 51 million jobs daily, emphasizing the importance of consistent code structure, proper testing, and following Laravel defaults. The talk focuses on practical approaches to organizing code in domains/modules while keeping things simple and maintainable.

Tobias Petri discusses database scaling strategies in Laravel applications, focusing on the progression from single server to read replication to sharding. He emphasizes the importance of optimizing existing setups before moving to more complex solutions, warns about common pitfalls in each scaling approach, and explains how different scaling solutions fit different application needs. The talk includes practical examples using a hypothetical Laravel e-commerce platform selling conference tickets.

The speakers from Figured, a financial management tool for farmers, share their journey of scaling a Laravel application from a small startup to an enterprise-level solution used by major banks across multiple countries. They discuss how Laravel helped them maintain simplicity while handling complex financial data, and share insights about team growth, technical decisions, and maintaining code quality at scale.

The speaker presents a practical approach to implementing microservices architecture while avoiding common pitfalls by initially deploying as a monolith. He shares experiences from his time as CTO at Glo, describing how they structured their codebase into independent packages following domain-driven design principles, while maintaining the ability to later transition to true microservices. The talk focuses on achieving the benefits of microservices architecture (like loose coupling and clear boundaries) without immediately taking on all the operational complexity.

The talk discusses how to effectively model business requirements using Laravel's Eloquent ORM while following domain-driven design principles. The speaker demonstrates how to create clean, maintainable code by properly encapsulating business logic, using domain-specific language, and avoiding leaky abstractions. Using an award management system as an example, he shows how to evolve from simple CRUD operations to more complex domain models while keeping the code aligned with business terminology and requirements.

The talk discusses structuring large Laravel applications using domains and improving frontend interactions using TypeScript. The speaker shares examples from Flare, an exception tracking application, to demonstrate how to organize code into domains for better maintainability. They also cover authorization handling and type safety between backend and frontend using TypeScript.

Jason McCreary presents 10 tips for creating maintainable Laravel applications based on his experience with Shift and 20 years of programming. He covers topics ranging from staying current with Laravel versions to proper testing practices, emphasizing code readability and framework conventions. The talk focuses on practical approaches to improve application maintainability through proper structure, dependency management, and adherence to Laravel's design patterns.

This talk discusses approaches to securing data and communications in software-as-a-service applications, particularly focusing on end-to-end encryption, zero-knowledge systems, and practical ways to protect user data. The speaker uses a banking/financial data example to illustrate concepts around encrypting sensitive information while still maintaining service functionality. The talk concludes with practical advice for incrementally improving data security in applications.

Steven, the head of development at Figured, discusses how his company builds a modular monolith using Laravel and manages self-organizing development pods. He explains their approach to maintaining code consistency while giving development teams autonomy, their package-based architecture, and how they enable quick deployment cycles while maintaining code quality.

Josh Hanley, a core maintainer of Laravel Livewire, presents best practices for building maintainable Livewire applications. He covers various architectural approaches including page components, computed properties, form objects, and action classes. The talk focuses on code organization, naming conventions, and strategies to keep Livewire components clean and testable.

Daniel Kurn presents 'Verbs', a Laravel package for event sourcing that aims to make it more ergonomic and developer-friendly. Through live coding, he demonstrates how to refactor a job application system from using traditional status columns to an event-sourced approach, showing how this better captures business requirements and handles state transitions while making it easier to track history and implement features like notifications.

Josh Hanley presents a talk about building a common language between UI and database using actions, focusing on how Livewire and Verbs can work together. He demonstrates how to implement event sourcing in Laravel applications using the Verbs package, showing how to capture user actions as events and process them consistently throughout the application stack.