Category: Articles (Page 211 of 258)

Personal opinions and how-to’s that I’ve written both here and as contributions to other blogs.

On Using Helper Files in WordPress

December 17, 2013 / Tom / 0 Comments

One of the things that I appreciate about certain application development frameworks is their approach to convention over configuration.

By that, I mean that they tend to take the approach of “a place for everything, and everything in its place” rather than setting a ton of variables in a set of different files to tell the core system where everything is located.

In my opinion, WordPress is a little bit of hybrid of this kind of stuff, but I tend to look at it in the direction of modifying configuration files.

After all, we have both `wp-config.php` and we have `functions.php`. Both of these serve their purpose, but `functions.php` can get specifically cluttered as a theme or an application grows.

Software is Malleable (Or “A Case For a Strong 1.0”)

December 12, 2013 / Tom / 0 Comments

The longer I’ve worked in developer – and the more developers with whom I’ve interacted – the more I recognize that we all share a single trait:

We want to get our project right the first time.

Of course, this looks different depending on the type of project, but the point remains: We want to make sure that we nail not only the larger details, but the smaller details correct for the first release.

Have we detailed all the features?
Have we tested across every single device?
Did we select the right font size?
Should this feature automatically work, or should it have an element exposed to control it?
…and so on

And even though this is true, I think that deep down we know it’s not really possible to achieve.

In fact, I’ve talked numerous times about what I call a strong 1.0 which is essentially the idea that you focus very hard on an MVP – trim the features, nail down the specifics for the first release, and then iterate.

And when it comes to that compulsive need that we – as developers (and probably designers, as well) – have, this can go along way in helping to make a better product.

Modular Procedural Programming The WordPress Theme Customizer

December 11, 2013 / Tom / 0 Comments

One of the things that I love about working with WordPress is the entire hook system – you know, the various `add_action` and `add_filter` calls that you can make in order to manipulate content prior to sending it up to the browser.

I think that it provides a really powerful mechanism for working content prior to saving it to. or retrieving it from, the database.

Now, to be clear, I’m not someone who thinks that everything should be object-oriented versus functional versus procedural. Generally speaking, I think that certain paradigms lend themselves to certain strategies more so than others.

Case in point: The fact that WordPress `functions.php` file is nothing more than a collection of functions is fine with me; however, I really like the fact that I can write plugins using object-oriented programming.

Anyway, one of the the things about the hook system is that it can result in writing repetitive code – which I’ll show in a moment – which can in turn make for very long, very tedious, and very redundant functions.

Or, more generally stated, it can result in less than stellar programming practices.

So when these situations arise, I try to look for opportunities that help to keep functions lean, but yet maintaining a purpose, as well as easy to follow. I think it pays off significantly when it comes time to read back through the code, maintain the code, and to document the code.

Fear The Publish Button (For Your Words and Your Code)

December 9, 2013 / Tom / 0 Comments

For aspiring bloggers, one of the things that we often hear in podcasts, read on other blogs, and in other articles is “Don’t Fear The ‘Publish’ Button,” or we read “just hit ‘Publish!'”

I get the idea behind that mentality – it’s mainly motivation for saying that nothing you write will ever be perfect, so write, hit publish, and you’ll get better as you go.

Embarrassed By The First Version!

There’s a lot of truth to that – you do get better as you go – but I think that this advice (any advice like it) should be taken with a grain of salt.

In fact, I’d go as far as to say that if you don’t have some type of healthy fear associated with hitting the publish button, then you may later regret some of the material that you’ve published.

Arguably, there are a lot of parallels in writing a blog post as there are to writing code: Publish too soon, and you have something that isn’t worth reading or using; Wait too long for complete satisfaction and you may never end up releasing anything at all.

Publishing a blog post, just like publishing code, is something for which you should have a healthy fear.

The CSS Single Responsibility Principle

December 5, 2013 / Tom / 0 Comments

In software development, there’s this set of principles called the SOLID principles. As with most things in computer science, it’s yet another acronym in which each letter stands for the following:

Single-Responsibility
Open/Closed
Liskov Substitution
Interface Segregation
Dependency Inversion

Though these ideas are geared towards software engineering and object-oriented design, there’s one principle that I think is relevant to front-end web development (well, actually a few but I digress for now).

Specifically, I think the idea of the single-responsibility principle is applicable to CSS – namely, within the popular LESS and Sass preprocessors.