Cloudways Blog: Michelangelo Van Dam Digs Deep Into The PHP Community

On the Cloudways blog there’s a new post spotlighting a well-known member of the PHP community, Michelangelo van Dam and talking with him about his experiences and involvement in the community.

Michelangelo van Dam is the co-founder and CEO of in2it. He has been working with the PHP community for many years and has become an expert on PHP and Zend Framework.

Recently, Cloudways got a chance to interview him regarding his experience and how he got involved in the PHP community. He also shared different things related to PHP, including the change of WordPress from PHP to NodeJS and how it will change the internet landscape.

In the interview Michelangelo (DragonBe) answers questions about:

  • his experience as a coach in CoderDojo Mechelen
  • the easiest way to change your code from mysql to mysqli
  • opinions on WordPress‘ move towards NodeJs
  • advice to students thinking of starting a career as a developer

Check out the full post for more on these and the answer to other questions with this great member of the PHP community!

Site News: Popular Posts for This Week (12.25.2015)

Popular posts from for the past week:

  • Joshua Thijssen: My guide to commenting on
  • Laravel News: Laravel 5.2 is released!
  • Jordi Boggiano: New Composer Patterns
  • SitePoint PHP Blog: Sourcehunt PHP Xmas 2015: Give the Gift of Pull Requests!
  • Jordi Boggiano: The Road to Monolog 2.0
  • SitePoint PHP Blog: Easier Authentication with Guard in Symfony 3
  • Matt Stauffer: Middleware groups in Laravel 5.2
  • Lorna Mitchell: Relying on A Dev-Master Dependency in Composer
  • Voices of the ElePHPant: Interview with Marco Pivetta
  • Zend Blog: Running a PHP Cluster on AWS

  • Community News: Bulgaria PHP Conference 2015 Videos Posted

    This year’s Bulgaria PHP Conference has officially posted the videos from all of their sessions at this year’s event to the official conference website. There’s lots of great sessions from this year’s event including talks from Larry Garfield, Ilia Alshanetsky and Beth Tucker Long. The full list of videos is a bit long to have here, but here’s a sampling:

    You can check out the rest of the videos on the conference website or directly over on their Vimeo channel.

    Jani Hartikainen: Why is fixing bugs so slow? (and how to make it faster)

    On his CodeUptopia blog Jani Hartikainen has posted a great article with some of his thoughts about why fixing bugs is so slow and includes a few suggestions on how to make it happen faster and streamline the process for the future.

    Have you ever wondered why sometimes fixing bugs seems to take much longer than it should? When you finally find the problem, it turns out all you need is one small change. Yet, it took a lot of time to find what’s going on. This happens to me more often than I’d like.

    […] Why is it that sometimes fixing bugs takes a lot of work even when the problem is simple, and other times, it’s really quick to fix the problem – maybe even when it isn’t so trivial? Is there something we can learn from the bugs that are easy to fix, so that we could spend less time fixing bugs in general?

    He starts off by describing a typical bug fixing process after the initial discovery and reporting of the issue down to the actual fix being deployed. He then breaks down each of these six steps and provides more context around them:

    • Understanding the problem
    • Reproducing the bug
    • Finding the problematic piece of code
    • Identifying the root cause
    • Fixing the bug
    • Ensuring the bug is fixed

    He then goes back and talks about the pain points in this typical process citing things like a lack of good information around the bug and the time constraints that often come with the "time to fix" allowance. He makes some suggestions about how to gather better information around the issue before the fix begins and points to effective logging as one possible source. He also talks about how unit testing can help verify the bug is actually fixed and help to prevent and locate future issues. What Are Laravel Packages?

    On the site they’ve published a tutorial that explains Laravel packages – what they are and how you can create your own to seamlessly integrate with this popular framework.

    As a PHP developer, you may be interested in working with frameworks. Frameworks attempt to make the process of development easier by simplifying common practices used in the majority of developing web projects such as packages, modules, plug-ins, and even components (CakePHP).

    […] There are two types of packages; some are framework independent (stand-alone) and the others are for a specific framework. This tutorial will exclusively cover Laravel packages.

    They start with a look at what these packages are and how they integrate with the framework and your application. They also link to a few of the packages they’ve found useful in their development including an IDE helper and OAuth wrapper. With this knowledge in place the tutorial then gets into to creating your own packages, installable via Composer and using a Service Provider to set up configuration needs. The post ends with a look at integrating and enabling your package through the application configuration.

    Paul Jones: Configuration Values Are Dependencies, Too

    In this post to his site Paul Jones suggests that dependencies aren’t limited to just the libraries and tools you use in your applications, it’s also the configuration values that define it’s environment.

    As part of my consulting work, I get the opportunity to review lots of different codebases of varying modernity. One thing I’ve noticed with some otherwise-modern codebases is that they often “reach out” from inside a class to retrieve configuration values, instead of injecting those values into the class from the outside. That is, they use an equivalent of globals or service-location to read configuration, instead of using dependency injection.

    […] The effect, though, is global-ish or service-locator-ish in nature: the class is reaching outside its own scope to retrieve values it needs for its own operation. Likewise, one cannot tell from the outside the class what configuration values it depends on.

    He gives code examples of this in action, showing pieces of code directly accessing the configuration structure from inside the class functionality. His examples show direct configuration access (not great), using a "Configuration" object (a bit better) and, finally, what he sees as a more correct way: injecting them like any other value. Code examples are provided for each step in this evolution, helping to illustrate his point.

    Voices of the ElePHPant: Interview with Adam Culp (2)

    The Voices of the ElePHPant podcast has posted their latest in the interviews host Cal Evans does with members of the PHP community. In this latest episode Cal talks with Adam Culp, organizer of the Sunshine PHP Conference and the SoFloPHP meetup group.

    Cal and Adam talk about the two user groups that Adam helped to found and organizes and how they were started. They also talk about the conference that Adam started up, Sunshine PHP, why he started it and how it’s grown over the years. They also talk about the "themes" the different years have had and how he hopes people take what they learned back and contribute, both to their own work and open source.

    You can listen to this latest episode either through the in-page audio player or by downloading the mp3 of the show to listen at your leisure. Be sure to subscribe to their feed and follow them on Twitter to get updates with the latest episodes are released.

    Voices of the ElePHPant: It’s the Booze Talking: Contributing to Open Source

    The Voices of the ElePHPant podcast has posted their latest episode but this time it’s another in their special "It’s the Booze Talking" series. In this latest show they gathered together people from several PHP projects and other well-known individuals from the community:

    In this episode they talk about how they started in open source and contributing to projects. They also talk about some of their own definitions around what "contributing" means for open source and its projects. Cal also asks the group about how contributing to open source has helped (or hurt) their career. There’s also some discussion about leadership and management in open source projects. The group also shares some of the "worst" things they felt when making their first pushes to an open source project.

    You can listen to this latest show either using the in-page audio player or by downloading the mp3 directly. If you enjoy the episode and want to hear more (and other interviews with members of the PHP community) be sure to subscribe to their feed and follow them on Twitter.