Laravel 11

Mastering the Speed of Command K The most immediate change in the relaunched Laravel Forge is the integration of a powerful command palette. Accessible via **Command K** or **Control K**, this interface transforms how you interact with your infrastructure. Instead of clicking through nested menus to find a specific site or server, you can simply type and jump. This isn't just about navigation; it’s a direct line to the documentation. By integrating **Ask Forge**, a specialized AI assistant, developers can query server-side concepts or specific Forge workflows without leaving the dashboard. It’s a workflow optimizer that keeps your hands on the keys and your focus on the code. Instant Staging with on-forge.com Domains Testing a new feature often requires a temporary home before it hits the production domain. Forge now provides custom **on-forge.com** domain names for every new site. When you spin up a repository, like the Chirper demo app, Forge generates a unique subdomain automatically. This eliminates the friction of configuring DNS or managing temporary records just to see your application live in a production-like environment. Bulletproof Zero Downtime Deployments Shipping code should never result in a blank screen for your users. The relaunch makes **zero downtime deployments** a standard, out-of-the-box feature for new sites. While your new code is being prepared, the existing version remains active. The handoff happens only once the new build is ready. This is particularly vital for high-traffic applications where even a few seconds of downtime can disrupt user sessions or data integrity. Proactive Monitoring and Health Checks The revamped **Observe** tab moves beyond basic server monitors. While tracking CPU and disk space remains a staple, the new UI introduces visual metrics for bandwidth and traffic spikes. More importantly, it introduces **heartbeats** for scheduled tasks. If a critical cron job, such as a YouTube scrape or data backup, fails to ping its designated URL within a set window, Forge alerts you immediately. Combined with post-deployment health checks that verify the **'\/up'** route introduced in Laravel 11, you get a comprehensive safety net for your production environment. Real-Time Collaboration via Laravel VPS The most ambitious addition is the Laravel VPS integration, which features a **shared terminal session**. This allows multiple team members to SSH into the same instance through the browser simultaneously. It’s a massive win for remote pair programming or collaborative debugging. Anything typed in one terminal is visible to teammates in real-time, effectively turning server maintenance into a multiplayer experience. It bridges the gap between isolated local development and the collaborative reality of modern DevOps.

