News Feed
Sections




News Archive
feed this:

Looking for more information on how to do PHP the right way? Check out PHP: The Right Way

Matthieu Napoli:
Test against the lowest Composer dependencies on Travis
December 18, 2014 @ 10:53:58

Recently the "prefer-lowest" option of Composer was mentioned in relation to testing for Symfony-based applications. In this new post to his site Matthieu Napoli shows how you can do it on any project that uses the Travis-CI continuous integration service.

Composer just got a new awesome addition thanks to Nicolas Grekas: prefer the lowest versions of your dependencies. [...] This amazing option will install the lowest versions possible for all your dependencies. What for? Tests of course!

He includes all the instructions you'll need to get your Travis build using this command line option, starting with testing it on your own system first. He shows a basic ".travis.yml" file with the configuration you'll need to provide it use the "prefer-lowest" (check out line 17). He does point out that you'll need to run a "composer self-update" first though, as Travis hasn't quite caught up with the latest Composer that includes this option.

0 comments voice your opinion now!
test lowest dependency version composer travisci tutorial

Link: http://mnapoli.fr/test-lowest-dependencies/

Symfony Blog:
Testing minimal versions of Symfony requirements
December 17, 2014 @ 12:02:47

On the Symfony blog today there's a quick tip from Nicolas Grekas about using Composer to install a Symfony2 project and the definition of minimum version requirements.

Setting up Composer package versions for complex projects is not an easy task. For starters, there are a lot of different ways to define package versions. Then, you must check that declared package versions really work when installing or updating the project, specially for the minimal versions configured. In order to improve testing the minimal versions of Symfony Components requirements, Composer now includes two new options: prefer-lowest and prefer-stable. [...] Thanks to these two new options, it's really easy to check whether your project really works for the minimal package versions declared by it.

He includes definitions of what impact each of the options has on the packages Composer installs and the work that's been done recently to define the correct package versions for the 2.3, 2.5 and 2.6 branches of Symfony. He also offers some steps to follow in your own projects to ensure that the "prefer-lowest" packages installed work correctly.

0 comments voice your opinion now!
symfony framework package version preferlowest preferstable

Link: http://symfony.com/blog/testing-minimal-versions-of-symfony-requirements

Lee Blue:
PHP vs Ruby - Application Shelf Life
December 10, 2014 @ 13:19:15

Lee Blue has started up a series of posts talking about his reasoning for moving back to PHP from Rails in his applications. In his first post of the series, he looks at application "shelf life" and the overall lifespan of the project and how that relates to things like maintainability and upgrade handling.

I plan to write a series of posts about how we develop, deploy, and support our affiliate software and digital downloads applications. And why, after 5 years of Ruby on Rails development we switched back to PHP. One of the reasons is what I refer to as the shelf life of a web application. Let's talk about what happens to a web application if you just let it sit.

He talks about the "rotting on the vine" that one of his clients' Rails 1.0 application faced when the later versions of the Ruby on Rails framework. He talks about how these kinds of upgrades cost money (and time) and how, with the right selections for the deployment stack, some of the costs could be alleviated. He gives the example of a PHP-based deployment setup and how much of the related technology has been stable and (mostly) unchanging over the years, just with new features being added. He offers a few suggestions to avoid this "app rot" and things startups/freelancers can do to help prevent it in their clients' applications.

0 comments voice your opinion now!
ruby shelflife application rot version deployment stack opinion rubyonrails

Link: http://leehblue.com/php-vs-ruby-application-shelf-life/

Jordi Boggiano:
My view of PHP version adoption
November 18, 2014 @ 09:28:12

Jordi Boggiano has a new post today sharing some of his own insights about PHP version adoption but, unlike some of the raw numbers shared before, his perspective comes from aggregating data from Packagist.

Pascal's number are interesting but I believe they have a bias towards older PHP versions. I would argue that people configuring their servers properly are also those that tend to keep up to date with newer versions, and part of the best practices is to avoid publishing the software versions you are using (i.e. disable expose_php in php.ini). If I am correct here that means early adopters are mis-represented in those numbers. In any case, I do have another biased dataset to present so here it comes! I looked in the packagist.org logs of the last fifty days for GET /packages.json which represents a composer update done by someone.

