Skip to content

10 Things Every Good Web Developer Should Know (A Checklist)

January 31, 2012

10 Things Every Good Web Developer Should Know (A Checklist)

10 Things Every Good Web Developer Should Know (A Checklist)

My favorite thing about web development is the wide variety of skills it uses. Being a good developer means staying on your toes and always learning, because there are so many important skills and these are constantly changing.

Here’s a checklist of 10 skills that are some of the most important for good web developers to have. These focus a bit on front-end skills, but they apply to all developers:

  1. Regular expressions
  2. Basic SEO
  3. A good Javascript library
  4. Cross-browser debugging
  5. Image processing and optimization
  6. Layouts with valid HTML/CSS (and no tables)
  7. Copyright / cyber law basics
  8. Apache rewrites
  9. Debugging software
  10. Version control

1. Regular expressions

regex

Regular expressions are used to parse strings, basically to find and replace bits of text. While this may seem trivial, the versatility of regex makes it quite powerful. There are a wide variety of methods for optimizing a regex string, which can mean huge performance differences for your app.

Regular expressions can be used with just about any language, they work great with Javascript’s replace() and PHP’s preg_replace() to name a few. They are also great for Apache rewrites.

It’s surprising how few web devs use regex considering how useful it is. So if you haven’t already, make sure to learn regular expressions.

2. Basic SEO

SEOmoz

A knowledge of basic SEO is essential for any good web developer. While you can leave keyword research to your clients, a developer should have sound strategies for targeting those keywords on the page. This means clean markup and good use of <title>, <meta>, <h1> and <h2> tags on the front-end, as well as solid link and directory structure organization on the back-end.

The best resources I’ve found for learning SEO are the Beginner’s Guide to Search Engine Optimization and Search Engine Ranking Factors v2, both from SEOmoz.

3. A good Javascript library

jQuery javascript library

Even if you don’t write much Javascript, knowing a good Javascript language can make that little bit so much easier. Whether it’s jQuery (my personal favorite), Mootools, or whatever, learning a Javascript library will cut your Javascript dev time in half. First, these libraries take the cross-browser guess-work out of Javascript programming so you can stop feature checking and start animating. Additionally, they provide a ton of easy animation options and make selecting nodes in the DOM a piece of cake.

More adventurous Javascripters might even want to tackle a Javascript UI language. There are plugins for the libraries above, but I’d recommend Dojo with Dijit.

4. Cross-browser debugging

cross-browser

In order to reach as many viewers as possible, your websites need to work in all the major browsers (IE6, IE7, IE8, FF2, FF3, Safari 4, Opera 9). Everyone hates cross-browser debugging, but the better you get the less you’ll have to do it.

The best cross-browser debugging is preventative, starting with valid HTML and a good reset stylesheet. For my reset CSS, I just use * { margin: 0; padding: 0 } but you can also use a more robust option.

Beyond this it helps to understand the various quirks specific to certain browsers. Top of this list is usually Internet Explorer, and in particular IE6 (yes, still). And while most IE issues boil down to the infamous haslayout bug, you shouldn’t rely on something heavy-handed like * { zoom: 1 } to solve these.

5. Image processing and optimization

photoshop

Although most developers rely on professional designers for design assets, it is just as important for devs to know their way around Photoshop. A strong knowledge of image processing not only allows you to make quick changes to comps without bouncing them back to the designer, it also helps you to understand what is possible when asking for design changes.

One Photoshop skill that is particularly important for webdevs is image optimization. Image file sizes are probably the largest threat to bandwidth and optimizing images can make or break a site’s load time. Photoshop and Illustrator’s “Save for Web” option makes image optimization a lot easier: simply press Ctrl-Alt-Shift-S on PC or Command-Alt-Shift-S on Mac to access this wizard.

6. Building layouts with valid HTML/CSS (and no tables)

CSS box model

Let’s face it: it’s not 1996 and even back-end developers need to know how to write good front-end code, meaning valid HTML and CSS—not a bunch of tables. The markup should be clean and validate according to it’s doctype and the CSS should be separated from the HTML, which means no inline styles and especially no <font> tags.

For starters learn the various CSS tags and the CSS box model. From there you should learn W3C specifications on how to write valid code.

Whenever you write HTML it should naturally be valid xHTML; meaning properly nested nodes, closed image tags with specified alt attributes and other basics. Then you can go on to learn which nodes can be nested within which, and other more complex validation issues. In the end you’ll find that the w3c’s HTML validator hardly ever throws an error, which is a really good feeling.

7. Copyright / cyber law basics

law

You don’t need a law degree, but it’s best for all developers to have at least a basic knowledge of copyright and cyber law wherever they do business.

Since websites are essentially publications, copyright issues tend to be the most common legal issue for sites. From user generated content with stolen Flickr photos to quoting paragraphs from the New York Times, it’s important to know when you’ll get sued, when you’ll get an angry letter and when you’re okay. It’s also good to know when to sue and when to send an angry letter :) .

Beyond copyright laws it’s good to understand privacy and COPPA regulations as well as read carefully through any agreements you have with registrars / hosting companies (and clients!).

8. Apache rewrites

apache http

Apache rewrites make it easy to take messy URLs and make them clean and easy to type (if you know regular expressions). You can take something ugly like index.php?section=about&page=bio and rewrite it to the much prettier: about/bio.

But beyond simply cleaning URL’s, Apache’s mod_rewrite can be used to quickly turn a simple page into a complete app with a directory structure. Simply rewrite the various query string variables to be directories, and you’re all set.

However be careful: Apache rewrite issues are notoriously hard to debug. The rewrites can’t provide any debugging info themselves and will often skip over info you include through other methods. So be aware, rewrites can cause a nightmare that you can’t track down.

9. Debugging Software

firebug debugger

A good debugger will make your web programming go so much quicker.

When it comes to the front-end, I like Firebug, which allows you to click elements on the page and analyze which styles are being applied and from which stylesheet. You can additionally add or remove styles on the fly, as well as edit the page markup.

Firebug also helps with Javascript debugging, providing a better analysis of Javascript errors, as well as a console for running Javascript on the fly and displaying output from console.log(). Finally it provides NET info, showing you the loading time of various front-end assets as well as anything that is 404′ing or otherwise not loading.

I don’t use a back-end debugger but I hear xDebug is good for PHP.

10. Version control

Mercurial VC

Last but definitely not least, every good developer should know and use version control. Version control not only is the best way to backup files as you work on them, it is really the only way to effectively collaborate with other developers.

Version control works by keeping a record of the changes in a directory’s contents. As you work you can commit any changes to this record, or roll back to any previous version.

I personally like distributed as opposed to centralized version control, since it provides two levels of VC: you can commit changes to your local repository and then push these changesets to a centralized server. This allows you to make a number of small or potentially unstable changes locally, then push a set of final changes to your team.

When it comes to distributed VC I like Mercurial, and for centralized I like Subversion.

No comments yet

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: