Free Intro Course Plus Resources

So You Want to Learn WordPress Development

WordPress development is a hugely useful skill, but it’s also tricky to learn—especially if you learn things out-of-order and try to tackle advanced topics while remaining confused on the fundamentals.

This free WordPress development course is designed to get you familiar with the basics of how WordPress works as a technical system. Because we start at the beginning, this WordPress development course is the right foundation for you to learn WordPress development as quickly as possible.

You should also know that this course is just a small preview of our flagship guide to WordPress development, Up and Running. If you’re serious about learning, Up and Running is the best WordPress development course available.

This free course can get you started and oriented to the basics of WordPress development, starting with: What is WordPress, and what does it do?

1. Beginning at the Beginning: What WordPress Is

To learn WordPress development, you need to know what WordPress is. Our “factory analogy” is the best overall explanation we’ve found for what WordPress, as a technology, is and does.

WordPress is a Factory: A Technical Introduction

Summary: What WordPress Is

WordPress is a factory that makes webpages.

To start learning WordPress development, start by knowing what WordPress is, meaning what it’s useful for. (Yes, it’s a PHP-based, open-source content management system, but what does it do?)

The best definition we’ve found is an analogy: WordPress is a factory. Specifically, WordPress is a factory that makes webpages, by taking raw material from the database and processing it through various “factory lines”—WordPress’s core code itself, plus additional code from both themes and plugins—all to generate a finished product ready to send to the user’s browser.

The Factory Analogy in Detail

Here is more detail on the “WordPress is a factory” analogy as a tool to help you learn WordPress development:

1. The environment of the WordPress factory is the server, the computer connected to the internet that everything is stored on. (“Buying hosting” means buying space on a server.) The server takes production requests from clients—users running web browsers—and is responsible for assembling a completed product ready for the web browser to display to the user.
2. The WordPress factory’s primary raw materials are its posts, and its warehouse (where it stores these raw materials) is the MySQL database.
3. In response to a production order from the browser (“assemble and send back the completed webpage corresponding to the URL I’ve just requested”), WordPress fetches the correct raw materials from the database.
4. WordPress sends that raw material down the factory’s assembly lines, which are the bulk of WordPress’s code itself. These give the webpage its inner workings: the fundamentals of what data it will include, and in what order.
5. WordPress has assembly lines specifically for handling display: how the product will be “painted” to appear to the user (regardless of its underlying data). These appearance-focused assembly lines are the PHP template files of the WordPress theme.
6. The factory can call on specialized outside contractors for specific jobs. These are WordPress plugins, and they can enter at any point in the factory process using WordPress’s hooks system.
7. The finished product is the full HTML markup necessary to display a webpage. The factory ships this product to the requesting user’s browser on every page load.

Read the article to understand the WordPress factory analogy in more detail. If you absorb the analogy deeply, you’ll have an uncommonly good picture of what WordPress is, and that’s the right first step in learning WordPress development—even before looking at code.

2. How to Program in WordPress: WordPress’s Four Key Technical Languages

The next step in your WordPress developer training is to know what programming languages you’ll be using. This next article introduces the four most important technical languages in WordPress—HTML, PHP, CSS, and JavaScript—and outlines what each one does.

The Four Languages You Must Know to Understand WordPress

Summary: WordPress’s Four Technical Languages

This basic WordPress development course can’t teach you coding languages in depth, but it can let you know which languages to learn, and what they do.

In order of importance, these are the four technical languages used in WordPress development:

1. PHP, the main programming language of WordPress. PHP is the primary language that the WordPress software itself is written in, the primary language of WordPress themes and plugins, and the language you’ll be writing most as a WordPress developer.
2. CSS, a declarative langauge controlling presentation, how webpages look to the user. CSS can control virtually every aspect of presentation, from sizes to margins to colors to fonts to responsive behavior on different devices. When you want to make a WordPress site look a certain way, CSS starts where page builder features and theme options stop.
3. HTML, the language of the web. HTML is a declarative language that web browsers interpret to turn a stream of code into a visible webpage with text, images, and everything else. If you don’t understand HTML, you certainly can’t do WordPress development in depth, but it’s also true that much of the time you’ll be writing PHP whose function is to turn itself into HTML, rather than writing HTML directly.
4. JavaScript, for programming the front-end. JavaScript is a very powerful programming language that can be used for all sorts of things, but a WordPress developer will use it mostly to control dynamic aspects of presentation—things that involves interacting complexly with the user as he or she visits your webpages. As cool as this sounds (and is), you can get an awful lot of WordPress development done without knowing more than very basic JavaScript, so learn the other three languages first.

3. How WordPress Talks to Your Web Browser: “Server-Side” and “Client-Side” in WordPress