He notes that the data is biased towards development machines (not always running the same version as their production counterparts) but that it shouldn't skew the numbers too much. He compares two different datasets, one from November 2013 and the other from November 2014, showing a major change in the overall numbers and moving the largest version used up from 5.3.10 to 5.5.9. He also shares some interesting statistics around the requirements developers are putting on Packagist packages...that have basically remained the same over the past year (sadly).

0 comments voice your opinion now!
jordiboggiano version adoption packagist statistics

Link: http://seld.be/notes/my-view-of-php-version-adoption

Matt Stauffer:
Introducing Laravel Homestead 2.0
November 17, 2014 @ 10:41:45

In his latest post Matt Stauffer has posted a guide to the latest release of the Laravel Homestead project, version 2.0, walking you through the installation, configuration and validation of this virtual machine.

When Laravel Homestead first came out, it was a Github repository that included a base Homestead.yaml by default. There was no prescribed place to install it, no global commands for accessing the box, and any time you actually customized your Homestead.yaml file you instantly dirtied your Homestead Github clone, making upgrading difficult.

You can guess where I'm going with this. All of these things are problems no more. The latest version of the Homestead ecosystem has just been released, and it's moved Homestead into a globally installable Composer package which copies Homestead.yaml (and any other user-editable files) into ~/.homestead on your machine.

He covers the two different ways you'd get this updated version - the fresh install (no previous VM installed) and the upgrade path. For each all of the commands and configuration updates you'll need are included. He also points out some of the new features and handling as he goes along.

0 comments voice your opinion now!
laravel homestead version introduction install configure setup tutorial

Link: http://mattstauffer.co/blog/introducing-laravel-homestead-2.0

SitePoint PHP Blog:
Joomla's Coming of Age
November 13, 2014 @ 12:56:15

In the latest post to the SitePoint PHP blog Adedayo Adeniyi talks about Joomla's "coming of age" and some of the changes that have come/are coming in the latest versions.

Over the years, there has been a healthy rivalry between the main CMSes in use on the planet: WordPress, Drupal, and Joomla!, and all three have hosts of die-hard fans that would pitch for their favorites over the others any day. Don't worry, I'm not about to add to the high pile of subjective CMS comparison posts available on the web. Instead, I will briefly review all the recent changes in Joomla! that have modernized it for the present day developer - from version 3.0 onwards (currently 3.3).

She talks about some of the most recent changes including easier updating, the tool being mobile friendly out of the box and more flexible user access handling. She also mentions the improvements in "developer friendliness" and that it's become a good bit more security-conscious. Other topics mentioned include the JED (Joomla Extension Directory), smart search/tagging and improved database handling.

0 comments voice your opinion now!
joomla improvement version update cms contentmanagement

Link: http://www.sitepoint.com/joomlas-coming-age/

SitePoint PHP Blog:
How to Run Multiple Versions of PHP on One Server
November 07, 2014 @ 10:54:27

