Dougal Campbell has a new post to his site with his own contribution to the "WordPress 10th Anniversary Blogging Project" - a remembrance of his history with the tool and where/when he first started using it.

The official 10th anniversary of the release of WordPress is May 27, 2013. It has been an amazing 10 years, during which WordPress evolved from a simple blogware to a very full-featured CMS (Content Management System), used to power some of the biggest and most popular web sites on the internet. All over the world, people are planning celebrations. As much as I like a good party, I thought this would also be a good time to celebrate WordPress by actually using WordPress - for blogging.

He talks some about when he got started with WordPress (2003) and what's happened since. He suggests that others follow suit and use the "#wp10" hashtag on Twitter to share their own posts.

There's been a few articles posted on various blogs in the PHP community recently about the "most correct" usage of the "private" scope in your PHP applications. As with any feature of just about any language out there, there's people on both sides of the fence. Here's the ones that have weighed in so far:

• Brandon Savage's initial post (an excerpt from his upcoming "Do This, Not That" book)
• A response to this from Anthony Ferrara
• Brandon's own response to comments on his previous article
• This new post from Larry Garfield and some of his experience from the Drupal world

Various topics come up during these posts including static coupling, using interfaces versus inheritance, wrapper classes and developer intent.

A new blog has started up that mentions some of the "masterpieces" that occur in the PHP manual - phpmanualmasterpieces.tumblr.com:

Sparkling gems found in the official PHP documentation, mostly in the user-submitted comments. Not meant to pick on anyone, just to serve as a source of wonderment.

There's already several posts to the blog including:

• Here's my int, so cast it maybe
• Two quotes that make me sad
• Two's Complewhat
• The documentation clearly says raptors

You can subscribe to their RSS feed if you'd like to keep up.

On NetTuts.com there's a new article posted that introduces you to the concept of a persistence layer in a PHP application:

One of the most confusing design pattern is persistence. The need for an application to persist its internal state and data is so tremendous that there are likely tens - if not hundreds - of different technologies to address this single problem. Unfortunately, no technology is a magic bullet. [...] In this tutorial, I will teach you some best practices to help you determine which approach to take, when working on future applications. I will briefly discuss some high level design concerns and principles, followed by a more detailed view on the Active Record design pattern, combined with a few words about the Table Data Gateway design pattern.

Included in the post is a high-level application design with the business logic is at the core and the persistence technology/layer exists outside of it. They show how to create a simple, working solution for a persistence layer to handle a blog post and its contents. It talks about characterization tests, the table gateway design pattern and the possible move to the active record pattern.

On the NetTus.com site today there's a new tutorial showing how to use the Slim microframework to create a flat-file blog system as a stand alone PHP application.

In this article, we will learn how to create a flat file blog engine in PHP using the Slim framework. If you don't understand the jargon, don't worry. We're simply going to create a spartan blogging application, which utilizes text files instead of a database to store data. If you're a beginner, fret not! We will start with the basics of using Slim.

He introduces the Slim framework with a simple route handling to render a basic PHP page (an "About" page), setting variables to output to the template, setting up dynamic routes and creating the setup for the blogging engine (viewing articles, archives and a listing page).

On his blog today Rafe Colburn shares a list of engineering blogs he follows to keep up with various technologies companies are using and the interesting things they find out in using them.

One of my favorite technology trends of the past few years has been the emergence of engineering blogs. They are, mostly, a recruiting tool, but that doesn't mean that you can't learn a lot about how companies operating at varying levels of maturity and scale go about their business.

Some of the blogs on his list include:

• Ety's "Code as Craft"
• Facebook's blog
• SlideShare
• Twitter

You can check out the full list here.

On PHPMaster.com today there's a new tutorial from Alejandro Gervasio about using virtual proxies in your application - a method in development that provides a layer of abstraction on top of domain objects and makes it more efficient to work with (and lazy load) them.

Often referenced by a few other fancy names, the substitute is generically called a virtual proxy, a sort of stand-in that exploits the neatness of Polymorphism and interacts with the actual domain objects. Proxies aren't new to PHP. Doctrine and Zend Framework 2.x make use of them, although with different aims. On behalf of a didactic cause, however, it would be pretty instructive to implement some custom proxy classes and use them for lazy-loading a few basic aggregates from the database, this way illustrating how virtual proxies do their stuff under the hood.

He starts off by setting up a domain model for a "Post" and "Author" - a typical blog example.Based on the definition of these classes, he creates a mapper class to generate Author objects and an "AuthorProxy" class that uses a "loadAuthor" method to only load in the author's details when a property is requested. He gives a bit more code showing it in action and the difference between using the normal Author and AuthorProxy class.

Matthew Weier O'Phinney has a new post to his blog walking you through the creation of his own Zend Framework 2 blogging platform that works with git branching and page generation to get the job done.

Why write something of my own? Well, of course, there's the fact that I'm a developer, and have control issues. Then there's also the fact that a blog is both a simple enough domain to allow easily experimenting with new technology and paradigms, while simultaneously providing a complex enough domain to expose non-trivial issues.

He realized that he wanted a platform that was not only something he wanted to maintain but that also allowed him to write how he wanted to write - no more in-browser editing, just working with text files and generated page output. He shares some of the thoughts behind the different parts of the blog software - the domain model, his PhlyBlog module and the updated code he used to override some of the functionality in this default module. He also describes his new blogging process which includes git branching, creating a PHP "post" file, regernerate the blog via a command-line tool and merge and deploy.

This time last year, several members of the PHP (and wider) community wrote up blog posts titled "The Ideas of March". The idea was to blog about blogging and try to kickstart others and encourage them to get back on to blogging again. Here's a list of the people who have posted so far:

• Wez Furlong
• Lorna Mitchell
• Cal Evans
• Chris Cornutt
• Tom Mairs
• Jason Lotito
• Drew McLellan
• Sean Coates
• Chris Shiflett
• Joshua Thijssen
• Kevin Bruce
• Cameron Moll
• Aaron Pinero
• Nick Sloan
• Rafael Dohms
• Bart-Jan Verhoef
• Michiel Rook
• Web Standardistias
• Joshua Taylor
• Katy Watkins
• Shane Carmody
• Rachel Shillcock
• Rian van der Merwe
• Praveen Kumar
• James Trevor

This list will be updated throughout the day as more posts show up. Have a post you don't see mentioned here? Let me know!