On the Delicious Brains site, there's a tutorial posted asking WordPress plugin developers if their code is ready to work with Gutenberg, the next major release of the editor used in the popular blogging tool and content management system.

WordPress 5.0 is right around the corner with the flagship feature, the new Gutenberg editor, set to change the WordPress landscape dramatically. Gutenberg not only impacts how you write content in WordPress, but how developers build plugins for WordPress.

[...] In this post I’ll walk you through the process I took for making Intagrate, my Instagram WordPress plugin, Gutenberg-compatible, which will hopefully get you started on making your own plugins Gutenberg-ready.

The post starts with some general things to consider about Gutenberg's functionality as compared to the classic editor and some key places to check in your own plugins. They then provide a guide to testing your plugin by installing the standalone editor package. It then walks through the three main places to check functionality:

• custom post types
• custom meta boxes
• TinyMCE

The post ends with some suggestions of possible enhancements such as making use of shortcodes and converting custom meta boxes.

The StarTutorial site has posted the latest in their "Modern PHP Developer" series of posts outlining some of the more recent changes to PHP and its ecosystem that can help you become a better developer. In this latest post they focus on Exceptions in PHP - the types, handling them and when they're most useful.

Since PHP 5 was released, Exception is added to PHP as an object-oriented programming language feature. By definition, an Exception is an exceptional event during program execution. In PHP, an Exception is simply an object (an instance of Exception class). When an exception occurs, PHP will halt current execution flow and look for an handler, and then it will continue its execution by the handler's code. If no handler is found, a PHP Fatal Error will be issued with an "Uncaught Exception ..." message and the program terminates.

The tutorial is then broken down into several parts:

• When to use Exception
• How to use Exception
• Create your first custom exception 5.3
• SPL exceptions
• RuntimeException

For each item in the list, there's a summary of the topic and code examples to help illustrate the points made.

StarTutorial has continued their "Modern PHP Developer" series of tutorials with their latest covering the use of Iterators for working with sets of data.

If you have used a for loop in PHP, the idea of iteration is most likely not foreign to you. You pass an array to a for loop, and perform some logic inside the loop, but did you know that you can actually pass data structures other than arrays to a for loop? That's where Iterator comes into play.

The tutorial starts by introducing some of the basic concepts of what iterators are and how they're represented in PHP in their most basic form: arrays. They cover some of the basic array handing and functions before getting into the actual Iterator object handling. The article is then broken up into a few parts covering iterators and their functionality:

• Your first iterator class
• Why iterator?
• SPL Iterators
• ArrayObject vs SPL ArrayIterator
• Iterating the File System
• Peeking ahead with CachingIterator
• Generator

Code and a summary of the functionality is included in each section providing you with a great start towards using iterators over simple arrays in your modern PHP applications.

On the TechBeacon site there's a new tutorial posted sharing a list of nine ways to master awful code and make it more efficient, easier to maintain and clearer.

You've been given the task of implementing a new feature on an old codebase, but the code looks awful. How can you understand it as quickly as possible? Here are several shortcuts to help learn the important parts of new code without getting lost in the irrelevant details.

Their suggestions range from technical to non-technical and include:

• Ask for help
• Make it easy to reproduce bugs (add version control, build environments)
• Prepare for automated testing
• At first, work on a small task

For each item in the list there's an explanation and links (or screenshots) of other resources to help illustrate their point.

On his Medium.com site, Adnan Ahmed has shared some of his thoughts about being a modern backend developer in 2018. In it he talks about the current state of backend development and makes some recommendations for those wanting to get started.

Web development today is completely different from what it was a few years ago; there are lots of different things that can easily baffle anyone entering into the web development. It was one of the reasons that we decided to make these step by step visual guides demonstrating the bigger picture and to give anyone a clear idea about what they have to follow to be in certain roles in web development.

The post starts with a large infographic showing the basic steps and some of the related technologies and concepts to go with them. Following this they break it down into more detail in a text form with summaries attached for each. There are a lot of topics in the list (24 of them) but here's some of the highlights:

• Learn a Language
• Learn a Package Manager
• Standards and Best Practices
• Security
• ?Learn about the Relational [and NoSQL] Databases
• Learning a Framework
• Caching
• RESTful APIs
• Different Auth Methods
• GraphQL [and Graph Databases]

His final recommendation is one that's good for beginners and veterans in the software development world alike: "keep exploring". If you stop learning and stop trying new things you'll stagnate in your own work and career. Challenge yourself to learn something new - a new language, tool or technique - as often as possible and apply it to your work.

PHPStorm users out there might want to check out this list of helpful hints from the Stitcher.io blog covering some "lesser-known-yet-powerful features" of the IDE that could help improve your daily workflow.

Their list includes:

• binding keys to pane display preferences (ex: floating, windowed, etc)
• namespace auto-importing
• "copy path" of the current file
• defining custom JVM options
• inspection of why a term/word is syntax highlighted

Each of the items on the list comes with a description of where to make changes and animated GIFs of where to find it in the interface and what it looks like. If you're not a PHPStorm user and want to find out more about this IDE offered by JetBrains, check out this page on their website.

In a post to his site just before the new year Patrick Louys shared some of his thoughts about how to become a better developer in 2018 as a sort of programming-related New Year's resolution.

Do you have any programming related New Year’s resolutions? A lot of people don’t follow through with their resolutions. But don’t let that discourage you. When you make resolutions, you are much more likely to achieve your goals (10x more).

I wrote this post to show you how you can achieve your programming New Year’s resolutions. Every year I have been writing down my goals, for over a decade. It helped me grow a lot in my personal and professional life. It’s not just about setting goals and achieving them. You have to pick the right goals.

He begins by making a few recommendations when it comes to setting goals and how to set yourself up in your day to day work to achieve them. He then relates this back to programming goals, suggestion you focus more on patterns and practices rather than specific technologies (unless they're relevant to your work). He also recommends several books to read during 2018 to either learn new concepts if you're just starting out or wanting to refine your own skills.

On the Toptal.com site they've posted an article from Fernando Martinez with some suggestions about how to attract and retain software developers. The ideas cover the full range - all the way from the job posting/interview process out to how to keep them with the company and help them thrive in their role.

Management is all about people. Whether managers or employees, both are thinking about how to achieve their personal and professional goals. The combination of these goals and the personal traits of the people involved give shape to relationships that, in time, can be positive, productive, and fulfilling, or sometimes just plain stressful, demanding, and conflict-prone.

[...] This is especially true in managing software developers, because of their job’s technical complexity and creative nature, compressed into often narrow timelines for producing results. [...] In this article, we will focus on the main management aspects, rather than on the technical ones, that we think should be considered by anyone who wants to be successful in managing to retain software developers.

He starts with a look at how to attract and hire the right people for the roles you're trying to fill with suggestions about the interview process and the job offer. Next he gets into recommendations about managing the team itself and the importance of training, organization and communication. The article then goes on to cover other topics like conflict management, keeping up motivation and assigning objectives/follow up.

The North Meets South podcast, hosted by Jacob Bennett and Michael Dyrynda, has posted their latest episode: Episode #32 - Conventions, configuration, and becoming a lead developer.

Topics mentioned in this show include:

• Laravel's Responsible Interface
• An article about the ex-Googler's manifesto
• Computed properties in Vue.js
• the osTicket ticketing system

You can listen to this latest episode either using the in-page audio player or by downloading the show for listening offline. If you enjoy the show, be sure to subscribe to their feed and follow them on Twitter to get the latest updates when new episodes are released.

On thePHP.cc blog Stefan Priebsch offers up an interesting opinion about code, developers and understanding - developers shouldn't code.

The ultimate problem with program code seems to be that no human really understands it. Sure, we can look at a short piece of code and be relatively clear on what it does, but can we still do the same thing with programs that span tens or even hundreds of thousands of lines?

[...] Well, sometimes I get a strong feeling that there is a shortage of good programmers, because I often find myself looking at legacy code, being unable to tell what it does, at least with reasonable certainty. [...] Personally, I already consider code to be problematic when there is a reasonable amount of doubt as to what it does (and why it exists). To me, uncertainty and discussions are a sure sign of bad code. Call me picky, but years of experience have taught me that this level of strictness makes sense.

He suggests that the fact a developer cannot recognize what current code is doing doesn't make you a poor developer, but the opposite. He talks some about the meaning of the word "code" and how it is written for a machine to understand, not a human. He ends the post talking about testing your code to provide an "executable specification" and, despite having this, a human-readable spec is still a requirement (like it or not).