Forem: Cloudways

Installing Symfony 3.x on DigitalOcean

Cloudways — Thu, 18 May 2017 12:54:35 +0000

This article was originally published at Cloudways: How To Install Symfony 3 On Cloud Server

Symfony is the leading, modern PHP framework that is used to create secure websites and web applications with the help of its different components. It’s a popular MVC framework which saves time with handling typical development tasks such as content rendering, directing traffic, creating persistent models, etc.

To install and run Symfony 3, your system needs to fulfill a list of following requirements:

PHP with a minimum version of 5.5.9
Composer
JSON enabled
ctype enabled
date.timezone should be set (default timezone will not work)

Note: If you want to use any optional component, see these Requirements for Running Symfony.

If you are wondering how to install Symfony on Cloudways, you can simply follow this easy step-by-step guide. Ready? Lets begin!

Step 1: Prepare your server and application

Signup or Login to your Cloudways account and create a new server by selecting PHP Stack from the “Select your Application” drop-down. Also, Name your App, Server & Project accordingly.

Step 2: Select Cloud Provider

Now select your favorite Cloud provider.

Step 3: Server Size and Location

In “Server Size” field, scale up to 1GB.

Keeping the latency difference in mind, now select your server location in “Location” field.

To launch your server, click “Launch” button at the bottom right side of the page and wait for a while. A working example:

Step 4: Server Timezone

Once launched, change your server timezone as it’s the requirement to install Symfony (default value for timezone is not supported by Symfony). Under “Server Management”, go to “Settings & Packages.”*

In “Basic” tab you can see “PHP Timezone.” Change server timezone to your respective location.

Step 5: SSH Terminal

After changing server timezone, in “Server Management” click on “Launch SSH Terminal” under “Master Credentials” where you can find your login credentials for SSH Terminal.

Step 6: Emptying public_html directory

Now delete all files from your public_html directory. Navigate to your public_html folder and remove all files using rm -Rf * command.

Step 7: Symfony 3 Installation

Now in your “public_html” directory, run the following command to install Symfony 3 on your server:

composer create-project symfony/framework-standard-edition your_project_name "3.0.*"

for 3.1:

composer create-project symfony/framework-standard-edition your_project_name "3.1"

Step 8: DB Information and Finishing Project Installation

Now Symfony will start downloading to your server. During downloading, it will ask for your database information.

You can find out your DB information under “Application Management” go to “Access detail” and see MySQL Access.

After providing database information, in very few seconds you will see the following screen which means that Symfony has been installed successfully.

Step 9: Composer Repositories

Now we will check if there is any need to install or update composer dependencies required for the application by using composer install command. Navigate to your project directory and run the command.

Step 10: Installation Completed

After a successful installation, in “Application Management” go to “Access detail” and copy your Application URL.

Open your favorite web browser and access to Welcome page to Symfony by the following URL:

http://your_application_url/your_project_directory/web

This is how the Symfony Welcome page should look like:

There you have it! Your Symfony Project is ready for development. If you have any issues in installing Symfony 3, feel free to comment below. And if you are still not a part of the Cloudways family, then you can start your FREE TRIAL here and experience ease at its best.

Consuming Restful API in PHP with Guzzle

Cloudways — Wed, 26 Apr 2017 12:51:55 +0000

Originally Published at HackerNoon.com on April 18, 2017

If you are familiar with Rest API, you must know about HTTP calls created for getting and posting data from the client to the server. What if you wish to create a REST API client in PHP? Your answer would be to go with CURL. CURL is the most widely used method to make HTTP calls but it contains several complicated steps.

Let’s see a simple CURL request in PHP:

$url = “https://api.cloudways.com/api/v1”
$resource = curl_init($url);
curl_setopt($ch, CURLOPT_HTTPHEADER, [â€˜Accept:application/json, Content-Type:application/json’]);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, â€˜GET’);

You need to call the curl_setopt() method to define the header and the particular HTTP verb like GET, POST, PUT, etc. It does look pretty complicated. So, what is a better and robust alternative?

Here comes Guzzle.

Let’s see how Guzzle creates a request:

$client = new GuzzleHttp\Client();
$res = $client->request(â€˜GET’, â€˜https://api.cloudways.com/api/v1’, [
â€˜headers’ => [
â€˜Accept’ => â€˜application/json’,
â€˜Content-type’ => â€˜application/json’
]])

You could see that it is simple. You just need to initialize the Guzzle client and give HTTP verbs and a URL. After that, pass the array of headers and other options.