One key element of how to learn WordPress development quickly is to get a good grasp of which parts of WordPress’s processes live on the user’s computer (“client-side”), and which parts live on the web server hosting the site (“server-side”).

Understanding “Server-Side” and “Client-Side” in WordPress

Summary: Server-Side and Client-Side in WordPress Development

Many very confusing questions in learning WordPress development—such as “Can the user see the PHP I write?”—can be solved by understanding how the server side and the client side interact within WordPress.

In brief:

Server-Side Processes

Server-side processes are anything that happens on your server: the computer connected to the internet (and probably leased from a web host) that you host your website on.

Important server-side processes include:

• Putting information into and fetching information from the WordPress database, the MySQL database that stores most of your site’s data.
• The entirety of WordPress’s PHP processing: the server moving through the logic spelled out by WordPress’s thousands of PHP files, as well as by the PHP files in your themes and plugins. This all happens on the server—browsers can’t read PHP—and only when it’s transformed into usable HTML (as well as JavaScript and CSS files and some other things) does it get sent back to the client to construct a webpage from.

Client-Side Processes

Client-side processes happen in the environment of the client: the computer (or phone, or whatever) asking the server for stuff, and usually turning that stuff into viewable and interactable webpages.

Important client-side processes include:

• Making requests for resources—everything from HTML markup to CSS stylesheets to JavaScript files to image files and more.
• Rendering received HTML, CSS, images, and more into a human-viewable webpage.
• Handling user interactions of all kinds through things like HTML forms, CSS pseudoselectors, and especially through JavaScript.

As you learn WordPress development, you’ll learn in depth how the server and the client engage in an ongoing flow of data. Read the full article for more information and a detailed diagram.

4. WordPress Development Core Principle: WordPress’s Hooks System

As you’re learning WordPress development, you’re almost immediately going to want to understand the foundation of WordPress’s event-driven programming system: WordPress hooks, also known as actions and filters. We’ve written a free WordPress development course on hooks that we believe is the clearest guide out there to this crucial topic in WordPress development.

Course: A Complete Introduction to the WordPress Hooks System

The Fundamentals of WordPress’s Hooks System

First off, you should know that this topic is difficult to grasp at first. It’s probably the most confusing single system to learn in WordPress, at least among the systems that a WordPress developer needs to deal with on a daily basis.

Hooks Let You “Hook Into” Any Part of WordPress

In WorPress, a hook is a specific type of PHP function that basically means “insert or modify code here.” You can “hook into” any part of WordPress’s functioning and insert your own code.

WordPress Has Two Types of Hooks: Action Hooks and Filter Hooks

Action hooks let you hook in and do something arbitrary—for example, add a CSS stylesheet or a JavaScript file, or run any other PHP code you want to run.

Filter hooks let you hook in and modify something—for example, modify the title of a given post before it’s printed onto the webpage. Filters always give you something to work with, and ask you to modify it and give it back.

To Use Hooks, Write Hooked Functions

There’s a specific syntax that lets you add your own code onto an existing WordPress hook. You write that code in the form of a hooked function: a function that “hooks in ” your code.

For action hooks, we write action functions, and hook them in with WordPress’s add_action() function. An example is:

add_action('wp_footer', 'wpshout_action_example');
function wpshout_action_example() {
	echo "WPShout was here.";
}

For filter hooks, we write filter functions, and hook them in with WordPress’s add_filter() function. An example is:

add_filter( 'the_title', 'wpshout_filter_example' );
function wpshout_filter_example( $title ) {
	return 'Hooked: ' . $title;
}

Further reading on hooks: We’ve created a whole free course exploring this super-crucial concept. Have a look as you get further into WordPress development.

5. First Applied Topic Area: WordPress Theme Development

Okay, you understand what WordPress is (a webpage factory), you understand what languages you need (mostly PHP), you understand what lives where (client-side and server-side), and you understand the basic event-driven system (hooks) that makes the whole thing tick.

You’re ready for the next step in our basic WordPress developer course, which is to learn the fundamentals of WordPress theme development.

This is a Course all unto itself, which will introduce you to the key foundational concepts of WordPress themes: the template hierarchy, The Loop, and functions.php.

Course: WordPress Theme Development (Core Concepts)

Further WordPress Development Courses

We’ve been happy to offer this free WordPress development course. You should now have a much clearer sense of the fundamentals of WordPress development.

If you liked this and really want to understand WordPress development fully, Up and Running is the best WordPress development course there is. Real clarity in WordPress development starts here.

And, of course, WPShout has a huge collection of free resources to help you to learn WordPress development as deeply as possible. Our other Courses, in particular, are organized to help you learn key WordPress development topics in a step-by-step fashion.

Have a look around and enjoy, and if you have any questions about how to learn WordPress development, we’d love to hear from you in the comments below, via email, or in our Facebook group. Cheers!