The SitePoint PHP blog has a new tutorial by Thien Tran Duy showing you how to run multiple versions of PHP all on the same server. The key is in using a few custom configuration options (you'll be compiling PHP manually for this) to place the different versions in different locations.

In this particular post, we'll demo a solution to install multiple versions of Phalcon and PHP and run them on a single web server. PHP 5.5.x and 5.6.x will be used here, but you can replace them with other versions. Any servers that support PHP-FPM should be enough but we recommend using Nginx. The environment used in this tutorial is Fedora OS - a Linux system, but the instructions are almost identical for any other *nix OS.

The tutorial also includes the installation of a few other PHP extensions including APC caching, memcache and ioncube. He walks you through the installation of Nginx first to get the web server up and running. Then he starts in on the PHP installs and the requirements to ensure you have to be able to compile from the PHP source. He shows how to pull the different versions of PHP down (5.3, 5.4, 5.6 and master) from the GitHub repository and execute the "buildconf" to make the configure script. He includes the example configuration command with options, ensuring it will work with PHP-FPM and the Nginx server. He then reproduces the process, making slight changes, for the other versions of PHP. Finally, he shows the installation of the two different versions of Phalcon and configuring it to all work with the installed web server.

0 comments voice your opinion now!
multiple version one server language tutorial phpfpm nginx

Link: http://www.sitepoint.com/run-multiple-versions-php-one-server/

Phil Sturgeon:
Composer It's ALMOST Always About the Lock File
November 05, 2014 @ 11:44:49

In his latest post Phil Sturgeon talks about a point that's been argued on both sides of the Composer users out there - whether or not to commit the "composer.lock" file. Phil talks some about it in his article and suggests that you should commit it for applications but not for components.

If you and your employees are a little vague with your composer.json specifications and you don't have a composer.lock then you can end up on different versions between you. Theoretically, if component developers are using SemVer and you're being careful then you should be fine, but keeping your lock in version control will make sure that the same version is on your dev teams computers. This will happen every time you run $ composer install. If you are on Heroku or EngineYard then this will be used for the deployment of your production components as a built in hook, which is awesome.

He mentions an article from Davey Shafik, this being his reaction to it. He suggests, though, that an absolute of "always commit for components" may be too much and could potentially cause other problems. He points out that since the "composer.lock" handling is local to the directory, you can hit up against version requirement issues between them in your application as a whole. He wonders "how strict is too strict" when defining dependencies and some things to think about (like your users) when making the choice to upgrade the libraries you use.

0 comments voice your opinion now!
composer composerlock file commit version semanticversioning semver component application

Link: https://philsturgeon.uk/blog/2014/11/composer-its-almost-always-about-the-lock-file

PHP.net:
New Supported Versions Timeline Page
October 29, 2014 @ 11:18:40

The PHP.net website has introduced a new feature to help make it a bit clearer which versions of PHP are supported and which have reached their end-of-life mark. This new Supported versions page off the main site provides listings of currently supported versions and graphical timelines of past (and future) support milestones.

Each release branch of PHP is fully supported for two years from its initial stable release. During this period, bugs and security issues that have been reported are fixed and are released in regular point releases. After this two year period of active support, each branch is then supported for an additional year for critical security issues only. Releases during this period are made on an as-needed basis: there may be multiple point releases, or none, depending on the number of reports.

The page includes information on when the initial release in a series was made (like the 5.4.x or 5.5.x series), when active support did/will end and how long the timeline is for security fixes and support. As of the time of this post, PHP 5.3.x is the only series that has reached end-of-life, but the 5.4.x series is coming close being in security fix only mode now and EOL-ing completely in ten months.

0 comments voice your opinion now!
version support timeline page phpnet release bugfix security

Link: http://php.net/supported-versions.php

Pascal Martin:
PHP Version Statistics - October 2014
October 28, 2014 @ 11:23:13

Pascal Martin's latest post (in French, but the English version is coming soon) shares some statistics he's gathered around the usage of various software around the web, more specifically those involved in web-based applications.

I've collected statistics about the use of different PHP versions several times. The first time was in September 2011 and the most recent was in November 2013. At this point, PHP 5.2 still accounted for 34.4% of all PHP installations with PHP 5.3 moving up to 48.7%. This new data was collected the weekend of October 19th, 2014. At this point, the current stable versions of PHP are 5.4.34, 5.5.18 and 5.6.2. PHP 5.3 is no longer maintained (since August 14th 2014) and PHP 5.2 hasn't been supported for 4 years now.

He's broken up the statistics into a few different sections:

  • Web server software
  • Usage of major versions of PHP
  • Usage of minor versions of PHP
  • Versions in use under each of the major version numbers

He includes both the raw numbers (percentages) and some graphs showing the results in a bit more consumable fashion. It's interesting to see that, despite it being quite an old version now, PHP 5.3.x still has the largest share in the usage results.

UPDATE: He's posted the English version now as well.

0 comments voice your opinion now!
usage statistics oct2014 version major minor webserver

Link: http://blog.pascal-martin.fr/post/statistiques-versions-php-2014-10


Community Events





Don't see your event here?
Let us know!


podcast language symfony security library framework laravel release composer version artisanfiles opinion conference voicesoftheelephpant interview tool list community introduction series

All content copyright, 2014 PHPDeveloper.org :: info@phpdeveloper.org - Powered by the Solar PHP Framework