Understand the Guzzle Client

Guzzle is a simple PHP HTTP client that provide an easy method of creating calls and integration with web services. It is the standard abstraction layer used by the API to send messages over the server. Several prominent features of Guzzle are:

Guzzle can send both synchronous and asynchronous requests.
It provides a simple interface for building query strings, POST requests, -
streaming large uploads & downloads, uploading JSON data, etc.
Allows the use of other PSR7 compatible libraries with Guzzle.
Allows you to write environment and transport agnostic code.
Middleware system allows you to augment and compose client behavior.

Install Guzzle In PHP

The preferred way of installing Guzzle is Composer. If you haven’t installed Composer yet, download it from here
Now to install Guzzle, run the following command in SSH terminal:

composer require guzzlehttp/guzzle

This command will install the latest version of Guzzle in your PHP project. Alternatively you can also define it as a dependency in the composer.json file and add the following code in it.

{
 “require”: {
 “guzzlehttp/guzzle”: “~6.0”
 }
}

After that, run the composer install command. Finally you need to require the autoloader and added some more files to use Guzzle:

require â€˜vendor/autoload.php’;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Psr7\Request;

The installation process is over and now it’s time to work with a real example of creating HTTP calls with an API. For the purpose of this article, I will work with Cloudways API.

What You Can Do With the Cloudways API

Cloudways is a managed hosting provider for PHP, Magento, WordPress and many other frameworks and CMS. It has an API that you could use for performing CRUD operations on servers and applications. Check out popular use cases of the Cloudways API to see how you could integrate it into your projects.

In this article, I am going to create HTTP calls to perform specific operations with Guzzle on Cloudways server.

Create the HTTP Requests In Guzzle

As I mentioned earlier, creating HTTP requests in Guzzle is very easy; you only need to pass the base URI, HTTP verb and headers. If there is an authentication layer in the external API, you can also pass these parameters in Guzzle. Similarly, Cloudways API needs email and API key to authenticate users and send the response. You need to sign up for a Cloudways account to get your API credentials.

Let’s start by creating a CloudwaysAPIClient.php file to set up Guzzle for making HTTP calls. I will also create a class and several methods using HTTP calls in them.

The URL of the API does not change so I will use const datatype for it. Later on, I will concatenate it with other URL suffixes to get the response. Additionally, I have declared variables $auth_key,$auth_email which will hold the authentication email and the API key. $accessToken will hold the temporary token which will be renewed every time.

Class CloudwaysAPIClient
{
private $client = null;
const API_URL = “https://api.cloudways.com/api/v1";
var $auth_key;
var $auth_email;
var $accessToken;
public function __construct($email,$key)
{
$this->auth_email = $email;
$this->auth_key = $key;
$this->client = new Client();
}
}

Create a Post Request to get Access Token

The access token will be generated from this URL: https://api.cloudways.com/api/v1/oauth/access_token every time I access the API. This will be set in $url with additional data array which holds auth credentials. Later on, I created a POST request with the base URL and query string. The response will be decoded and access token is saved to be used within the methods.

public function prepare_access_token()
{
try
{
$url = self::API_URL . “/oauth/access_token”;
$data = [â€˜email’ => $this->auth_email,’api_key’ => $this->auth_key];
$response = $this->client->post($url, [â€˜query’ => $data]);
$result = json_decode($response->getBody()->getContents());
$this->accessToken = $result->access_token;
}
catch (RequestException $e)
{
$response = $this->StatusCodeHandling($e);
return $response;
}
}

Here the POST request for getting access token is completed. Additionally, If you observed in the exception handling, I declared a method StatusCodeHandling($e), which will take care of the response codes (HTTP codes like 404, 401, 200 etc), and throw a related exception.

public function StatusCodeHandling($e)
{
if ($e->getResponse()->getStatusCode() == â€˜400’)
{
$this->prepare_access_token();
}
elseif ($e->getResponse()->getStatusCode() == â€˜422’)
{
$response = json_decode($e->getResponse()->getBody(true)->getContents());
return $response;
}
elseif ($e->getResponse()->getStatusCode() == â€˜500’)
{
$response = json_decode($e->getResponse()->getBody(true)->getContents());
return $response;
}
elseif ($e->getResponse()->getStatusCode() == â€˜401’)
{
$response = json_decode($e->getResponse()->getBody(true)->getContents());
return $response;
}
elseif ($e->getResponse()->getStatusCode() == â€˜403’)
{
$response = json_decode($e->getResponse()->getBody(true)->getContents());
return $response;
}
else
{
$response = json_decode($e->getResponse()->getBody(true)->getContents());
return $response;
}
}