2024 didn't just feel like another year in the Laravel ecosystem; it felt like a tectonic shift in how we approach web development. As the year winds down, reflecting on the sheer volume of shipping that occurred reveals a framework—and a community—that is no longer just content with being the best PHP option. Instead, it is actively competing for the title of the best overall web development experience on the planet. From the refinement of the core skeleton in Laravel 11 to the explosive growth of Filament and the birth of Inertia 2.0, the pieces of the puzzle are clicking into place with a satisfying snap. This isn't just about code; it's about the developer experience, the culture, and the tools that make us feel like true artisans. Let's look at the biggest milestones that defined this year and what they mean for the future of our craft. Rethinking the Skeleton: The Radical Simplicity of Laravel 11 When Laravel 11 dropped in early 2024, it brought with it a moment of collective breath-holding. The team decided to perform major surgery on the project's directory structure, aiming for a streamlined, "no-fluff" skeleton. For years, newcomers were greeted by a mountain of folders and files that, while powerful, often sat untouched in 95% of applications. Nuno Maduro and the core team recognized that this friction was a tax on the developer's mind. By moving middleware and exception handling configuration into the `bootstrap/app.php` file and making the `app/` directory significantly leaner, they redefined what it means to start a new project. This shift wasn't just about aesthetics. It was a functional bet on the idea that configuration should be centralized and that boilerplate belongs hidden unless you explicitly need to modify it. While some veterans were initially skeptical of the "gutted" feel, the consensus has shifted toward appreciation. The new structure forces you to be more intentional. When you need a scheduler or a custom middleware, you use a command to bring it to life, rather than stumbling over a file that's been there since day one. This "opt-in" complexity is a masterclass in software design, proving that Laravel can evolve without losing its soul or breaking the backward compatibility that businesses rely on. Inertia 2.0 and the JavaScript Marriage The release of Inertia 2.0 represents a maturation of the "modern monolith" approach. For a long time, the Laravel community felt split between the Livewire camp and the SPA camp. Inertia.js bridged that gap, but version 2.0 took it to a level where the lines between the backend and frontend are almost invisible. The introduction of deferred props and prefetching on hover changes the performance game for complex dashboards like Laravel Cloud. Nuno Maduro and the team dog-fooded these features while building the Cloud platform, realizing that a UI needs to feel "snappy" and immediate. When you hover over a link in an Inertia 2.0 app, the data for that next page can be fetched before you even click. This isn't just a parlor trick; it’s a fundamental improvement in perceived latency. Moreover, the ability to handle multiple asynchronous requests and cancel redundant ones puts Inertia on par with the most sophisticated JavaScript meta-frameworks, all while keeping the developer safely ensconced in their familiar Laravel routes and controllers. The Testing Renaissance: Pest 3 and Mutation Testing Testing has historically been the "vegetables" of the programming world—something we know we should do but often avoid. Pest 3 changed that narrative in 2024. Nuno Maduro pushed the boundaries of what a testing framework can do, moving beyond simple assertions into the realm of architectural testing and mutation testing. Mutation testing is particularly revolutionary for the average developer. It doesn't just tell you if your tests pass; it tells you if your tests are actually *good*. By intentionally introducing bugs (mutations) into your code and seeing if your tests catch them, Pest 3 exposes the false sense of security that high code coverage often provides. This level of rigor was previously reserved for academics or high-stakes systems, but Nuno made it accessible with a single flag. Coupled with architectural presets that ensure your controllers stay thin and your models stay where they belong, Pest has transformed testing from a chore into a competitive advantage. Filament and the Death of the Boring Admin Panel If 2024 belonged to any community-led project, it was Filament. The "rise of Filament" isn't just about a tool; it's about the democratization of high-end UI design. Developers who lack the time or inclination to master Tailwind CSS can now build admin panels and SaaS dashboards that look like they were designed by a Tier-1 agency. The core strength of Filament lies in its "Panel Builder" philosophy. It isn't just a CRUD generator; it’s a collection of highly typed, composable components that handle everything from complex form logic to real-time notifications via Livewire. Josh Cirre and others have noted how Filament has fundamentally changed the economics of building a SaaS. What used to take weeks of frontend labor now takes hours. The community surrounding Filament has exploded, with hundreds of plugins and a contributors' list that rivals major open-source projects. It proves that the Laravel ecosystem is a fertile ground where a well-designed tool can gain massive traction almost overnight, provided it respects the "Artisan" ethos of clean code and excellent documentation. Observability and the Nightwatch Horizon As we look toward 2025, the buzz surrounding Nightwatch is impossible to ignore. Building on the foundation of Laravel Pulse, Nightwatch aims to bring professional-grade observability to the masses. The team, including Jess Archer and Tim MacDonald, is tackling the massive data ingestion challenges associated with monitoring high-traffic applications. By leveraging ClickHouse, the Nightwatch team is creating a system that can track specific user behaviors—like who is hitting the API the hardest or which specific queries are slowing down a single user's experience. This level of granularity changes the developer's mindset from "I hope the server is okay" to "I know exactly why this specific user is experiencing lag." It's the final piece of the professional devops puzzle for Laravel shops, moving observability from a third-party luxury to a first-party standard. Breaking the Barrier: The First-Party VS Code Extension For a long time, the Laravel experience was slightly fragmented depending on your editor. PHPStorm with the Laravel Idea plugin was the undisputed king, but it came at a cost. In 2024, the release of the official Laravel VS Code Extension changed the math for thousands of developers. Created by Joe Dixon, this extension brings intelligent route completion, blade view creation, and sophisticated static analysis to the world's most popular free editor. This move was about lowering the barrier to entry. If you're a JavaScript developer curious about PHP, you shouldn't have to learn a new IDE just to be productive. The massive adoption—over 10,000 installs in the first few hours—underscores the demand for high-quality, free tooling. It's a move that ensures Laravel remains the most welcoming ecosystem for the next generation of coders. Conclusion: The Road to 2025 As we look back on Laracon US in Dallas and the impending arrival of PHP 8.4, it's clear that Laravel is in its prime. We are no longer just a framework; we are a complete platform that handles everything from the first line of code to the final deployment on Laravel Cloud. The momentum is undeniable. Whether you're excited about property hooks in PHP 8.4 or the new starter kits coming in Laravel 12, there has never been a better time to be a web developer. The tools are sharper, the community is bigger, and the future is bright. Stay curious, keep shipping, and we'll see you in the new year.

Overview Fetching the same data multiple times within a single request is a common performance bottleneck. Whether you are retrieving a user profile for the header, a sidebar, and a footer, or fetching a list of featured items, redundant database queries waste resources. The `once` helper in Laravel provides an elegant solution for in-memory memoization. It ensures that a given callback is executed exactly once during the lifecycle of a request, returning the cached result for all subsequent calls. Prerequisites To follow this tutorial, you should have a baseline understanding of PHP and the Laravel framework. Familiarity with anonymous functions (closures) and static methods will help you grasp the implementation details. You will need Laravel 11 or higher to use this as a built-in feature. Key Libraries & Tools * **Laravel Framework**: The primary PHP framework providing the helper. * **Spatie once**: The original package that inspired this native implementation. * **Tinkerwell**: An excellent code runner for testing Laravel snippets in real-time. Code Walkthrough Suppose we have a `Podcast` model with a static method that fetches featured shows via an action class. Without optimization, every call triggers a new query. ```python // Before: Every call hits the database public static function featured() { return (new GetFeaturedPodcastsAction)->execute(); } ``` To optimize this, wrap the logic in the `once` helper. The helper accepts a `callable` and stores the result based on the calling context. ```python // After: Optimized with the once helper public static function featured() { return once(fn () => (new GetFeaturedPodcastsAction)->execute()); } ``` When the application executes this code three times in one request, Laravel runs the inner logic on the first attempt, caches the return value, and serves that cached value for calls two and three. This eliminates redundant database overhead instantly. Syntax Notes The `once` helper uses the object instance or class and the method name to create a unique cache key. It relies on a closure (`fn () => ...`) to encapsulate the logic you want to memoize. This pattern is much cleaner than manually checking if a property is null before assigning a value. Tips & Gotchas Remember that `once` only persists for the duration of the current HTTP request. If you need to store data across multiple requests or for hours at a time, you must use Laravel's standard `Cache` facade. Additionally, be mindful of state; if the underlying data changes mid-request, `once` will still return the original result until the request ends.