PHP & Web Development Blogs

Halloween is filled with ghouls, ghosts, zombies and lots of other spookiness, but the scariest thing ever is FOMO. It’s conference season and several have their call for papers out (including us at Nomad PHP :D). This is the perfect time for you to share your knowledge with the community. Whether it’s your first time or 100th time - it can be scary to put yourself out there and do a talk, but worse than that is not taking the chance and submitting your talk and doing the presentation. Plus, many of these events host lightning talks (short 5-15 minute talks) - meaning you can test out your talk risk free ;)

So here is your chance - submit for one or submit for all of them. May the odds be ever in your favor!

Fosdem 2019

First we have Fosdem 2019 which will take place on February 2 & 3 in Brussels,Belgium. Some facts about this call for papers:
*Deadline: November 3, 2018
* Presentations are expected to be 50 minutes long (including audience questions) and should cater to a varied technical audience. For examples check out youtube.
*Submit your proposals via Pentabarf: https://fosdem.org/submit.
* The conference covers reasonable travel expenses agreed upon in advance as well as arranges accommodations

Midwest PHP 2019

Next up we have Midwest PHP which will take place on March 8 & 9 in Bloomington, Minnesota.
*Deadline: November 15, 2018
* There is a speaker package included (conference pass, 2 hotel nights, airfare/travel - $500 max, lunch, etc.)
* Make sure the talk title and abstract define the exact topic and what you hope people will learn from it.
* Recommended to submit more than one talk because it can increase your chances of one of them being picked.
*Submit your talk here: [https://cfp.midwestphp.org/] (https://cfp.midwestphp.org/)

Longhorn PHP

Next we have Longhorn PHP which will take place on May 2 (tutorial day) then MAy 3 &4 (conference) in Austin, Texas.
*Deadline: December 15, 2018
* For all speakers, you'll get a full conference pass (tutorial day and main conference days), including access to lunch, after-parties, and any other activities included in the conference.
* For speakers remote to the Austin area, we'll provide 3 nights at the speaker hotel (4 nights if presenting a talk and a tutorial) near the conference venue.
* For speakers outside Texas, we'll book you an Economy or equivalent round-trip airfare on a flight into Austin we'd be comfortable taking ourselves (we're conference speakers too!). Plus, we'll arrange transportation between the Austin airport and the speaker hotel.
* Three different session lengths: 3 hour tutorials, 60 minute talks, and 30 minute talks.
* It doesn't have to just be a PHP related talk. For more information on talks click here.
*Submit your talk here: https://cfp.longhornphp.com/.

Laravel Live India 2019

Then we have LaravelLive India 2019 in Mumbai, India.
*Deadline: December 31, 2018
* Talk length is 30 minutes - Q&A up to the presenters discretion but would be included in the 30 minute time limit.
* Talks will be recorded and distributed for free as well as the presentation slides.
* Looking for a range of talks from PHP (security, testing and frameworks), web development, HTML5, JavaScript, mobile development, emerging technologies and non-technical proposals that will appeal to developers.
*Talk guidelines: Objective with clear expectation for audience, short and to the point description, mention of employer is only allowed at the beginning of the content and background image/wallpaper shouldn’t include company name/logos.
*Submit your talk here: [https://www.papercall.io/laravellive-india] (https://www.papercall.io/laravellive-india)

Nomad PHP

(you know you want to)

Last but not least - this is an ongoing call for papers. This is perfect if you want to present from the comfort of your office, home or really wherever you are. It’s via RingCentral meetings and will be live and recorded. This is for none other than Nomad PHP.
*Deadline: Anytime :D
* Talk length: 45 - 60 minutes.
* Talks should be unique to Nomad PHP and not available in video format online.
* Talk should not be recorded or made available elsewhere online for at least 3 months following your talk.
* The talk will be featured on our page and promoted via social media.
* Speakers will receive a financial stipend.
* Upon being selected we will reach out with further details.
*Submit here: [https://www.papercall.io/nomadphp] (https://www.papercall.io/nomadphp)
Now that you have some information - it’s the perfect time to take it all in and get started on your talk proposals :)! Looking forward to seeing all the amazing talks that will be coming out!!!

At Nomad PHP our goal is to empower developers in building a habit of continuous learning - and that means we have a habit of continuous improvement ourselves. Here are just some of the things we've done this year (with much more coming down the road)!

Website Redesign

We've refreshed the look and feel of Nomad PHP to better emphasize the goal of Nomad PHP - to help developers build a habit of continuous learning and grow their careers. This includes numerous usability enhancements as well as a focus on our new book library, blogs, and certification in addition to virtual meetups, workshops, conferences, and on-demand videos.

Free Meetups

As technology has advanced, more and more meetups and usergroups are able to stream their local usergroup meetings.

As our goal has always been to make technology accessible, we are proud to provide free streaming technology for local user groups, and share local user group meetings on our live virtual meetup schedule.

Student and Professional subscribers will continue to have access to our monthly conference level Pro Talks, hands on virtual workshops, and live conference streams in addition to streams by local user groups.

You can find a list of all upcoming talks (free and Pro) on our Live Meetings Page, or add your user group stream here.

Free Subscriber Tier

As our mission has evolved from being the meetup for developers without a meetup group to building an inclusive community of PHP developers where you can network, grow your skills, and share your knowledge with others - we are excited to announce our new Free Tier.

With a free Nomad PHP account you can:

* Stream free meetups

* Watch ad-supported videos in SD

* Read PHP blogs and write your own

* Network with other PHP developers

Create your free developer account to get started.

New Student Tier

To provide the best value, we've also restructured our plans to provide professional online meetings, workshops, and conference streaming to our Student Tier. This will allow students and new developers the chance to learn from the best speakers and top practioners and obtain entry level certifications at the best price possible.

However, with the addition of PHP Books and Magazines, and in order to provide the best value while keeping the Student plan affordable, new Student subscribers will not have access to the PHP Book and Magazine Library, or advanced certifications. These will now require a professional plan.

Student plans start at $12.95/mo

PHP Books and Magazines

We're excited to announce that we have expanded our PHP library. In addition to the ability to read the latest issues of php[architect] magazine, Professional subscribers now have access to read PHP and web development books online.

We're excited to announce the availability of Chris Hartjes' bookThe Grumpy Programmer's Guide to Testing PHP Applications, as well as several titles from Notes for Professionals, andUndisturbed REST: a Guide to Designing the Perfect API.

More titles including exclusive titles will be made available for online reading soon.

You can view our entire PHP Library here.

Blog Updates

We've received a lot of feedback on the blog writing process, and have upgraded several aspects of our blogging software. This includes the ability to save drafts prior to publishing, and the ability to upload, edit, and crop images and videos. We've also added some bug fixes for editing and writing code.

We're also excited to share that members with Student and Professional plans can now have their ownVLOG (video blog) with the ability to screencast/ record video from your webcam within the blog.

To see the most recent blog posts, or write your own, visit the Nomad PHP Blogs.

Certification Updates

We've updated our certifications for better usability and readability. We've also reworked some of the code samples and questions in our Level 1 PHP Certification exam.

You can find our available exams, test your skills, and obtain your Nomad PHP certification here.

Team Management

Our new team manager allows you to easily add or remove team members with your Nomad PHP team subscription. You'll also find real time metrics on how your team is using Nomad PHP, who on your team is investing in their growth and streaming meetups, watching videos, reading books, and earning certifications, and the overall content value consumed by your team.

The Team Manager is available to new teams, and will be made available to existing team managers over the next several weeks.

2020 Roadmap

There's still plenty of more great things coming in 2020. Here are the items at the top of our list:

* Mobile app for offline viewing

* Desktop app for offline viewing

* Nomad PHP member only books

* PHP Level 2 Certification

* Interactive tutorials

* Better video support in blogs

* Ability to schedule blog posts

* Meeting software for local usergroups

* Improved plan management for subscribers
Of course, what's most important to us is what's most important to you. Leave what you want to see on Nomad PHP in the comments below and if we're able to we'll get it added to our roadmap!

In today's dynamic and fast-paced world of web development, ensuring the reliability, performance, and scalability of applications is paramount. Monitoring and observability tools play a crucial role in achieving these goals by providing insights into application metrics, performance trends, and system health. Prometheus, a popular open-source monitoring and alerting toolkit, offers robust capabilities for monitoring infrastructure and application metrics. In this article, we'll explore how to leverage Prometheus with PHP to monitor, analyze, and troubleshoot PHP-based applications effectively.

Understanding Prometheus:

Prometheus is an open-source monitoring and alerting system originally developed by SoundCloud. It is designed for reliability, scalability, and extensibility, making it suitable for monitoring complex, distributed systems. Key features of Prometheus include:

Time Series Data: Prometheus collects time-series data, allowing developers to track metrics such as CPU usage, memory consumption, request latency, and HTTP response codes over time.

PromQL: Prometheus Query Language (PromQL) enables users to query and aggregate metrics, create custom dashboards, and set up alerting rules based on specific conditions.

Scalability and Reliability: Prometheus is designed to be highly scalable and reliable, supporting a distributed architecture with multiple replicas and federated setups for global monitoring.

Integrating Prometheus with PHP:

To integrate Prometheus with PHP applications, developers can utilize client libraries and instrumentation libraries that facilitate metric collection and exposition. The following steps outline the process of integrating Prometheus with PHP:

Choose a Prometheus Client Library: Select a Prometheus client library for PHP that suits your needs. Popular options include prometheus/client_php and php-prometheus/client.

Instrument Your PHP Code: Instrument your PHP application code to collect relevant metrics. This involves adding instrumentation code to track metrics such as request duration, memory usage, database queries, and custom business metrics.

Exposing Metrics: Expose the collected metrics in a format compatible with Prometheus. This typically involves exposing an HTTP endpoint (e.g., /metrics) where Prometheus can scrape the metrics using the Prometheus exposition format.

Configure Prometheus Server: Configure the Prometheus server to scrape metrics from the PHP application's endpoint. Update the Prometheus configuration file (prometheus.yml) to include the target endpoint and define any additional scraping parameters.

Example Integration:

Let's illustrate how to integrate Prometheus with a PHP application using the prometheus/client_php library:

require 'vendor/autoload.php';

use Prometheus\CollectorRegistry;
use Prometheus\Storage\APC;
use Prometheus\RenderTextFormat;

$registry = new CollectorRegistry(new APC());

$requestDuration = $registry->registerCounter('php_requests_total', 'Total number of PHP requests');

$requestDuration->inc();

$renderer = new RenderTextFormat();
echo $renderer->render($registry->getMetricFamilySamples());

In this example, we register a custom metric (php_requests_total) to track the total number of PHP requests. We then increment this metric for each request and expose the metrics endpoint using the Prometheus exposition format.

Benefits of Using Prometheus with PHP:

Real-time Monitoring: Prometheus provides real-time monitoring capabilities, allowing developers to monitor application metrics and diagnose issues promptly.

Scalability: Prometheus scales horizontally, making it suitable for monitoring large-scale deployments and distributed systems.

Alerting: Prometheus supports alerting based on predefined rules, enabling proactive monitoring and alerting for potential issues or anomalies.

Integration: Prometheus integrates seamlessly with various programming languages, platforms, and frameworks, including PHP, enabling comprehensive monitoring across the entire technology stack.

Conclusion:

Prometheus offers powerful capabilities for monitoring and observability, making it a valuable tool for developers and DevOps teams tasked with ensuring the reliability and performance of PHP applications. By integrating Prometheus with PHP using client libraries and instrumentation, developers can gain valuable insights into application metrics, troubleshoot issues effectively, and proactively respond to performance anomalies. Embracing Prometheus as part of your monitoring strategy empowers organizations to build resilient, scalable, and high-performing PHP applications in today's dynamic digital landscape.

In the realm of web development, the Model-View-Controller (MVC) architectural pattern stands as one of the most influential paradigms. It provides a structured approach to designing web applications, promoting modularity, scalability, and maintainability. In this guide, we'll delve into the MVC framework in PHP, exploring its key components, principles, and benefits.

Understanding MVC Architecture:

MVC separates an application into three interconnected components, each with its distinct responsibility:

Model: The model represents the application's data and business logic. It encapsulates the data structure, database interactions, and validation rules. In MVC, the model is responsible for managing data persistence and state.

View: The view is responsible for presenting data to the user in a visually appealing format. It encompasses the HTML markup, CSS styling, and client-side scripting necessary to render the user interface. Views are typically passive components that receive data from the controller and display it to the user.

Controller: The controller acts as an intermediary between the model and the view. It processes user requests, invokes the appropriate methods in the model to retrieve or manipulate data, and selects the appropriate view to render the response. Controllers handle user input, orchestrate business logic, and coordinate the flow of data between the model and the view.

Implementing MVC Framework in PHP:

PHP offers a robust foundation for building MVC-based web applications. Let's explore how to implement each component of the MVC pattern in PHP:

Model:

In PHP, models typically represent data entities and interact with the database. They encapsulate data access logic and provide methods for querying, inserting, updating, and deleting records. Here's a simplified example of a model class:

class User { 
 public function getUserById($userId) { 
 } 

 public function updateUser($userId, $userData) { 
 }

}

View:

Views in PHP are responsible for generating HTML markup to render the user interface. They receive data from the controller and use it to dynamically generate the content displayed to the user. Views can include HTML templates with embedded PHP code or utilize template engines for better separation of concerns. Here's a basic example of a view:

<!DOCTYPE html>

<html>

<head> <title>User Profile</title>

</head>

<body> <h1>Welcome, <?php echo $user['username']; ?>!</h1> <p>Email: <?php echo $user['email']; ?></p>

</body>

</html>

Controller:

Controllers in PHP handle user requests, process input data, and interact with models to retrieve or manipulate data. They select the appropriate view to render the response and pass data to the view for presentation. Controllers are responsible for defining application routes and managing the overall application flow. Here's an example of a controller method:

class UserController { 
 public function profile($userId) { 
 $userModel = new User(); 
$userData = $userModel->getUserById($userId); 

include 'views/profile.php'; 
 }
}

Benefits of MVC Framework in PHP:

Separation of Concerns: MVC promotes a clear separation of concerns, making it easier to manage code complexity and maintainability.

Modularity: Components in MVC are modular and reusable, allowing developers to build and extend applications more efficiently.

Testability: With distinct components, it becomes easier to write unit tests for models, views, and controllers independently.

Scalability: MVC facilitates the scalability of web applications by enabling developers to add new features or modify existing ones without impacting other parts of the system.

Conclusion:

The MVC framework in PHP provides a robust architectural pattern for building scalable and maintainable web applications. By separating concerns into models, views, and controllers, developers can organize code more effectively, enhance testability, and streamline the development process. Whether you're building a simple blog or a complex enterprise application, leveraging the MVC pattern in PHP can significantly improve the quality and maintainability of your codebase.

Unit testing is a crucial aspect of modern software development, ensuring that individual units of code function correctly in isolation. In PHP, unit testing helps developers identify bugs early in the development cycle, improve code quality, and facilitate code maintenance. In this comprehensive guide, we'll walk you through the process of creating unit tests in PHP, using popular testing frameworks like PHPUnit.

Why Unit Testing?

Unit testing involves testing individual components or units of code in isolation from the rest of the application. Here are some reasons why unit testing is essential:
   
. Bug Detection: Unit tests help identify bugs and regressions early in the development process, making them easier and cheaper to fix.
   
. Code Quality: Writing unit tests encourages developers to write modular, well-structured, and maintainable code.
   
. Improved Documentation: Unit tests serve as executable documentation, providing clear examples of how individual components of your code should behave.

Getting Started with PHPUnit:

PHPUnit is the most widely used testing framework for PHP. It provides a robust set of features for writing and executing unit tests. Let's dive into how you can get started with PHPUnit:

Installation:

You can install PHPUnit using Composer, the PHP package manager. Simply navigate to your project directory and run the following command:

composer require --dev phpunit/phpunit

This command installs PHPUnit as a development dependency in your project.

Writing Your First Test:

Now that PHPUnit is installed, let's create a simple test case. Create a new directory named tests in your project root, and within that directory, create a file named ExampleTest.php. Here's an example of what your test file might look like:

<?php

use PHPUnit\Framework\TestCase;

class ExampleTest extends TestCase
{
 public function testTrueAssertsToTrue()
 {
 $this->assertTrue(true);
 }
}

This test case contains a single test method named testTrueAssertsToTrue, which asserts that true is indeed true.

Running Tests:

To run your tests, simply execute PHPUnit from the command line, pointing it to your test directory. Run the following command in your project root:

vendor/bin/phpunit tests

PHPUnit will discover and execute all test cases within the specified directory, providing detailed feedback on the results.

Writing Testable Code:

Writing testable code is essential for effective unit testing. Here are some best practices to follow:
   
. Separation of Concerns: Ensure that your code follows the principle of separation of concerns, with clear boundaries between different components.
   
. Dependency Injection: Use dependency injection to inject dependencies into your classes, making it easier to replace them with mock objects during testing.
   
. Mocking and Stubbing: Use PHPUnit's mocking and stubbing features to simulate the behavior of dependencies and isolate the code under test.

Advanced Features:

PHPUnit provides a wide range of advanced features for writing comprehensive unit tests. Some notable features include:

-Data Providers: Use data providers to run a test method with multiple sets of data.

-Annotations: PHPUnit supports annotations for marking test methods, setting up fixtures, and configuring test execution.

-Code Coverage: PHPUnit can generate code coverage reports, showing which parts of your codebase are covered by your tests.

Conclusion:

Unit testing is an indispensable practice in modern PHP development, and PHPUnit makes it easy to write and execute unit tests for your codebase. In this guide, we've covered the basics of getting started with PHPUnit, writing testable code, and leveraging advanced features to write comprehensive unit tests. By incorporating unit testing into your development workflow, you can improve code quality, reduce bugs, and build more robust and maintainable PHP applications.