The main client class is now completed. I will extend it to create more HTTP requests for different cases.

Create a GET Request to Fetch All Servers

Once the User is authenticated, I can fetch all my servers and applications from Cloudways. /server is the suffix concatenated with the base URI. This time, I will attach the accessToken with Authorization string in Guzzle header to fetch all servers in JSON response. To do this, create a new method:

Public function get_servers()
{
try
{
$url = self::API_URL . “/server”;
$option = array(â€˜exceptions’ => false);
$header = array(â€˜Authorization’=>’Bearer â€˜ . $this->accessToken);
$response = $this->client->get($url, array(â€˜headers’ => $header));
$result = $response->getBody()->getContents();
return $result;
}
catch (RequestException $e)
{
$response = $this->StatusCodeHandling($e);
return $response;
}
}

Now create index.php file and include CloudwaysAPIClient.php at the top. Next, I will declare my API key and email, passing it to the class constructor to finally get the servers.

include â€˜CloudwaysAPIClient.php’;
$api_key = â€˜W9bqKxxxxxxxxxxxxxxxxxxxjEfY0’;
$email = â€˜shahroze.nawaz@cloudways.com’;
$cw_api = new CloudwaysAPIClient($email,$api_key);
$servers = $cw_api->get_servers();
echo â€˜<pre>’;
var_dump($servers);
echo â€˜</pre>’;

Let’s test it in Postman to verify that the information and right response codes are being fetched.

So all my servers hosted on the Cloudways Platforms are being fetched. Similarly, you can create new methods with HTTP calls to get applications, server settings, services and etc.

Let’s create a PUT call to change the label of the server which is cloned-php applications at the moment. But first, I need to get the server ID & label because this information will be used as an argument. To get the server ID, create a foreach loop in the index.php file:

foreach($servers->servers as $server){
echo $server->id;
echo $server->label;
}

Now, if I hit the API, it will fetch the server id and label.

Create a PUT Request to Change Server Label

Now to change the server label, I need to create a PUT call in Guzzle. I will extend the class with a new method. Remember that server id and label are two necessary parameters that will be passed in the method.

public function changelabel($serverid,$label)
{
try
{
$url = self::API_URL . “/server/$serverid”;
$data = [â€˜server_id’ => $serverid,’label’ => $label];
$header = array(â€˜Authorization’=>’Bearer â€˜ . $this->accessToken);
$response = $this->client->put($url, array(â€˜query’ => $data,’headers’ => $header));
return json_decode($response->getBody()->getContents());
}
catch (RequestException $e)
{
$response = $this->StatusCodeHandling($e);
return $response;
}
}

Now in the index.php, put this condition beneath the foreach loop.

if($server->id == â€˜71265’ && $server->label == â€˜Cloned-php applications’){
$label = â€˜Cloudways Server’;
$changelabel = $cw_api->changelabel($server->id,$label);
}

When testing this in Postman, I will get the updated server label.

Create a Delete Request to Remove a Server

To delete a server using Cloudways API, I need to create a Delete request in Guzzle through the following method. This is pretty similar to the above method, because it also requires two parameters, server id and label.

public function deleteServer($serverid,$label)
{
try
{
$url = self::API_URL . “/server/$serverid”;
$data = [â€˜server_id’ => $serverid,’label’ => $label];
$header = array(â€˜Authorization’=>’Bearer â€˜ . $this->accessToken);
$response = $this->client->delete($url, array(â€˜query’ => $data,’headers’ => $header));
return json_decode($response->getBody()->getContents());
}
catch (RequestException $e)
{
$response = $this->StatusCodeHandling($e);
return $response;
}
}

Try this in Postman or just refresh the page. The server will be deleted.

Final Words

Guzzle is a flexible HTTP client that you could extend as per your requirements. You can also try out new ideas with uploading data, form fields, cookies, redirects and exceptions. You can also create middleware for authentication layer (if needed). All in all, Guzzle is a great option for creating REST API in PHP, without using any frameworks.

If you have any questions or query you can comment below.

Creating RESTful API Using Slim Micro-Framework

Cloudways — Thu, 23 Mar 2017 11:51:51 +0000

This article was originally published at Cloudways: Creating A Simple REST API With Slim Framework

