![php[architect] logo](/wp-content/themes/phpa/images/new_logo_mark_nav.png){kind=logo}
Joe Ferguson
Joe Ferguson is a PHP developer and community organizer. He is involved with many different technology related initiatives in Memphis including the Memphis PHP User group. He’s been married to his extremely supportive and amazing wife for a really long time and she turned him into a crazy cat man. They live in the Memphis suburbs with their two cats.
Mastodon: https://phpc.social/@joepferguson
twitter: @JoePFerguson
Articles
Rector Refactoring
By Joe Ferguson
This month we’re covering the use of Rector, a tool for automatic code refactoring in PHP. We’ll explain how to configure and use Rector to improve code quality, remove dead code, and enforce coding style. We’ll also cover examples of how Rector can be used to refactor code in a real-world application, Snipe-IT.
by Joe Ferguson
Published in Packing Up PHP, August 2023
The Workshop: PostgreSQL
By Joe Ferguson
Last month we covered Databases as a Service and glossed over the
fact that MySQL and PostgreSQL are the commonly found relational
database management systems (DBMS) across providers. While MySQL is
often the default for most PHP developers, this month, we will dive into
PostgreSQL and get a PHP application up and running. by Joe
Ferguson
Published in Be Barrier Free, July 2023
The Workshop: Databases as a Service
By Joe Ferguson
Whether you’re working on a legacy project or scaling up a modern
application, one popular way would be migrating the database to a
Database as a Service (DBaaS). These services can provide great benefits
to teams that may not have a dedicated database administrator by
offloading the database service to a managed host. This month we will
explore the DBaaS cloud landscape and take a test drive through
migrating an application to a DBaaS host. by Joe Ferguson
Published in Evolving PHP, June 2023
The Workshop: The Workshop: Minicli
By Joe Ferguson
Should you use Minicli? It’s definitely worth a look. Let’s review
what is has to offer. by Joe Ferguson
Published in HTTP Burritos, May 2023
The Workshop: Upgrading with Reckless Abandon: Part Two
By Joe Ferguson
This upgrade process is not for the faint of heart, nor is it for those who spend hours meticulously curating their commits and merges. We’re intentionally being reckless because we’re confident that our tests cover enough of our code to know when a problem will arise. by Joe Ferguson
Published in Knowledge Crunching, February 2023
The Workshop: Upgrading with Reckless Abandon Part One
By Joe Ferguson
This month we’ll dive into upgrading a PHP 7.1 application originally built with the Laravel framework version 5.6 with reckless abandon. The only way this kind of upgrade can succeed is with a robust suite of tests. Tests allow us to leap major versions of our framework and dependencies and even PHP versions in some cases. Without a strong test suite, we couldn’t possibly have the confidence to jump versions without thoroughly testing each change manually. If you’d like to jump versions for your projects, ensure you start by writing as many tests as it takes to provide confidence in major structural changes. by Joe Ferguson
Published in PHP is Standing Tall, January 2023
The Workshop: Get A Blog!
By Joe Ferguson
This month we’re going back to the early days before Discord and Slack, to when we shared our knowledge through ancient tomes known as Blogs. Most developers have a blog, even if they never published it. by Joe Ferguson
Published in Owning The Web, December 2022
The Workshop: Local Dev with Lando
By Joe Ferguson
This month we’re going to visit a topic near and dear to my heart: local development environments. I’ve been maintaining Laravel Homestead since late 2016. I have been a longtime tinkerer of just about every local development tool you’ve ever heard of, and they all have their strengths and weaknesses. Lando is just about the only tool I haven’t had a chance to dive into, so join me in this dive into the world of local development with Lando.dev. by Joe Ferguson
Published in The Value of the AST, November 2022
The Workshop: Cheating at SPA with Breeze & Inertia
By Joe Ferguson
This month we’re diving into a fresh Laravel application using the Breeze package to scaffold our authentication using Inertia and Vue.js. No previous Vue experience is required! We’re exploring the ability to quickly build modern single-page applications with Inertia leveraging Vue.js components to build our application. If you previously used Laravel’s make auth commands, you’ll find Breeze to be an updated and modern implementation of user registration, password reset, and functionality using Vue.js and Inertia by default. React is also supported if you would rather use it over Vue. by Joe Ferguson
Published in The State of PHP, October 2022
The Workshop: Making Things Happen
By Joe Ferguson
This month we’re straying slightly from our usual PHP tooling to cover Make and how we can leverage it to simplify our lives as developers. by Joe Ferguson
Published in Making Code, September 2022
The Workshop: Blueprinting our Application
By Joe Ferguson
This month we’re exploring a programming concept known as Scaffolding. Scaffolding is the process of using an application to generate code based on some input or configuration file. Just as construction workers raise temporary structures to help perform their work, we can expect similarly. Automatically generating code is a wonderful idea but questions always arise with “how good is the code?” by Joe Ferguson
Published in PHP Blueprint, August 2022
The Workshop: PHP from Virtual Machine to Compose
By Joe Ferguson
Containers are here to stay, and if you’ve been putting off learning how to migrate a PHP application from a VM to containers, we have you covered this month as we migrate a long-standing Laravel application from running on Linux via Apache and MariaDB. Our application also utilizes Redis for caching, so we need to include this in our container plan. by Joe Ferguson
Published in Database Freedom, July 2022
The Workshop: A Night With Symfony
By Joe Ferguson
Symfony is one of the stalwarts of modern PHP, dating back to 2005. Symfony has continued to evolve into a framework of components focused on building web applications using decoupled and reusable components. Their philosophy of embracing professionalism, best practices, standards, and interoperability of applications is an exciting statement. Backing up that statement is years of open source community contribution and cooperation among the Symfony team, open-source contributors, partners, and enterprise developers. This month we’re diving into Symfony 6 with a tour of the ecosystem and building our own demo application.
Published in Another Bright Idea, June 2022
The Workshop: Acceptance Testing with Codeception
By Joe Ferguson
Acceptance testing is my favorite tool to reach for when working with legacy applications that may have low test quality or no tests at all. Because acceptance testing approaches the application from outside of the source code, we’re able to greatly increase test coverage without having to touch the application’s code itself. Larger teams can use acceptance tests to prove new features behave as expected. For the single developer that knows they should be writing tests but still doesn’t for whatever reason: acceptance testing can help them jump-start their application’s test suite.
Published in Testing The Core, April 2022
The Workshop: Queues with Horizon
By Joe Ferguson
In the January 2022 edition, my friend Chris Tankersley wrote Education Station: [Background Queues](https://phpa.me/background-queues), a fantastic primer for using background queues, or workers with your PHP application. This month we will implement [Laravel Horizon](https://laravel.com/docs/8.x/horizon), a dashboard monitor for your Redis queues.
Published in World Backup Day, March 2022
The Workshop: Configuring PHP-FPM & Apache
By Joe Ferguson
Last month we covered PHP and Apache and demonstrated how to get started with our custom virtual host in Apache and execute PHP via the libapache2-mod-php (mod-php) library. This month we will replace our use of mod-php with the Fast CGI Process Manager (FPM). Instead of bundling a PHP worker process in Apache, we’ll use FPM as another running service that will execute PHP. The requests are normally handled by Apache but instead of using mod-php, we’ll configure our virtual hosts to pass requests into the FPM service which will execute our PHP code and return the response to the Apache web server. One of the biggest benefits of using FPM with Apache is the ability to serve multiple PHP versions via the web server, which is not possible when using mod-php. by Joe Ferguson
Published in Parallelize Your Code, February 2022
The Workshop: Apache and PHP – Back to Basics
By Joe Ferguson
This month we’re diving into Apache and PHP configuration to better understand the relationship between the web (HTTP) server and our application. When getting started with PHP, it’s quite common for tutorials and guides to skip over the webserver and focus more on the language aspects. PHP developers need to have a strong understanding of how the webserver executes their code. As requests and responses being handled by a server are the primary purpose of web applications. We’re going to install Apache, PHP, and review configuration for ensuring our application not only functions well but leverages Virtual Hosts to serve multiple applications. by Joe Ferguson
Published in Domain-Driven Resolutions, January 2022
The Workshop: Octane & Roadrunner
By Joe Ferguson
Laravel Octane is a package that leverages another application server that loads the entire application once and keeps the application in memory throughout multiple requests, which can dramatically increase response times in applications by removing the load time for bootstrapping Laravel and all of the dependencies. by Joe Ferguson
Published in The Zen of Mindful Programming, December 2021
The Workshop: Intro to Craft CMS
By Joe Ferguson
Last month we covered Nitro, a local development environment that came out of the Craft CMS community. This month we’re going to dive into Craft CMS and demonstrate getting started with a basic project. by Joe Ferguson
Published in The Art of Data, November 2021
The Workshop: Nitro
By Joe Ferguson
Nitro is a command-line tool for managing Docker-based PHP development environments. Like most development environments, Nitro provides several defaults to improve the developer experience of using Docker. A primary focus of Nitro is “Simplicity matters,” meaning the developer should be focused on building their project, not getting bogged down in the DevOps swamps. If you avoid local container development environments because you don’t care about DevOps, Nitro is a great place to start your container experience.
Published in Decrypting Cryptography, October 2021
The Workshop: Laravel Livewire
By Joe Ferguson
Laravel Livewire describes itself as a “..full-stack framework for Laravel that makes building dynamic interfaces simple, without leaving the comfort of Laravel.” As a developer who has always struggled to feel comfortable with the latest and greatest front-end tooling, “without leaving Laravel” is incredibly appealing.
Published in It’s Really an Upgrade, September 2021
The Workshop: Testing with Pest Framework
By Joe Ferguson
Pest is a PHP testing framework focused on simplicity and brings a powerful expectations API to PHP. Pest is influenced by Jest, a JavaScript testing framework. Pest was created by Nuno Maduro originally via Sponsorware license and ultimately was published under the MIT open source license. You can think of Pest ha an alternative to other testing frameworks, such as Codeception, which can coexist with your existing PHPUnit tests.
Published in Trimming One’s Sails, August 2021
The Workshop: Installing Rocky Linux
By Joe Ferguson
If you use CentOS as the L in your LAMP stack, you may be wondering what to do after Red Hat’s announcement. Let’s look at a new community distro that aims to provide a replacement for CentOS.
Published in Deep Dive Into Search, July 2021
The Workshop: Docker Swarm
By Joe Ferguson
Docker Swarm is a mode in which Docker deploys container services across a cluster. Spreading a service across multiple swarm nodes (systems running Docker joined to the same swarm cluster) allows us to perform load balancing and rolling updates to our application. We also can easily horizontally scale by adding more nodes and scaling services up. Previously when we’ve worked with Docker Compose files, we’ve declared services made up of containers and their operational parameters; we can deploy these same compose files as a “stack” in swarm mode. Our goal this month is to cover how to build container images for our application and orchestrate the services required to support our app in a testing or staging environment.
Published in Debug, Rinse, Repeat, June 2021
The Workshop: New OS, Old PHP
By Joe Ferguson
We continue our containerization journey from last month where we covered how to refactor an application that created PDF files to use S3 to store the documents instead of relying on the local server’s storage. Another challenge often found is when an application uses outdated PHP and runs on an unsupported/outdated operating system version. What happens if you find yourself in the scenario where your current operating system is reaching the end of life (EOL) while the new LTS doesn’t support your current PHP version? What happens if you weren’t able to keep up with PHP’s release cadence? The good news, we can use containers to bundle our application with our old PHP version, which we can run on newer operating system versions.
Published in Testing Assumptions, May 2021
The Workshop: Refactoring to an Object Store
By Joe Ferguson
Welcome to the third installment of our containerization journey. Last month we covered running our application locally in Docker containers replacing our pre-existing development virtual machine. We used Laravel Sail to scaffold our development environment with Docker Compose. This month we’re going to look at a real-world application running on a traditional Linux Virtual Private Server with PHP 7.4, MySQL, Redis, and Apache. Before we can dive too far into containers, we need to get a looming task out of the way.
Published in Busy Worker Bees, April 2021
The Workshop: Using Sail to Understand Local Development with Docker
By Joe Ferguson
Welcome to the second installment of our containerization journey ast month. We covered container basics, Docker installation, and running command line PHP images. This month we’re focused on building our local development environment with Docker coming from an existing Vagrant virtual machine configuration. We’re not jumping directly into overly complicated build targets and multistage builds just yet. Our goal is to run our application locally in Docker containers to replace our existing development virtual machine. Doing so will give us a better understanding of how each service container fits and work together.
Published in Lambda PHP, March 2021
The Workshop: Just Use Docker
By Joe Ferguson
If you’ve been putting off learning how to use Docker in your PHP projects, here is your chance: we’re going to start from scratch, and we’re going to cover a lot of ground to take a PHP application from running locally to running in containers, then a cluster, and ultimately in Kubernetes. Let’s get settled in and ready to figure out how all of these container tools work and can improve your quality of life as a developer by streamlining your workflow and building robust, fault-tolerant applications that can run in any supported container ecosystem.
Published in Dealing with Data, February 2021
The Workshop: S3 Storage with MinIO
By Joe Ferguson
This month, we’re diving into running our own S3 compatible open-source server via the open-source project MinIO. We’ll configure MinIO alongside our local development environment to quickly replicate our application’s integration with S3 object storage without operating on “production” storage buckets or having to set up “dev” buckets.
Published in Newfangled Views, January 2021
The Workshop: Git Hooks with CaptainHook
By Joe Ferguson
Git Hooks are executable server-side or client-side scripts that run when specific Git events happen, such as creating commits or checking out branches. Server-side hooks are useful for Git administrators to enforce specific policies and can run before or after pushes to the server. We’re going to focus on client-side Git Hooks, and how we can leverage them to perform routine tasks for us automatically during the Git workflow we’re already using.
Published in PHP 8 Bits and Git, December 2020
The Workshop: GUI Applications in WSL with X Server
By Joe Ferguson
We’ve spent the past few months discussing and demonstrating how to use WSL in your PHP development workflow as a better alternative to Virtual Machines by running native Linux on Windows 10. This month we’re going to dive into an unsupported (by Microsoft) territory and cover how to and why we may run GUI applications in WSL distributions.
Published in SOLID Foundations, November 2020
The Workshop: PHP Development with Homestead in WSL
By Joe Ferguson
We’ve spent the past two months talking about Windows Subsystem for Linux (WSL) in Windows 10 and how to customize it to serve as a PHP development environment. While functional, our environment lacked a fair bit of polish. In the nearly four years that I’ve been working on and maintaining Laravel Homestead, I’ve spent much of that time adding functionality and polish to the Laravel focused Vagrant development environment. Homestead is a fantastic PHP development environment that provides many tools PHP developers have come to expect: NGINX and Apache support, easy access to multiple PHP versions, MySQL and PostgreSQL databases, and an easy “reset” method in case something goes wrong you can quickly get back to a known state. This month we’re going to explore the ongoing Homestead development to bring some of the polish and ease of use from Homestead to WSL.
Published in Running Parallel, October 2020
The Workshop: Mail, Ngrok, and Xdebug in WSL
By Joe Ferguson
Last month we covered Windows Subsystem for Linux and this month we’re continuing the journey by demonstrating how to further work with our WSL distribution using tools such as Mailhog, Xdebug with PhpStorm and Visual Studio Code, and ngrok.
Published in Under the Scope, September 2020
The Workshop: PHP Development With Windows Subsystem for Linux
By Joe Ferguson
Does a recent announcement by Microsoft have you wondering how you’ll continue to use Windows for PHP development? Anyone with a compiler and the PHP source code should be able to build a PHP executable for Windows. If the thought of compiling your PHP binary on Windows seems daunting, have no fear! We’re going to install native Ubuntu PHP packages on Windows!
Published in Data Discipline, August 2020
The Workshop: Twig, Bulma, and CodeIgniter 4
By Joe Ferguson
Last month, we covered getting started with a brand new CodeIgniter 4 project and explored the framework. We explained installation, routing, controllers, and built some models and migration to exercise the basics of working with a database. This month we’re focusing on the frontend of our CodeIgniter 4 example project by implementing a PHP template engine and the Bulma CSS framework.
Published in Warp Driven Development, July 2020
The Workshop: Blasting Off with CodeIgniter 4
By Joe Ferguson
Fourteen years after its first public release and six years after transitioning ownership from EllisLab to British Columbia Institute of Technology CodeIgniter (CI) has released major version 4. It continues to deliver a framework with a small footprint without having to learn a lot of framework vendor-specific functionality. CodeIgniter has always prided itself on clear, thorough documentation and favoring simple solutions over complexity.
Published in Advanced Design & Development, June 2020
The Workshop: Specification BDD with Phpspec
By Joe Ferguson
phpspec is a package which allows us to use Behavior-Driven Development, BDD, which comes from Test-Driven Development, TDD. When applying BDD, we write our tests first and then only enough code to pass our tests and then refactor and verify the tests still pass exactly as we would with TDD. This cycle continues and is often referred to as red-green development of writing tests that fail and enough code to make them pass, then restarting the process.
Published in Unsupervised Learning, May 2020
The Workshop: Easy CLI PHP with Symfony Console 5
By Joe Ferguson
Writing console commands with PHP is something I have always taken for granted. I started my career having learned Linux and command line server configuration and was very comfortable writing small applications with BASH scripts, Python, and even dabbling in C and Microsoft Qbasic. These commands copied files to a backup location, process batched data records in CSV, XML, and various other formats. By the time I discovered PHP, the community had just seen early builds of PHP 5, and the entire ecosystem was in for a shock. Once comfortable with PHP, I began writing small CLI commands in PHP instead of Python (or BASH). It was quite liberating to flex the same language for both web and command line applications.
Published in Machine Learning and OpenAPI, April 2020
The Workshop: Managing LAMP with Virtualmin
By Joe Ferguson
Virtualmin is a web hosting and cloud computing control panel. A hosting control panel is a web-based application that runs on a server and manages all the aspects of a hosting account. This includes account information, websites, web servers, databases, mail servers, and all the other services which ultimately work together to allow you to run your application. The value Virtualmin provides is the ability to run my servers while striking a balance between wanting to control the server without having to perform tedious tasks manually. It handles operations like writing virtual host configurations, creating database users and managing permissions, and also managing system users
Published in How Magento is Evolving, March 2020
The Workshop: GitHub Actions for Continuous Integration
By Joe Ferguson
Continuous Integration (CI), or the ongoing process of integrating changes in a shared version control repository, should be a goal of every project you work on. This month, we’re going to dive into configuring GitHub Actions to build and test our PHP application. Then we’ll look at a larger scale API, which also uses GitHub Actions for Continuous Integration. by Joe Ferguson
Published in Cultivating the Developer Experience, February 2020 —Available for Free
The Workshop: Ansible In Practice
By Joe Ferguson
This month, we’re going to dive into a practical application of Ansible by building a playbook with roles to implement a fully functional Linux, MySQL, PHP, and NGINX web server. By the end, you should be able to take the playbook we build together and extend it to suit your requirements.
Published in New Habits, January 2020
The Workshop: System Management with Ansible
By Joe Ferguson
Ansible is an open-source IT automation tool used for configuring systems and deploying applications. Red Hat supports Ansible in the enterprise by offering support contracts and funding employees who contribute. Ansible communicates over SSH, so there is no need to install any extra software (such as PHP, Apache, NGINX, Redis, and others) on the remote systems. Ansible allows us to version control our infrastructure in YAML files and supports Jinja templates allowing flexibility in the configuration of services and applications. This month we’re going to review Ansible’s core concepts and start building our first playbook to begin our transition to infrastructure as code
Published in Expedition PHP, December 2019
The Workshop: What’s New in PHP 7.4
By Joe Ferguson
PHP 7.4 brings typed properties, arrow functions, coalesce assignment operators, and more. PHP 7.4.0RC4 was released on October 17th. There’s still plenty of time as the current planned date for general availability of 7.4 is November 28th, 2019, according to the PHP 7.4 timetable.
Published in Object Orientation, November 2019 —Available for Free
The Workshop: What’s New in Laravel 6
By Joe Ferguson
September 2019 marks the release of the latest major version of Laravel: 6.0. Laravel 6 is also the new LTS (long term support) version of the framework. We’ll cover what’s new and different in version 6 and learn about the brand new error handling package: Ignition. One notable change is the requirement of PHP 7.2 as a minimum supported version.
Published in Coding Without Fear, October 2019
The Workshop: Real World PDF Generation
By Joe Ferguson
Last month we covered the basics of PDF generation by focusing on the FPDF library. We generated a custom PDF by placing cells on the page and adding data to those cells. FPDF is a relatively low-level library in comparison to modern libraries which may do more heavy lifting for you. This month, we’re exploring methods to take your existing views and use a browser engine to turn HTML and CSS into a PDF.
Published in Master of Puppets, September 2019
The Workshop: Introduction to PDF Generation
By Joe Ferguson
Despite the promise of a “paperless” office, we still need to create documents that print and render nearly-identically across devices and operating systems. PDFs have filled this niche nicely for end-users, but if you need to generate PDFs with PHP programmatically, the options are overwhelming. How do you choose? In this series, we’ll investigate the solutions at our disposal and the pros and cons of each.
Published in Renovating Applications with Symfony, August 2019 —Available for Free
The Workshop: Run Amazon Linux Locally
By Joe Ferguson
This month we focus on running Amazon Linux on your local development machine via Vagrant. While you could spin up resources in EC2 and go to town, maybe you’re not quite ready to jump into the deep end. Perhaps you want to test your application in a controlled environment to see how it performs on Amazon Linux. Possibly you’re new to AWS and don’t want to burn through all of your free credits. These are all great reasons to spend some time creating your local instance for testing your application.
Published in Find the Way With Elasticsearch, July 2019
The Workshop: The Road to 7.3, Part Two
By Joe Ferguson
Last month we explored the world of static analyzers Phan and PHPStan to find compatibility issues and several other common issues in our PHP Easy Math code base. This month, we’re going to review our code base and implement new and recent features from PHP 7.x
Published in Out on a Limb – February 2019, February 2019
The Workshop: Producing Packages, Part Three
By Joe Ferguson
Over the past two months we’ve been building PHP Easy Math a purposely simple example library to demonstrate how to build a reusable package for the PHP ecosystem. Make sure to check the previous issues if you’re just now joining us! This article is the third and final installment in this series. We’re going to cover triaging and managing issues users may open as well as pull requests to your library.
Published in Better Practice – December 2018, December 2018
The Workshop: Producing Packages, Part Two
By Joe Ferguson
Last month we started building PHP Easy Math, a small library which can be included in PHP projects to provide simple methods to do basic addition and subtraction. We’re using this as an example library to focus on what makes a library “good” we are less worried about the practical need for and usage of our package. In this part, we look at why you should provide a license and good documentation for your package.
Published in Generics and Project Success – November 2018, November 2018
Artisinal: Producing Packages, Part One
By Joe Ferguson
PHP developers can now easily share their code for others to use. You can also easily bundle your application’s domain logic into a package to share between multiple projects. This month we are diving into creating PHP packages and ensuring our packages are held to a high standard of having tests, license information, and other best practices for creating and maintaining high-quality PHP packages.
Published in Internal Journeys – October 2018, October 2018
The Workshop: Describe Your Tests with Kahlan
By Joe Ferguson
This month we’re covering a full-featured unit and Behavior-Driven Development (BDD) test framework named Kahlan. Kahlan is similar to RSpec (Ruby) and JSpec (Java) using BDD style syntax where you describe the behavior your application should have.
Published in Magniphpicent 7.3 – September 2018, September 2018
The Workshop: Make PhpStorm Work for You
By Joe Ferguson
This month we’re going to dive into PhpStorm and cover configuration from personal preferences to obeying standards and day to day usage. We’ll see how to use the features of an IDE to improve your productivity and the quality of your code.
Published in Masterful Code Management – August 2018, August 2018
The Workshop: CakePHP, Part Two
By Joe Ferguson
Last month we covered the basics of CakePHP and how to get started creating routes, controllers, database tables, and retrieving data. This month we’re going to dive into returning HTML views, as well as creating and validating forms to create new widgets.
Published in Navigating State – July 2018, July 2018
The Workshop: CakePHP, Part One
By Joe Ferguson
Welcome to the first installment of The Workshop, a column where we try out new tools and techniques to hone our craft. We’ll be covering frameworks, packages, tools, and exploring topics related to the PHP development ecosystem. This month we’re going to jump into CakePHP. CakePHP has recently released version 3.6 of their full stack framework.
Published in Command and Control – June 2018, June 2018
Artisanal: Odds and Ends
By Joe Ferguson
This month I’m running with a collection of odds and ends of Laravel which I feel strongly about or that answer some common questions about Laravel and the related ecosystem. I find these issues to be common among people who ask me about Laravel on social media or in person at conferences or user group meetups.
Published in Treasure, Old & New – May 2018, May 2018
Artisinal: Authentication with Laravel
By Joe Ferguson
Authentication is the foundation of your application’s security. Authentication separates guests from users and restricts functionality in your application to authenticated users. We can also take authentication a step further and completely offload the grunt work to some other service such a GitHub, Google, or any other third party authentication service provider.
Published in Testing in Practice – April 2018, April 2018
Illuminating Lumen
By Joe Ferguson
Lumen is a microframework from the creator of Laravel advertised as “Decidedly Laravel. Delightfully Minimal.” If you are looking at taking your first dive into building an API or microservice, Lumen is a welcome starting point for those already familiar with Laravel.
Published in Long Running PHP, March 2018
Artisanal: Full-Text Searching with Scout
By Joe Ferguson
Laravel Scout is a package that makes adding full-text searching of your Eloquent models simple. Scout is driver based, which means you will need to use a driver for the data source you’ll be searching. Scout ships with the Algolia driver out of the box. While Algolia is a fine solution offering a free tier and reasonable rates, what if you aren’t ready for such a level of commitment? We’re going to cover installing and configuring Laravel Scout and utilizing a community supported MySQL driver so you can test drive Scout in your application before making the leap to Algolia (or another driver).
Published in Know Your Tools, February 2018
Artisanal: Using Data Collections
By Joe Ferguson
Every application you work on will have some way to deal with a data set and take the form of arrays. If you have a more modern application, you may have a class which represents a data set with specific attributes and helper methods. Laravel is no different and takes the entire idea of a data set to the next level by using Collections.
Published in Setting Up to Succeed, January 2018
Artisinal: Queue Monitoring
By Joe Ferguson
Laravel Horizon is a beautiful and code driven configured dashboard for your Redis queues. You can easily monitor throughput, job run times, as well as job failures. Horizon utilizes asynchronous process signals which means your project should be on PHP 7.1 or higher. You _are_ running PHP 7.1, right? Horizon keeps your worker configuration in one simple file, so it’s easy to share with your coworkers or teammates via version control.
Published in Talking Code, December 2017