The internet is chock full of third-party and custom APIs that offer a wide range of functionalities. PHP offers several frameworks for web app development rapidly. However, time is always the enemy of web developers and the app needs to be pushed at an impossible deadline. In such times, frameworks are the best option for rapid application development.

In this tutorial, I will introduce you to Slim framework for PHP. Slim is fast becoming the most-opted framework for API development and small web apps. Although you can create REST API in several other frameworks like CakePHP, Symfony Laravel, Codeigniter, they have a steep learning curve and are often too cumbersome to use in rapid development scenarios.

Understanding Slim Framework

Slim is super lightweight framework, ideal for rapid web app development. One of the important usages is in REST API development. Slim supports all HTTP method (GET,POST,PUT,DELETE). Slim contains very handy URL structure with routers, middlewares, bodyparser along with page templates, flash messages, encrypted cookies and lots more.

At this point, it is important to understand the structure of the REST API.

Understanding REST API

REST is the abbreviation of Representational State Transfer. This is a bridge or medium between data resource and application interface, whether it's on mobile devices or desktops. REST provides a block of HTTP methods which are used to alter the data. The following are common HTTP methods:

GET is used for reading and retrieving data.
POST is used for inserting data.
PUT is used for updating data.
DELETE is used for deleting data.

Basically, REST phenomena works on actions and resources. Whenever any action URL is invoked, it performs an individual method (or a set of methods) on that URL. I will further discuss this below with examples.

First we will need to install Slim framework for the REST API project.

I assume that you already have your Cloudways server launched with PHPstack and if you didn't launch your server signup to get it.

After creating the server launch SSH terminal.

Step 1: Install Slim Framework From Composer

Open SSH terminal from the Cloudways panel and and sign in with your username and password. Now go to the folder where you want to install SLIM with cd command

Input the following command in the terminal to install Slim via composer.

composer require slim/slim"^3.0"

After installing Slim, the following piece of code will require it in the index.php file to require autoload file and instantiate Slim.

<?php

require 'vendor/autoload.php';
$app = new Slim\App();

Composer comes pre-installed on Cloudways servers. If you are working on the localhost, you need to install it. If you haven't installed it yet, just go to the following link and follow the instructions.

Step 2: Making a .htaccess File for Clean URL Structure

To make your life easier, you should create a .htaccess file that defines clean URL structure. At the root directory, make a .htaccess file and add the below code in it. This will provide a clean URL structure for the PHP file. (this just means that you don't want to include PHP filename in the URL calls).

RewriteEngine On

RewriteCond %{Request_Filename} !-F

RewriteCond %{Request_Filename} !-d

RewriteRule ^ index.php [QSA,L]

If your index file is located in different folder (for instance, the “public” folder), then you can insert the full path of the index file in the last line:

RewriteRule ^ public/index.php [QSA,L]

Step 3: Create a Database in MySQL

With each PHP Stack on Cloudways, you get an empty database.

Click on Launch Database Manager. To create the requisite tables, run the following query in SQL Command box:

CREATE TABLE IF NOT EXISTS `library` (

Â `book_id` int(11) NOT NULL,

Â `book_name` varchar(100) NOT NULL,

Â `book_isbn` varchar(100) NOT NULL,

Â `book_category` varchar(100) NOT NULL

) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

INSERT INTO `library` (`book_id`, `book_name`, `book_isbn`, `book_category`) VALUES

(1, 'PHP', 'bk001', 'Server Side'),

(3, 'javascript', 'bk002', 'Client Side'),

(4, 'Python', 'bk003', 'Data Analysis');

Now it is time for the first API call. Let's make it systematically.

Step 4: Retrieving All Books

Enter the following code in the index.php file to get all the books from the database. A GET call is used for retrieval.

$app->get('/books', function() {

Â require_once('db.php');

Â $query = "select * from library order by book_id";

Â $result = $connection->query($query);

Â // var_dump($result);

Â while ($row = $result->fetch_assoc()){

$data[] = $row;

Â }

Â echo json_encode($data);

});

To streamline working with the API calls, I recommend using Postman (available from the Chrome App Store). This plugin greatly helps in API management and usage.

In postman, make a GET call with API URL.

Step 5: Creating a Book's Record

Make a new API call in the index.php through the following code:

$app->post('/books', function($request){

Â require_once('db.php');

Â $query = "INSERT INTO library (book_name,book_isbn,book_category) VALUES (?,?,?)";

Â $stmt = $connection->prepare($query);

Â $stmt->bind_param("sss",$book_name,$book_isbn,$book_category);

Â $book_name = $request->getParsedBody()['book_name'];

Â $book_isbn = $request->getParsedBody()['book_isbn'];

Â $book_category = $request->getParsedBody()['book_category'];

Â Â $stmt->execute();

});

Open Postman and click Body. Select x.www-form-urlencoded. Now add records to insert via POST call.

Step 6: Updating a Book's Record

Make a new API call like below to update a record in the database.

$app->put('/books/{book_id}', function($request){

Â require_once('db.php');

Â $get_id = $request->getAttribute('book_id');

Â $query = "UPDATE library SET book_name = ?, book_isbn = ?, book_category = ? WHERE book_id = $get_id";

Â $stmt = $connection->prepare($query);

Â $stmt->bind_param("sss",$book_name,$book_isbn,$book_category);

Â $book_name = $request->getParsedBody()['book_name'];

Â $book_isbn = $request->getParsedBody()['book_isbn'];

Â $book_category = $request->getParsedBody()['book_category'];

Â $stmt->execute();

});

In Postman, add data to update a specific book record.

Step 7: Deleting a Book's Record

To delete a record with a specific ID, a DELETE call is required.

$app->delete('/books/{book_id}', function($request){

Â require_once('db.php');

Â $get_id = $request->getAttribute('book_id');

Â $query = "DELETE from library WHERE book_id = $get_id";

Â $result = $connection->query($query);

});

On Postman, run the call like this

This is all for the basic REST API in the Slim Framework. However, this API will not work until you add this command at the end of the code.

$app->run();

Conclusion

Creating and using the REST API with Slim framework is very easy. The biggest advantage of the framework is its ease of use and lightweight. The icing on the cake is that it is very easy to learn and a good developer could pick up the framework in a matter of hour. To summarize, Slim receives HTTP requests, review them and invokes the appropriate callback routine for HTTP requests and return the appropriate response(s).

If you need clarification about this article or have any other query about the Slim Framework, do let me know through the comment section.

How PHP Will Fare In 2017?

Cloudways — Wed, 04 Jan 2017 13:57:26 +0000

For the PHP community, the best news in 2016 was the release of version 7.1. While many initially saw PHP 7.1 as a minor release with bug fixes, it proved to be a whole different beast altogether. The version offered important improvements, a new return type (void) and Multi Catch Exception Handling.

This year, I went to the PHP community and asked about the general feelings and expectations about the trends that would dominate the PHP world in 2017. Essentially, I asked three questions in the Reddit thread:

What was the best thing that happened to PHP in 2016?
What does the community thinks of PHP 7 and 7.1?
What is the best PHP framework?

In addition, I asked about the community's response on the issue of official termination of support for PHP 5.6.

In addition to the Reddit, I also posed these questions via email to several community influencers. I received the following responses:

Cal Evans, Technical Manager at Zend Technologies and godfather of the PHP community responded:

Versions 7 and 7.1 of PHP are not the revolutionary changes that we got in the later 5.x versions. They are however proof that PHP has stabilized, matured, and has a predictable path forward.

In response to the question about the frameworks, Evans was very clear.

Frameworks exist only to make developers lives better. Some developers won't want to sweat the details, they want to just get things done. There is nothing wrong with this and frameworks like Laravel will always exist to fill this need. In our ecosystem, Laravel stands above all others with the tooling and ecosystem built around it to help developers just get things done.

Alex Makarov, a major contributor to Yii offered a personal insight for the question about PHP version 7+.

While 7.0 was excellent revolutionary release, there was design issue with return types and returning null preventing me from using it. 7.1 added nullable types and now I'm happy.

When talking about favorite PHP framework, Makarov added:

Depends on what is the definition of “the best”. If we're talking about “most popular in US then it should be Laravel. If it's “most popular in ex-USSR and asia then it's Yii. If we're talking about enterprise level support, that's Symfony without any doubt. If it's about features and performance, Yii has more out of the box.

Stefan Koopmanschap, cofounder of PHPBenelux loved PHP 7+.

I love it. I think it is a great step in the development of the language, PHP is a seriously mature language now, which can easily compete with other languages. And it's being used for highly scalable and business-critical applications.

His response on the question of favorite framework echoed the sentiments of “framework-independent developers.

There is no best framework. There is a best fit for every use case. Symfony, Laravel, Zend Framework, Yii, Expressive, Silex, Slim, the list is endless, and each of the frameworks has a place. Which framework fits your use case depends on the requirements of the application, the developers you have on your team, the infrastructure it will be running on, and a lot of other factors.

I would like to start discussing the Reddit poll with the comment by the Reddit user leeharris100, that sums up the PHP trends for 2017 very succinctly:

This is why I think PHP will continue to be popular for a long time to come. It's easy to make applications of any size and scope. There is documentation and support for every single problem you could ever think of. And it's finally hit the point where performance is mostly acceptable.

I ran a poll on Reddit and got some excellent answers from PHP experts, all over the world. I will now offer a summary of the answers to all four questions, so that the readers could form their own opinions.

What Was the Best Thing That Happened to PHP in 2016?

The majority of respondents agreed that speed was one area where PHP greatly improved in 2016. In the concise words of a Reddit commentator:

PHP is fast as h*ll!

The improvements in speed is the main benefit of PHP 7 (introduced near the end of 2015).

For some users, the best thing about 2016 was the increased maturity of PHP libraries and frameworks. I think Reddit user ajr901 put it best in the comment:

Speed, ease of development (sort of?), ease of deployment, arguably better frameworks and tooling available for PHP.

I believe that both these developments (the increase in speed and the maturity of libraries) are the direct result of the introduction of PHP 7 and 7.1. This brings me to the next question

What Does the Community Thinks About PHP 7 and 7.1?

The community loves the new PHP 7. The improvements in almost all areas of the language come together in a very fast package that removes one of the major complaints about PHP.

In the words of Reddit user hedsht:

it's a major step into the right direction, type hinting will hopefully silence some haters.

The community agrees that PHP 7+ is the best thing that has happened to the language so far. Almost every respondent on Reddit and Facebook agreed that PHP has entered a whole new era with the introduction of PHP 7. PHP 7.1 sweetened the pot even further by introducing speed related improvements that have impacted every framework and library.

Many respondents felt that PHP is now ready for enterprise level projects because of the speed of PHP 7. A Reddit commentator the_goose_says wrote:

The most important thing about PHP in 2016 is speed. PHP has always been used by millions, but the largest companies have avoided it because speed matters so much at that level. With PHP 7+, we may have more household names using PHP.

What Is the Best PHP Framework?

The real meat of the discussion (and this is true for every PHP related discussion!) was about the framework preferred by the users. Everyone has their own favorite framework that they use in their projects. In response to the question about the best PHP framework, everyone opted for their own favorite.

I asked the community to select their favorite from Symfony, Yii2 and Laravel. Interestingly, some Reddit commentators also brought in Codeigniter and their own custom PHP frameworks into the debate.

Overwhelmly, the comments favored Laravel among the three, with Symfony coming in the second place. I think diabetesjones summed up the debate:

Laravel is the smoothest coding I've ever had. Yii is fight-the-system every step of the way.

Finally, on the question of the termination of support for PHP 5.6, the community was not very divided. Several commentators said that if PHP 5.6 projects have been implemented using the best practices, there is nothing to worry about. In the words of scootstah, a Reddit commentator:

Anything that is 5.6 compliant will be able to migrate to 7 with little to no difficulty. You're only going to have problems if you were already 5 years behind the times.

What Will the (Probable) PHP Trends for 2017?

I see three major trends that would dominate the PHP world in the year 2017.

The first and the most probable trend is the complete dominance of PHP 7.x in all aspects of PHP development. In part this will be an outcome of the discontinued support for PHP5.6. However, the most important aspect of this trend is the fact that PHP 7.x introduced several important improvements to the language and PHP development for websites and web apps.

The second important and related PHP trend in 2017 would be the release of major versions of all important frameworks. Right now, the bulk of all major frameworks (Symfony, Laravel and Yii) is built on older versions of PHP. In 2017, the released versions would embrace PHP 7 completely and would make available the important features as part of the tooling and scaffolding of the frameworks.

Finally, major (and minor) web hosting providers of all flavors would upgrade to PHP 7.x. While this is a no-brainer, given the popularity of PHP7.x, anyone who has ever used a web host knows how difficult it is to get the web hosting company to upgrade anything! I think, 2017 would the year when PHP 7.x would be available as the default PHP version everywhere.

In conclusion, the PHP community is very optimistic about PHP 7+ and all the possibilities the new versions offer for projects of all descriptions and scale. When it comes to frameworks, Laravel and Laravel based CMS have captured the attention of the community for the moment and there is little indication that other frameworks would come up with a game changer!

If you think PHP would go in a different direction or would like to extend the discussion, please leave a comment below!

Originally published at www.cloudways.com on December 27, 2016