If you are earning your living by coding, it’s often one of these languages that pays the bills. Nevertheless, true hackers frequently meander in other directions, exploring and discovering different paradigms and methodologies, sometimes to the most esoteric extremes.

“The most obvious common ‘personality’ characteristics of hackers are high intelligence, consuming curiosity, and facility with intellectual abstractions. Also, most hackers are ‘neophiles’, stimulated by and appreciative of novelty (especially intellectual novelty). Most are also relatively individualistic and anti-conformist.”

– Eric S. Raymond, The Jargon File

Even if you’re particularly devoted to one of the languages mentioned above, it is normal to be curious about what else is out there. As the end of the year approaches, I find myself thinking about learning – or at least become acquainted with – some less known, more experimental, programming languages.
I was originally planning on learning another programming language as a New Year’s Resolution, which is quite common among programmers. The most difficult task turned out to be choosing a particular language: there are so many out there which makes it very hard to decide.

This article deals with ten possible candidates, and it’s far from being an exhaustive list. The programming languages described henceforth are very different from each other, but they all have one thing in common: they all stimulate my curiosity in their own, very different ways.

#1. Haskell

I tried to learn Haskell in the past. Quietly, I started diving into the multitude of articles, tutorials, overviews and even books about this fascinating academic language which claims to achieve functional purity though remaining extremely useful, practical and efficient. Sadly, I’m still not able to fully grasp some of its most crucial concepts, such as monads, but this still doesn’t put me off wishing to learn the language.

If you’ve never enountered Haskell before, I find The Evolution of a Haskell Programmer an amusing and informative read. Although aiming to be humorous in a way, it serves a very important didascalic purpose: it is one of the most complete collections of the different paradigms and programming approaches Haskell allows.

Besides its very elegant, pragmatic and almost-magical syntax, what really intrigues me about this language is what it offers, in terms of features:

• 9 different implementations (multiple compilers and interpreters)
• Countless standard libraries packages which can be used to solve any programming challenge
• Abundant learning material
• Speed that rivals C and C++
• Very mature cross-platform compatibility

The catch? It is likely to be very different from any other language you might have encountered before, and that’s probably the reason why some people find it difficult to learn and master. That being said, if you are looking for a challenging (but very rewarding, I believe) New Year’s Resolution, you should definitely go for this.

To get you started…

• Official Haskell Wiki
• Haskell Wikibook
• Real World Haskell
• 37 Reasons to Love Haskell
• Haskell for the Ruby Guy
• A-Z of Programming Languages: Haskell
• Learn you a Haskell for Great Good!
• Haskell Hacking

#2. Erlang

Erlang is a concurrent programming language originally developed by Ericsson for their real-time applications. It goes without saying that with these premise, Erlang seems the most natural answer to all concurrency problems you may encounter in your life as a programmer.
Developing with concurrency in mind feels natural and easy in Erlang, and the performance of Erlang-powered systems can be unmatched.

Quite a few interesting applications have been developed in this language, such as:

• CouchDB, a popular distributed, document-oriented database
• Yaws, a high-performance web server
• even Facebook Chat

The price Erlang adepts have to pay, as Damien Katz (CouchDB creator and Erlang enthusiast) points out, is:

• Awkward syntax, inspired by Prolog
• Weird if expressions
• Difficult string operations
• No classes or namespaces

…this list could go on. Damien’s article is an interesting read, enough to put anyone off learning the language if read superficially. On the other hand, it provides an invaluable resource for newcomers who wish to be prepared before taking on the challenge of learning Erlang to build their next scalable, concurrent and industry-proof application.

To get you started…

• Official Erlang Web Site
• An Introduction to Erlang
• Erlang Style Concurrency
• PlanetErlang
• Erlang Projects

#3. Io

Io is a relatively new programming language by Steve Dekorte which recently surfaced from Google’s oblivion (if you tried googling for it a few months ago, you couldn’t event find its home page) thanks to a short vut stimulating article by _why. It doesn’t have the best name for a programming language, that’s for sure, but it’s definitely a breath of fresh air in terms of the way it works.

Its unusual, minimalist and yet elegant and powerful syntax reminds of Smalltalk, but the language goes far beyond that. Io is an object-oriented, prototype-based, message-based and fully-reflective programming language. This means that you use messages like in Smalltalk, you create objects like in Javascript and every bit of your code can be inspected and passed around as you see fit.

If you think Ruby allows fancy (and potentially dirty) tricks like metaprogramming and monkey-patching, Io takes this to a whole different level, imposing virtually no limitation to the programmer. What’s truly amazing is that its grammar and syntax are so minimal that you can learn them in literally 10 minutes. After that, you can start experimenting, first with its extremely small core and then with its extension libraries and bindings.

Io has indeed a lot of potential. Granted, it’s still young and under development, but also already quite efficient and suitable for real-world tasks demanding high speed and concurrency. It is implemented in C, but Ola Bini started to design a similar language called Ioke for the Java Virtual Machine.

To get you started…

• Official Io Web Site
• Io Repository on Github
• Io user group
• Io has a very clean mirror
• Io Notes
• Io Language Notes
• Blame it on Io! A slow-paced introduction to the Io language
• Io Wikibook

#4. PLT Scheme

I stumbled upon the PLT Scheme web site while browsing for different Lisp flavors about a year ago. At the time, I was determined to learn the rudiments of Lisp and I started reading a few articles and books on this old and yet still popular language.
Although I was originally put off by certain Common Lisp literature, which dismissed Scheme as an almost-heretic attempt to revitalize an venerable language, I soon found out that Scheme – and PLT Scheme in particular – is definitely worthy of attention and interest.

Being a technical writer, I immediately became fond of the PLT Scheme Guide, one of the clearest and most well-organized examples of documentation available for a programming language I’ve ever come across.
The manual is exquisitely crafted as a Getting Started Manual and a Reference Book at the same time, though remaining pleasant to read sequentially: a rare trait in technical documentation. Best of all, it’s free: you simply have no real excuse not to read it.

Besides its excellent documentation, PLT Scheme feels like a fresh and modern implementation of one of the two most important dialects of Lisp. It’s cross-platform, it has an extensive collection of packages and a very active community behind it.
After my first attempt to learn Haskell, I felt compelled to try out PLT Scheme and it immediately felt much easier and more user friendly to learn, partly because of DrScheme a dedicated IDE/learning tool optimized to get you started and feel comfortable with the language.
Caveats? None, unless you have an adversion for parenthesis, that is.

To get you started…

• Official PLT Scheme Web Site
• PLT Scheme Guide
• PLaneT
• Quick: An Introduction to PLT Scheme with Pictures
• More: Systems Programming with PLT Scheme

#5. Clojure

Clojure is the most recent and notable attempt to bring Lisp back to life and ready to face the challenges posed to IT systems by the new century: concurrency and scalability. Because it runs on the Java Virtual Machine, you also get Java interoperability for free, in a more Lispy flavour. Although I’m a bit reluctant to deal with anything related to Java nowadays, Clojure’s approach makes it more appealing.

Unlike other Lisps (and Schemes) you may have encountered before, Clojure comes with some interesting additions:

• Multimethods
• Agents asynchronous actions
• Some interestings special forms
• Many pre-built data structures, like Vectors, Maps, Sets, Collections, …

Despite all this, Rich Hickey became increasingly popular both in the Lisp and Java world for creating such an interesting and well-designed language. Unlike with many new (and old) programming languages, I have yet to find a single blog post or article which is seriously criticizing Clojure in any way.

To get you started…

• Official Clojure Web Site
• Clojure User Group
• Clojure presentation on InfoQ
• Trying Clojure
• My first look at Clojure
• Enclojure

#6. Squeak

Squeak has become one of the most popular Smalltalk implementations available. It has been used in some very interesting projects:

• EToys, a kids-oriented but powerful development environment built in Squeak, was included as part of the educational sofware suite of the OLPC.
• Seaside is a modern and very productive web framework running on Squeak.
• Croquet is a development solution to build complex, multi-user virtual worlds.

If you ask Randal Schwartz, he’ll explain you why Squeak and Smalltalk are at least worth a look. Personally, while I’m attracted by Smalltalk’s unique approach to programming and its friendly syntax, I am still a bit overwhelmed by the way it works.
Squeak, and Smalltalk in general, runs inside (literally) a virtual machine written in Squeak itself. This means that:

• You write your code inside Squeak
• You debug, inspect and interact your code inside squeak
• You run your code inside Squeak
• You can install Squeak on virtually any platform, including mobile phones, fairly easily

Everything lives inside Squeak. It’s very weird to picture this without actually trying it, so I suggest you download it and give it a try: it will definitely be an unusual but intriguing experience.

Smalltalk takes programming to a whole different level, which is simply unimaginable for other languages. In return, it asks you to fully embrace the Smalltalk way of doing things, according to which external text editors, external version control systems and other common tools familiar to traditional programmers simply loose their purpose.

To get you started…

• Official Squeak Web Site
• Squeak by Example
• SqueakLand
• Ruby’s Roots: Smalltalk Comeback and Randal Schwartz on Smalltalk
• FLOSS Weekly 29: Dan Ingalls

#7. OCaml

Like Smalltalk, OCaml has been getting more attention recently than in the past. Sure, not everyone is planning to learn is these days, but after reading this article I admit I was eager to give it a proper try.

Despite being statically typed, OCaml offers some of the features which are common in dynamically typed languages like Ruby, such as duck typing, the possibility of creating Domain-Specific Languages and even extending the language syntax with custom operators and constructs.

Additionally, the OCaml Batteries Included project was created as an attempt to bundle a standard set of commonly-used library together with the language core. Even if this project is still in alpha stage, it definitely looks promising.

To get you started…

• Official Caml Web Site
• Objective Caml Tutorial
• A Concise Introduction to Objective Caml
• The OCaml Alliance Network
• OCaml News
• OCaml Batteries Included

#8. Factor

Factor is to Forth what Clojure is to Common Lisp: a reincarnation of an ancient language in a more modern and practical form. In the specific case, although it borrows from Lisp and Self as well, Factor retains the main characteristics of its ancestor: it’s stack-based, concatenative and has postfix notation.
While this is enough to put some people off, if you digg deeper you’ll discover that Factor offers all the most important features available in contemporary programming languages: garbage collection, dynamic typing, an object system, … they’re just presented in a very different way:

“Learning Factor is tough. One reason for this is that Factor is very different from other programming languages. Programmers today are used to imperative programming languages where data is stored and passed around in named variables (or function calls, which name their variables). Factor is the opposite of this. A lot of code tends to be written in a functional style, and even more jarringly, variables are rare, only referenced in a small fraction of words. Nobody intends to change any of this; it’s a feature, not a bug!”

– Daniel Ehrenberg, Learning Factor

Like Haskell, Factor demands a completely different programming approach to what you may be used to, but once you get past that, it can be as useful as any other language, if not more. The Furnace web framework, which powers the Concatenative wiki, is entirely built in Factor and runs on top of a Factor web server.

To get you started…

• Official Factor Web Site
• Factor on the Concatenative Wiki
• Factor Documentation
• Learn Factor
• Planet Factor

#9. Lua

Lua (“Moon” in Portuguese), is a lightweight and fast scripting language which can be easily embedded in other systems. Compared to the other languages mentioned in this article, it is definitely the less alien of the lot: if you know a tiny bit of C or Java, you’ll be able to understand (and possibly write) 80% of Lua code without reading a single line of its documentation.

Despite its simplicity, Lua is considered a multi-paradigm language supporting imperative, functional and even object-oriented approaches. More specifically, Lua’s tables provide a simple but powerful way to create arrays, hashes and even classes (or better, prototypes). Simple (and multiple) inheritance is achieved through metatables, which allow calls to undefined functions to be transferred to parent tables.

Lua programs are not interpreted in the traditional way: they are compiled to bytecode and then executed in the Lua Virtual Machine. As a result, Lua code tends to be executed much faster than other interpreted languages, so fast that “as fast as Lua” has become a proverbial expression.
Lua found its niche in embedded applications and games development, basically everywhere there’s the need to provide a fast scripting language which is also very easy to learn and extend with C or other languages.

To get you started…

• Official Lua Web Site
• Lua Manual
• Lua-users
• Learning Lua
• Lua for Beginners

#10. Scala

You may not be happy to see Scala in this list instead of other very valid and equally powerful languages for the Java Virtual Machine such as Groovy. While there was no doubt on whether Clojure should have been included or not, I was a bit hesitant to include Scala. In the end, I chose to do so simply because Scala fits better in this list than other languages: as you should have noticed by now, I am somehow more inclined to learn functional languages as opposed to their object-oriented counterparts.

Scala is both object oriented and functional. It offers the best of both worlds: classes, traits and mixins which may be familiar to OOP lovers but also anonymous functions, currying and pattern matching which may please Haskell enthusiasts. Additionally, it’s also compatible with Java: so if you use Java for work, trying out Scala for pleasure is definitely the most logical next step, especially if you want to experiment with functional programming in the meantime.

Compared to learning a fully-functional (no pun intended) language like Haskell, Clojure or PLT Scheme, learning Scala is definitely easier and will feel less alien.

To get you started…

• Official Scala Web Site
• The Case for Scala
• Scala Wiki
• Learning Scala with Project Euler
• Roundup: Scala for Java Refugees

#11. Epilogue

There are so many interesting programming language out there that it’s very hard to keep track of all of them. I hope this list can aid you in the right direction, whichever it may be.
Some people may debate over the very essence of this article: why choosing a programming language? Why spending time and energy in a task which may lead to a lot of confusion in your mind and lead you nowhere? What’s the purpose of learning something which may feel totally alien to you?

A programming language is ultimately just a tool to get your job done. If you have to write an end-user, desktop GUI application which will always run on Windows and which needs to inteface with Microsoft technologies, you’ll choose C# over Haskell, there’s no doubt about that. Especially if 500 developers in your company already develop in C# and you don’t, as a matter of fact, have a saying on the matter.

But what if you could choose? What if you wanted to develop your own geeky command line application to automate a particular task for yourself, and not because someone else tells you to do so? Would you be willing to experiment with something totally different and potentially difficult just for the sake of learning new things?

If the answer is yes, then you should take a look at this list again. Not now, maybe not this month or this year, but when you feel the time is right, and give one of these languages a shot. It may not end well (so far I attempted to learn Haskell twice, with no luck), but I promise you it will be worthwhile, in the long run.
If you already mastered some of these languages already, or even all of them, be assured that they’re plenty out there ready to be discovered and open your mind even more. Or, if you prefer, there are a lot of minds out there which may need guidance in learning and discovery. Help them. Write articles, tutorials, books, educate and evangelize: ultimately, that will be your greatest reward.

Today, I’d like to talk a little about CSSLint, a recently released code analysis tool for, you guessed it, CSS. Join me after the jump!

What Exactly is a Lint?

Let’s hit Wikipedia for a definition:

Lint is a tool that flags suspicious usage in software written in any computer language.

Basically, a lint looks at our code and checks for bad programming practices. Undefined variables, inefficient constructs, things like that.

You’re probably wondering why you’d ever need such a tool. Let’s face it: not all of us possess supreme knowledge of what we’re working with or have the luxury of getting our code peer reviewed. In these cases, sticking our code in a lint is the next best option. And unlike clean up tools, lint spits out tidbits about your code and how to improve it.

Introducing CSSLint

Created by Nicholas Zakas and Nicole Sullivan, CSSLint is an open source tool that checks your syntax against a set of predefined rules to root out possible inefficiencies and make sure that your presentation works as expected with little surprises.

After heading over to the CSSLint site, you can merely paste in your source CSS and choose which rules you’d like enforced. Hit the lint button and CSSLint will start eroding your smugness.

If you’re a Node junkie like me, there’s a version for that as well. Just type in sudo npm install -g csslint and you’re good to go!

The CSS Lint Rules

Let’s take a quick look at the rules that CSSLint enforces.

• Parsing errors should be fixed
• Don’t use adjoining classes
• Remove empty rules
• Use correct properties for a display
• Don’t use too many floats
• Don’t use too many web fonts
• Don’t use too may font-size declarations
• Don’t use IDs in selectors
• Don’t qualify headings
• Heading styles should only be defined once
• Zero values don’t need units
• Vendor prefixed properties should also have the standard
• CSS gradients require all browser prefixes
• Avoid selectors that look like regular expressions
• Beware of broken box models
• Don’t use @import
• Don’t use !important
• Include all compatible vendor prefixes
• Avoid duplicate properties

If you’re anything like me, a few of the rules must have had you flummoxed.

Do the Rules make Sense?

Quite frankly, yes, no and everything in between.

After lurking at a number of discussion boards and IRC rooms, I found out that many developers seem to be in uproar over the rules and maybe right so. Let me attempt to explain why most of the rules make sense but others do not.

The Controversial Rules

Don’t use IDs in selectors

IDs shouldn’t be used in selectors because these rules are too tightly coupled with the HTML and have no possibility of reuse. It’s much preferred to use classes in selectors and then apply a class to an element in the page.

This one struck a nerve with a lot of developers since we’re quite accustomed to assigning IDs for the main structural components of a layout like the header and footer.

CSSLint argues that the styling for such elements, by definition, can’t be directly reused. If you want dual sidebars on your page, a class lets you reuse styling while an ID will not.

Keep in mind that just because a class can be reused doesn’t mean it has to be. Unique classes are perfectly acceptable and a swell way to reuse styling if the need arises.

Don’t qualify headings

Heading elements (h1-h6) should be defined as top-level styles and not scoped to particular areas of the page.

Most developers, including me, have gotten used to writing context sensitive headers. As in, we define separate styling for headers depending on, say, which page it is being displayed on. An argument in favor of this approach is that it moves all cruft from the markup to the stylesheet. You can merely define a tag and let the CSS cascade accordingly.

CSSLint argues that such an approach compromises the predictability of your design. If someone else were to pick up your design and tried putting in a heading somewhere, he/she would need to be aware of the context and placement of the element. With headings defined unconditionally, he or she can use a heading anywhere confident of its presentation regardless of its parents.

Heading styles should only be defined once

Heading elements (h1-h6) should have exactly one rule on a site.

An extension of the rule above to improve predictability of presentation. Right or wrong, keep in mind that this basically excludes including some sort of reset code within your stylesheet. Every reset sheet works on your headings as well and thus CSSLint will mark it as an error.

The Questionable Rules

Don’t use adjoining classes

Adjoining classes look like .foo.bar. While technically allowed in CSS, these aren’t handled properly by Internet Explorer 6 and earlier.

With this rule enabled, CSSLint flags rules like .nav.red, with the official reason being that Internet Explorer 6 and below don’t play well with the selector. I respect the developers but I have to disagree here. Just because it doesn’t work with Internet ‘Dev-buster’ Explorer 6 is not a great reason to stop working with a useful feature.

Beware of broken box models

Borders and padding add space outside of an element’s content. Setting width or height along with borders and padding is usually a mistake because you won’t get the visual result you’re looking for. CSS Lint warns when a rule uses width or height in addition to padding and/or border.

The box model maybe broken but almost every front end developer I know is intimately aware of the shortcomings and how to overcome the disparities with implementation. Are we really ready to give up a layer of control because some older browsers have a different implementation?

Don’t use too many web fonts

Using web fonts comes with performance implications as font files can be quite large and some browsers block rendering while downloading them. For this reason, CSS Lint will warn you when there are more than five web fonts in a style sheet.

I don’t foresee a situation where I’d be using more than five fonts in a page but I feel that dipping into this territory is a bit questionable. If anything, this is a design flaw than a development flaw. If a developer is referencing five separate fonts in his stylesheet, chances are, it ain’t by accident.

Don’t use too many floats i.e. abstract the functionality away

CSS Lint simply checks to see if you’ve used float more than 10 times, and if so, displays a warning. Using this many floats usually means you need some sort of abstraction to achieve the layout.

While I concur with the creators’ argument that having more than ten instances of float is a bad idea, I also feel that this will affect the markup once past a given size.

For example, in a situation where you’d want to float two elements, traditionally you’d use:

<div class="container-1"></div>
<div class="container-2"></div>

and the styling, by traditional methods.

.container-1 { width: 70%; float: left; }
.container-2 { width: 30%; float: left; }

The CSSLint method would be abstracting the float like so:

<div class="container-1 float"></div>
<div class="container-2 float"></div>

and styling like so:

.container-1 { width: 70%; }
.container-2 { width: 30%; }
.float { float: left;}

While I agree that this is a viable approach, I feel that the markup will get significantly crowded once you try to abstract more away. I’d rather see a class containing most of its styling in one place than clutter the markup with 10+ classes. Again, I feel that this is a subjective topic.

The Obvious Rules

• Remove empty rules
• Avoid duplicate properties
• Zero values don’t need units
• Vendor prefixed properties should also have the standard
• Parsing errors should be fixed
• Include all compatible vendor prefixes
• … rest of the rules

All of the rules above adhere to the current standard practices. Sure, some of the rules have little real world significance, like zero values not needing units, or will be caught by a decent IDE, like parsing errors, but nevertheless these are good rules to have in a CSS test suite.

A Few Concerns

CSSLint is, no doubt, written by developers with great credentials and is definitely going to help a lot of developers and designers down the road.

What I find a little irksome is that a lot of the controversial rules come from Object Oriented CSS, a CSS framework intended to let developers write maintainable CSS. While I have nothing against the framework, and its paradigm, you’d have to agree that it’s a way of doing things, not the way to do things.

As opposed to JSLint where I feel like all the rules make sense, with CSSLint, it feels like I’m being told that one style of writing CSS is right and the others are wrong. It’d be like someone asking me to give up the Beatles because Rolling Stones is their preferred band.

It’s Only a Tool

Of course, we, as a group, tend to be rather clingy when it comes to our code. We don’t enjoy hearing that our code could have *gasp* potential issues or be written in an entirely different way.

The main thing to make a note of here is that CSSLint is, ultimately, a tool. It merely lets you know that some of the areas may have errors.

CSSLint doesn’t have to be the iron fist around which you base your entire ego on. There’s no reason to bend over backwards to avoid a warning if you know precisely what you’re doing.

So, Should you Start Using CSSLint?

In CSS, as in integral calculus, there are many solutions to a given problem. There necessarily isn’t a ‘best’ way to do things — you may favor readability while I may favor efficiency. What’s important is that you realize that each and everyone of us have our unique way of doing things.

If you don’t have the same perspectives towards solving a problem, you may disagree with another approach and may even find it questionable.

Having said that, there’s never a good reason for not learning new things. Looking at problems from the perspective of another developer is a great way to see if you can learn something new.

Wrapping Up

What do you think about CSSLint? Find it useful? Confusing? Has it helped with your real world problems? Let us know in the comments.

Here’s a simple array of users:

$users = array();

$users[] = array('username' => 'shiflett', 'name' => 'Chris Shiflett');
$users[] = array('username' => 'dotjay', 'name' => 'Jon Gibbins');
$users[] = array('username' => 'a', 'name' => 'Andrei Zmievski');

There are a few different ways to create this array. Here’s the output of print_r($users), so you clearly understand the structure:

Array
(
    [0] => Array
        (
            [username] => shiflett
            [name] => Chris Shiflett
        )

    [1] => Array
        (
            [username] => dotjay
            [name] => Jon Gibbins
        )

    [2] => Array
        (
            [username] => a
            [name] => Andrei Zmievski
        )

)

If I want to sort by username, I first create a separate array of usernames:

$usernames = array();

foreach ($users as $user) {
    $usernames[] = $user['username'];
}

I then use array_multisort():

array_multisort($usernames, SORT_ASC, $users);

Here’s the output of print_r($users) after sorting by username:

Array
(
    [0] => Array
        (
            [username] => a
            [name] => Andrei Zmievski
        )

    [1] => Array
        (
            [username] => dotjay
            [name] => Jon Gibbins
        )

    [2] => Array
        (
            [username] => shiflett
            [name] => Chris Shiflett
        )

)

To sort the array by name instead, I’d do something very similar:

$names = array();

foreach ($users as $user) {
    $names[] = $user['name'];
}

array_multisort($names, SORT_ASC, $users);

Here’s the output of print_r($users) after sorting by name:

Array
(
    [0] => Array
        (
            [username] => a
            [name] => Andrei Zmievski
        )

    [1] => Array
        (
            [username] => shiflett
            [name] => Chris Shiflett
        )

    [2] => Array
        (
            [username] => dotjay
            [name] => Jon Gibbins
        )

)

There are many more uses of array_multisort(), and there are many other useful sorting functions. Please feel free to share some of your favorites in the comments.

CREATE TABLE
	member(user_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, name VARCHAR(20) NOT NULL);
INSERT INTO
	member (name)
VALUES
	('Vasim'),
	('Alice'),
	('Sumit'),
	('Sunil'),
	('Vipul'),
	('Pravin'),
	('Nikhil'),
	('Harshad');

CREATE TABLE
	friendships(friendship_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, initiator_id INT NOT NULL, reciprocator_id INT NOT NULL, UNIQUE(initiator_id,reciprocator_id));
INSERT INTO
	friendships
VALUES
	(1,1,2),
	(2,1,3),
	(5,1,6),
	(6,1,7),
	(9,2,1),
	(10,2,3),
	(13,2,4),
	(14,2,7),
	(17,2,8),
	(19,3,1),
	(20,3,2),
	(23,3,6),
	(24,3,8);

Then you can use ‘GROUP_CONCAT’ as following:

SELECT
	m.user_id, GROUP_CONCAT(f.reciprocator_id) as ids
FROM
	friendships f
JOIN
	member m
ON
	m.user_id = f.initiator_id
WHERE
	1=1
GROUP BY
	m.user_id;

And the result would be:

SELECT
	m1.name, GROUP_CONCAT(m2.name) friends
FROM
	friendships f
LEFT JOIN
	member m1
ON
	m1.user_id = f.initiator_id
LEFT JOIN
	member m2
ON
	m2.user_id = f.reciprocator_id
GROUP BY
	name;

And the result would be:

DDL is abbreviation of Data Definition Language. It is used to create and modify the structure of database objects in database.

Examples:

CREATE: to create objects in the database
ALTER: alters the structure of the database
DROP: delete objects from the database
TRUNCATE: remove all records from a table, including all spaces allocated for the records are removed
COMMENT: add comments to the data dictionary
RENAME: rename an object

DML:

DML is abbreviation of Data Manipulation Language. It is used to retrieve, store, modify, delete, insert and update data in database.

Examples:

SELECT: retrieve data from the a database
INSERT: insert data into a table
UPDATE: updates existing data within a table
DELETE: deletes all records from a table, the space for the records remain
MERGE: UPSERT operation (insert or update)
CALL: call a PL/SQL or Java subprogram
EXPLAIN PLAN: explain access path to data
LOCK TABLE: control concurrency

DCL:

DCL is abbreviation of Data Control Language. It is used to create roles, permissions, and referential integrity as well it is used to control access to database by securing it.

Examples:

GRANT: gives user’s access privileges to database
REVOKE: withdraw access privileges given with the GRANT command

TCL:

TCL is abbreviation of Transactional Control Language. It is used to manage different transactions occurring within a database.

Examples:

COMMIT: save work done
SAVEPOINT: identify a point in a transaction to which you can later roll back
ROLLBACK: restore database to original since the last COMMIT
SET TRANSACTION: Change transaction options like isolation level and what rollback segment to use

It’s difficult to demonstrate the value of patterns using small examples. They often look like overkill because they really come into play in large code bases. This article can’t show huge applications, so you need to think about ways to apply the principles of the example — and not necessarily this exact code — in your larger applications. That’s not to say that you shouldn’t use patterns in small applications. Most good applications start small and become big, so there is no reason not to start with solid coding practices like these.

Now that you have a sense of what design patterns are and why they’re useful, it’s time to jump into five common patterns for PHP V5.

The factory pattern

Many of the design patterns in the original Design Patterns book encourage loose coupling. To understand this concept, it’s easiest to talk about a struggle that many developers go through in large systems. The problem occurs when you change one piece of code and watch as a cascade of breakage happens in other parts of the system — parts you thought were completely unrelated.

The problem is tight coupling. Functions and classes in one part of the system rely too heavily on behaviors and structures in other functions and classes in other parts of the system. You need a set of patterns that lets these classes talk with each other, but you don’t want to tie them together so heavily that they become interlocked.

In large systems, lots of code relies on a few key classes. Difficulties can arise when you need to change those classes. For example, suppose you have a User class that reads from a file. You want to change it to a different class that reads from the database, but all the code references the original class that reads from a file. This is where the factory pattern comes in handy.

The factory pattern is a class that has some methods that create objects for you. Instead of using new directly, you use the factory class to create objects. That way, if you want to change the types of objects created, you can change just the factory. All the code that uses the factory changes automatically.

Listing 1 shows an example of a factory class. The server side of the equation comes in two pieces: the database, and a set of PHP pages that let you add feeds, request the list of feeds, and get the article associated with a particular feed.

interface IUser
{
  function getName();
}

class User implements IUser
{
  public function __construct( $id ) { }

  public function getName()
  {
    return "Jack";
  }
}

class UserFactory
{
  public static function Create( $id )
  {
    return new User( $id );
  }
}

$uo = UserFactory::Create( 1 );
echo( $uo->getName()."\n" );

An interface called IUser defines what a user object should do. The implementation of IUser is called User, and a factory class called UserFactory creates IUser objects. This relationship is shown as UML in Figure 1.
Figure 1. The factory class and its related IUser interface and user class

If you run this code on the command line using the php interpreter, you get this result:

% php factory1.php
Jack
%

The test code asks the factory for a User object and prints the result of the getName method.

A variation of the factory pattern uses factory methods. These public static methods in the class construct objects of that type. This approach is useful when creating an object of this type is nontrivial. For example, suppose you need to first create the object and then set many attributes. This version of the factory pattern encapsulates that process in a single location so that the complex initialization code isn’t copied and pasted all over the code base.

Listing 2 shows an example of using factory methods.

interface IUser
{
  function getName();
}

class User implements IUser
{
  public static function Load( $id )
  {
        return new User( $id );
  }

  public static function Create( )
  {
        return new User( null );
  }

  public function __construct( $id ) { }

  public function getName()
  {
    return "Jack";
  }
}

$uo = User::Load( 1 );
echo( $uo->getName()."\n" );

This code is much simpler. It has only one interface, IUser, and one class called User that implements the interface. The User class has two static methods that create the object. This relationship is shown in UML in Figure 2.
Figure 2. The IUser interface and the user class with factory methods

Running the script on the command line yields the same result as the code in Listing 1, as shown here:

% php factory2.php
Jack
%

As stated, sometimes such patterns can seem like overkill in small situations. Nevertheless, it’s still good to learn solid coding forms like these for use in any size of project.

The singleton pattern

Some application resources are exclusive in that there is one and only one of this type of resource. For example, the connection to a database through the database handle is exclusive. You want to share the database handle in an application because it’s an overhead to keep opening and closing connections, particularly during a single page fetch.

The singleton pattern covers this need. An object is a singleton if the application can include one and only one of that object at a time. The code in Listing 3 shows a database connection singleton in PHP V5.

require_once("DB.php");

class DatabaseConnection
{
  public static function get()
  {
    static $db = null;
    if ( $db == null )
      $db = new DatabaseConnection();
    return $db;
  }

  private $_handle = null;

  private function __construct()
  {
    $dsn = 'mysql://root:password@localhost/photos';
    $this->_handle =& DB::Connect( $dsn, array() );
  }

  public function handle()
  {
    return $this->_handle;
  }
}

print( "Handle = ".DatabaseConnection::get()->handle()."\n" );
print( "Handle = ".DatabaseConnection::get()->handle()."\n" );

This code shows a single class called DatabaseConnection. You can’t create your own DatabaseConnection because the constructor is private. But you can get the one and only one DatabaseConnection object using the static get method. The UML for this code is shown in Figure 3.
Figure 3. The database connection singleton

The proof in the pudding is that the database handle returned by the handle method is the same between two calls. You can see this by running the code on the command line.

% php singleton.php
Handle = Object id #3
Handle = Object id #3
%

The two handles returned are the same object. If you use the database connection singleton across the application, you reuse the same handle everywhere.

You could use a global variable to store the database handle, but that approach only works for small applications. In larger applications, avoid globals, and go with objects and methods to get access to resources.

The observer pattern

The observer pattern gives you another way to avoid tight coupling between components. This pattern is simple: One object makes itself observable by adding a method that allows another object, the observer, to register itself. When the observable object changes, it sends a message to the registered observers. What those observers do with that information isn’t relevant or important to the observable object. The result is a way for objects to talk with each other without necessarily understanding why.

A simple example is a list of users in a system. The code in Listing 4 shows a user list that sends out a message when users are added. This list is watched by a logging observer that puts out a message when a user is added.

interface IObserver
{
  function onChanged( $sender, $args );
}

interface IObservable
{
  function addObserver( $observer );
}

class UserList implements IObservable
{
  private $_observers = array();

  public function addCustomer( $name )
  {
    foreach( $this->_observers as $obs )
      $obs->onChanged( $this, $name );
  }

  public function addObserver( $observer )
  {
    $this->_observers []= $observer;
  }
}

class UserListLogger implements IObserver
{
  public function onChanged( $sender, $args )
  {
    echo( "'$args' added to user list\n" );
  }
}

$ul = new UserList();
$ul->addObserver( new UserListLogger() );
$ul->addCustomer( "Jack" );

This code defines four elements: two interfaces and two classes. The IObservable interface defines an object that can be observed, and the UserList implements that interface to register itself as observable. The IObserver list defines what it takes to be an observer, and the UserListLogger implements that IObserver interface. This is shown in the UML in Figure 4.
Figure 4. The observable user list and the user list event logger

If you run this on the command line, you see this output:

% php observer.php
'Jack' added to user list
%

The test code creates a UserList and adds the UserListLogger observer to it. Then the code adds a customer, and the UserListLogger is notified of that change.

It’s critical to realize that the UserList doesn’t know what the logger is going to do. There could be one or more listeners that do other things. For example, you may have an observer that sends a message to the new user, welcoming him to the system. The value of this approach is that the UserList is ignorant of all the objects depending on it; it focuses on its job of maintaining the user list and sending out messages when the list changes.

This pattern isn’t limited to objects in memory. It’s the underpinning of the database-driven message queuing systems used in larger applications.

The chain-of-command pattern

Building on the loose-coupling theme, the chain-of-command pattern routes a message, command, request, or whatever you like through a set of handlers. Each handler decides for itself whether it can handle the request. If it can, the request is handled, and the process stops. You can add or remove handlers from the system without influencing other handlers. Listing 5 shows an example of this pattern.

interface ICommand
{
  function onCommand( $name, $args );
}

class CommandChain
{
  private $_commands = array();

  public function addCommand( $cmd )
  {
    $this->_commands []= $cmd;
  }

  public function runCommand( $name, $args )
  {
    foreach( $this->_commands as $cmd )
    {
      if ( $cmd->onCommand( $name, $args ) )
        return;
    }
  }
}

class UserCommand implements ICommand
{
  public function onCommand( $name, $args )
  {
    if ( $name != 'addUser' ) return false;
    echo( "UserCommand handling 'addUser'\n" );
    return true;
  }
}

class MailCommand implements ICommand
{
  public function onCommand( $name, $args )
  {
    if ( $name != 'mail' ) return false;
    echo( "MailCommand handling 'mail'\n" );
    return true;
  }
}

$cc = new CommandChain();
$cc->addCommand( new UserCommand() );
$cc->addCommand( new MailCommand() );
$cc->runCommand( 'addUser', null );
$cc->runCommand( 'mail', null );

This code defines a CommandChain class that maintains a list of ICommand objects. Two classes implement the ICommand interface — one that responds to requests for mail and another that responds to adding users. The UML is shows in Figure 5.
Figure 5. The command chain and its related commands

If you run the script, which contains some test code, you see the following output:

% php chain.php
UserCommand handling 'addUser'
MailCommand handling 'mail'
%

The code first creates a CommandChain object and adds instances of the two command objects to it. It then runs two commands to see who responds to those commands. If the name of the command matches either UserCommand or MailCommand, the code falls through and nothing happens.

The chain-of-command pattern can be valuable in creating an extensible architecture for processing requests, which can be applied to many problems.

The strategy pattern

The last design pattern we will cover is the strategy pattern. In this pattern, algorithms are extracted from complex classes so they can be replaced easily. For example, the strategy pattern is an option if you want to change the way pages are ranked in a search engine. Think about a search engine in several parts — one that iterates through the pages, one that ranks each page, and another that orders the results based on the rank. In a complex example, all those parts would be in the same class. Using the strategy pattern, you take the ranking portion and put it into another class so you can change how pages are ranked without interfering with the rest of the search engine code.

As a simpler example, Listing 6 shows a user list class that provides a method for finding a set of users based on a plug-and-play set of strategies.

interface IStrategy
{
  function filter( $record );
}

class FindAfterStrategy implements IStrategy
{
  private $_name;

  public function __construct( $name )
  {
    $this->_name = $name;
  }

  public function filter( $record )
  {
    return strcmp( $this->_name, $record ) <= 0;
  }
}

class RandomStrategy implements IStrategy
{
  public function filter( $record )
  {
    return rand( 0, 1 ) >= 0.5;
  }
}

class UserList
{
  private $_list = array();

  public function __construct( $names )
  {
    if ( $names != null )
    {
      foreach( $names as $name )
      {
        $this->_list []= $name;
      }
    }
  }

  public function add( $name )
  {
    $this->_list []= $name;
  }

  public function find( $filter )
  {
    $recs = array();
    foreach( $this->_list as $user )
    {
      if ( $filter->filter( $user ) )
        $recs []= $user;
    }
    return $recs;
  }
}

$ul = new UserList( array( "Andy", "Jack", "Lori", "Megan" ) );
$f1 = $ul->find( new FindAfterStrategy( "J" ) );
print_r( $f1 );

$f2 = $ul->find( new RandomStrategy() );
print_r( $f2 );

The UML for this code is shown in Figure 6.
Figure 6. The user list and the strategies for selecting users

The UserList class is a wrapper around an array of names. It implements a find method that takes one of several strategies for selecting a subset of those names. Those strategies are defined by the IStrategy interface, which has two implementations: One chooses users randomly and the other chooses all the names after a specified name. When you run the test code, you get the following output:

% php strategy.php
Array
(
    [0] => Jack
    [1] => Lori
    [2] => Megan
)
Array
(
    [0] => Andy
    [1] => Megan
)
%

The test code runs the same user lists against two strategies and shows the results. In the first case, the strategy looks for any name that sorts after J, so you get Jack, Lori, and Megan. The second strategy picks names randomly and yields different results every time. In this case, the results are Andy and Megan.

The strategy pattern is great for complex data-management systems or data-processing systems that need a lot of flexibility in how data is filtered, searched, or processed.

Conclusions

These are just a few of the most common design patterns used in PHP applications. Many more are demonstrated in the Design Patterns book. Don’t be put off by the mystique of architecture. Patterns are great ideas you can use in any programming language and at any skill level.

Resources

• Wikipedia has a good article on design patterns.
• The C2 Wiki is another good place to look for information about design patterns like observer, singleton, and more.
• The original Design Patterns book is a must-read for any engineer.
• O’Reilly’s Head First Design Patterns is a lighter-weight way to get into design patterns.
• The book PHP Hacks has several hacks for design patterns that extend beyond the examples shown here.
• PHP.net is the central resource for PHP developers.

With that in mind, we’ve prepared a list of books that we feel are among the best of the best.

Jump to a Topic

• PHP
• JS
• jQuery
• HTML
• WordPress
• CSS
• Miscellaneous

PHP

PHP Solutions: Dynamic Web Design Made Easy

Author: David Powers

“So why another PHP book? Well, not everyone who uses PHP is a programmer. PHP is the most common dynamic web language used by designers, if their web sites require dynamic functionality, and there are hordes of novice users who want to set up dynamic web sites.”

PHP for Absolute Beginners

Author: Jason Lengstorf

“PHP for Absolute Beginners starts at the very beginning stages of web programming, showing even the most inexperienced web developer, through examples, how to build a basic content management system. The book dives directly into writing web applications with accompanying explanation rather than explaining elements of the language and then showing examples.”

PHP Cookbook

Author: Adam Trachtenberg

“PHP Cookbook has a wealth of solutions for problems that you’ll face regularly. With topics that range from beginner questions to advanced web programming techniques, this guide contains practical examples — or “recipes” — for anyone who uses this scripting language to generate dynamic web content.”

JavaScript

Professional JavaScript for Web Developers

Author: Nicholas Zakas

“Starting at the beginning, the book explores how JavaScript originated and evolved into what it is today. A detailed discussion of the components that make up a JavaScript implementation follows, with specific focus on standards such as ECMAScript and the Document Object Model (DOM).”

JavaScript – The Good Parts

Author: Douglas Crockford

“Most programming languages contain good and bad parts, but JavaScript has more than its share of the bad, having been developed and released in a hurry before it could be refined. This authoritative book scrapes away these bad features to reveal a subset of JavaScript that’s more reliable, readable, and maintainable than the language as a whole-a subset you can use to create truly extensible and efficient code.”

Object-Oriented JavaScript

Author: Stoyan Stefanov

“Create scalable and reusable high-quality JavaScript applications and libraries using the concepts of object-oriented programming. This book is for the beginning to intermediate web developer who wants to solve web development problems with smart JavaScript. It does not assume any prior knowledge of JavaScript programming; however even if you already know some JavaScript, there will be plenty for you to learn here.”

JavaScript Patterns

Author: Stoyan Stefanov

“What’s the best approach for developing an application with JavaScript? This book helps you answer that question with numerous JavaScript coding patterns and best practices. If you’re an experienced developer looking to solve problems related to objects, functions, inheritance, and other language-specific categories, the abstractions and code templates in this guide are ideal — whether you’re writing a client-side, server-side, or desktop application with JavaScript.”

Pro JavaScript Techniques

Author: John Resig

“This book addresses all the points above in detail – modern browser support (including information on Internet Explorer 7), Object-Oriented JavaScript, testing and debugging, Unobtrusive JavaScript techniques using DOM Scripting, Ajax, creating and using blocks of reusable code, and looking towards the future of JavaScript.”

JavaScript 24 Hour Trainer

Author: Jeremy McPeak

“This unique book-and-DVD package shows you how to use JavaScript to make web pages more dynamic and interactive so that you can create a first-rate user experience. Packed with expertly written lessons, this must-have book-and-DVD set provides instructional demonstrations on the DVD that enhance your Java Script learning experience through tutorial demos and helpful examples.”

jQuery

jQuery Cookbook

Author: Cody Lindley

“Ideal for newcomers and JavaScript veterans alike, jQuery Cookbook starts with the basics and then moves to practical use cases with tested solutions to common web development hurdles. You also get recipes on advanced topics, such as methods for applying jQuery to large projects.”

jQuery Enlightenment

Author: Cody Lindley

“jQuery Enlightenment was written to express, in short-order, the concepts essential to intermediate and advanced jQuery development. Its purpose is to instill in you, the reader, practices that jQuery developers take as common knowledge. Each chapter contains concepts essential to becoming a seasoned jQuery developer.”

jQuery in Action

Author: Bear Bibeault

“jQuery in Action is a fast-paced introduction and guide. It shows you how to traverse HTML documents, handle events, perform animations, and add Ajax to your web pages. The book’s unique “lab pages” anchor the explanation of each new concept in a practical example. You’ll learn how jQuery interacts with other tools and frameworks and how to build jQuery plugins.”

HTML 5

Introducing HTML5

Author: Bruce Lawson

“Written by developers who have been using the new language for the past year in their work, this book shows you how to start adapting the language now to realize its benefits on today’s browsers. Rather than being just an academic investigation, it concentrates on the practical—the problems HTML5 can solve for you right away.”

Pro HTML 5 Programming

Author: Peter Lubbers

“The biggest revolution since Ajax, Pro HTML 5 Programming: Powerful APIs for Richer Internet Application Development introduces the most revolutionary new feature of HTML 5, the ability to build Real-Time Web applications using Web Sockets. “

HTML5: Up and Running

Author: Mark Pilgrim

“With HTML5: Up & Running, you’ll learn how this new version enables browsers to interact with JavaScript much more easily than before. “

WordPress

Rockable WordPress Designer

Author: Collis Ta’eed and Harley Alexander

“Managing web content has always been tricky, but with WordPress, any web designer can have a flexible, free and powerful CMS to use not just on blogging projects, but on all sorts of websites. In How To Be a Rockstar WordPress Designer you will learn step by step how to take a straight HTML site and power it with WordPress.”

Digging into WordPress

Author: Chris Coyier and Jeff Starr

“There is much to learn about the World’s most popular publishing platform. Digging into WordPress is nearly 450 pages of taking you from your first steps of learning about WordPress all the way through maintaining a site throughout the years.”

Professional WordPress Plugin Development

Author: Brad Williams, Justin Tadlock, Ozh Richard

“As one of the most popular open source content management systems available today, WordPress boasts a framework that allows you to easily customize and extend it through plugins. This comprehensive book shows you how plugins work, reviews the tools and APIs available in WordPress, and demonstrates how to extend the functionality of WordPress with plugins.”

Professional WordPress

Author: Hal Stern

“An in-depth look at the internals of the WordPress system. As the most popular blogging and content management platform available today, WordPress is a powerful tool. This exciting book goes beyond the basics and delves into the heart of the WordPress system, offering overviews of the functional aspects of WordPress as well as plug-in and theme development.”

CSS

Hardboiled Web design

Author: Andy Clarke

“‘Hardboiled Web Design’ offers a fresh perspective on designing for the web — never compromising, always pushing boundaries. It strips markup to the bone and uses HTML5 and CSS3 to the maximum to help make your sites more adaptable to whatever the web might throw at them. “

CSS Mastery

Author: Andy Budd

“A book that brings together the most useful CSS techniques in one place, that focuses on real-world browser issues and that helps plug common gaps in people’s CSS knowledge.”

CSS: The Definitive Guide

Author: Eric Meyer

“CSS: The Definitive Guide provides you with a comprehensive guide to CSS implementation, along with a thorough review of all aspects of CSS 2.1. Updated to cover Internet Explorer 7, Microsoft’s vastly improved browser, this new edition includes content on positioning, lists and generated content, table layout, user interface, paged media, and more. “

CSS Cookbook

Author: Christopher Schmitt

“Learn how to solve the real problems you face with CSS. This cookbook offers hundreds of practical examples for using CSS to format your web pages, and includes code samples you can use right away. You’ll find exactly what you need, from the basics to complex hacks and workarounds.”

Miscellaneous

Getting Good with Git

Author: Andrew Burgess

“In this book, Andrew Burgess will take you from knowing nothing about source code management to being able to use Git proficiently. You’ll look at why you should use a version control system, why Git is better than the other options, and how to set up and use Git.”

Regular Expressions Cookbook

Author: Jan Goyvaerts

“Whether you’re a novice or an experienced user, Regular Expressions Cookbook will help deepen your understanding of the tool. You’ll learn powerful new tricks, avoid language-specific gotchas, and save valuable time with this huge library of proven solutions to difficult, real-world problems.”

What Did We Miss?

We’ve undoubtedly forgotten a handful of books, so let us know which books the list should include below.

What We’re Going to Learn:

• Benefits of using OOP for WordPress plugins.
• How to setup a shortcode.
• How to setup a template tag.
• How to enable shortcode in WordPress widgets.
• Real-world example by using Dribbble’s API.

Why Use OOP?

Creating WordPress plugins with object oriented code is quite efficient and tidy, when compared to using procedural code. It’s easier to manage the code base, and expand it using inheritance techniques, which can be particularly helpful when writing a large plugin.

Dribbble

To write a WordPress plugin, we first need a sense of direction. We’re going to write a plugin that will display the latest shots from Dribbble, using their REST API. We’ll then add shortcode support for posts and widgets, and template tag for themes.

Step 1 – Setting up the Plugin Class

Object oriented code is based on classes and methods (functions). Let’s create our core class, which will interact with WordPress’ hooks and filters

class WPDribbble {
	public function __construct()
	{
	}
}

$wpDribbble = new WPDribbble();

PHP classes have a constructor function, __construct, which is executed as soon as a new instance of a class is instantiated. All WordPress hooks and filters will be registered under the constructor of our plugin class. Lets push ahead and register a shortcode for our plugin. The add_shortcode() function/hook will go under the constructor function.

The new instance of a class/object is registered using the new keyword. Refer to the last line in the code below.

class WPDribbble {
	public function __construct()
	{
		add_shortcode('Dribbble', array($this, 'shortcode'));
	}

	public function shortcode()
	{
	}
}

$wpDribbble = new WPDribbble();

• add_shortcode – The first parameter is the shortcode tag, and the second is the callback function.

Notice how we’re using an array in the callback function parameter? To register callback functions inside an object, we have to use an array.

The first item of the array references the object, via $this. The second item in the array is the method name within the class. All hooks and filters have to be referenced like this when inside a class.

Still Confused?

# 1. Standard usage
add_shortcode('shortcode_name', 'shortcode_func');

function shortcode_func()
{
 // Contents of this function will execute when the blogger
 // uses the [shortcode_name] shortcode.
}

# 2. With PHP 5.3, we can pass an anonymous function.
add_shortcode('shortcode_name', function() {
   // Contents of this function will execute when the blogger
   // uses the [shortcode_name] shortcode.
});

#3. Within a class
class WPDribbble {
	public function __construct()
	{
		add_shortcode('Dribbble', array($this, 'shortcode'));
	}

	public function shortcode()
	{
           // Contents of this function will execute when the blogger
           // uses the [shortcode_name] shortcode.
	}
}

Step 2 – Dribbble API Class

Since we currently do not require any fancy API functions, we’re going to create a rather simple API wrapper for Dribbble. There is already a library available for Dribbble, but, for the sake of this tutorial, we’re going to write our own. It’ll help you understand the concepts behind this tutorial.

We’re going to write a DribbbleAPI object, and register a method called getPlayerShots() to interact with Dribbble’s API and return an array of the latest shots.

Let’s create a new file for this class, called DribbbleAPI.php

class DribbbleAPI {
	// url to Dribbble api
	protected $apiUrl = 'http://api.dribbble.com/';

	// Dribbble username or user id
	protected $user;
}

Above, we’re setting up two class variables.

• $apiUrl – The link to the Dribbble API, where the calls will be sent.
• $user – The username or user id of a Dribbble user. This value will be set from within the constructor (__construct) method.

class DribbbleAPI {
	// url to Dribbble api
	protected $apiUrl = 'http://api.dribbble.com/';

	// Dribbble username or user id
	protected $user;

	public function __construct($user)
	{
		$this->user = $user;
	}
}

The constructor is passed a $user variable, which is then passed on by the constructor to the class property, called user.

We prefix the property, or variable name with public to specify that the value of this property can be retrieved from outside of the class. If we instead wish to limit access to the property to only this class, and perhaps any classes that inherit from it, we’d use the protected prefix. This practice is referred to as encapsulation.

We have the base ready for our Dribbble API wrapper. Now, We’re going to write a new method, called getPlayerShots(). The purpose of this method will be to query the API and convert the result into an array for usage within our plugin.

class DribbbleAPI {
	// url to Dribbble api
	protected $apiUrl = 'http://api.dribbble.com/';

	// Dribbble username or user id
	protected $user;

	public function __construct($user)
	{
		$this->user = $user;
	}

	public function getPlayerShots($perPage = 15)
	{
		$user = $this->user;

		$json = wp_remote_get($this->apiUrl . 'players/' . $user . '/shots?per_page=' . $perPage);

		$array = json_decode($json['body']);

		$shots = $array->shots;

		return $shots;
	}
}

The getPlayerShots function retrives the user from the class variable. It uses WordPress’ wp_remote_get function to query the Dribbble API. The API then responds to our query with a JSON string, which is then parsed into an array and sent back to the function using the return keyword.

This is all that we require from the API at the moment – simply an array of player shots. If we happen to require more functionality in the future, we can either add more methods to the current class, or create a new class that extends this one. Again, this is referred to as inheritance.

Step 3 – Integrating the DribbbleAPI Class

This is the fun part; the freshly baked DribbbleAPI class will come into use. We’re going to loop through the shots retrived from the API, and generate an html list of shots, which will be passed on to the shortcode and the template tag. During the loop, the full-sized Dribbble images will be cached and saved in the plugin folder, and the thumbnails will be generated using TimThumb.

To determine if the full images are already stored locally, the plugin path is required. Also, to generate the thumbnails with timthumb, the plugin url is required. For this purpose, we’ll create two class variables called pluginPath and pluginURL in our WPDribbble class, and then set their values from within the constructor method.

Setting PluginPath and PluginUrl

class WPDribbble {
	protected $pluginPath;
	protected $pluginUrl;

	public function __construct()
	{
		// Set Plugin Path
		$this->pluginPath = dirname(__FILE__);

		// Set Plugin URL
		$this->pluginUrl = WP_PLUGIN_URL . '/wp-Dribbble';

		add_shortcode('Dribbble', array($this, 'shortcode'));
	}

getImages() Method

Create a new method within the WPDribbble class, called getImages.

Inside a class, you can use generic names for functions. They will not conflict with other plugins or WordPress’ built-in functions, because they are under the class namespace.

public function getImages($user, $images = 3, $width = 50, $height = 50, $caption = true)
{
}

• $user – Username or User ID of Dribbble. $user will be used when registering a new instance of the DribbbleAPI class.
• $images – Number of images to render. $images will be used when querying the API through the getPlayerShots method.
• $width and $height – Timthumb will be used to generate thumbnails.
• $caption – Option to render title of an image.

Next, we’re going to include the DribbbleAPI class in the getImages() function, and create a new instance of it to grab the images.

public function getImages($user, $images = 3, $width = 50, $height = 50, $caption = true)
{
	include 'DribbbleAPI.php';

	$DribbbleAPI = new DribbbleAPI($user);
	$shots = $DribbbleAPI->getPlayerShots($images);

	if($shots) {
	}
}

The $shots variable in the code is populated with an array of three recent Dribbbles from the $user.

As mentioned previously, we’re going to loop through the $shots array, and save the full size images locally for caching purposes. The cached images will be used with TimThumb to serve the thumbnails. For storing full-images and thumbnails generated by TimThumb, create two folders. We’ll use full-images/ for storing the full size images, and cache/ for the thumbnails, since that is the default folder name for TimThumb.

The HTML for the list will be generated within the $shots loop.

public function getImages($user, $images = 3, $width = 50, $height = 50, $caption = true)
{
	include 'DribbbleAPI.php';

	$DribbbleAPI = new DribbbleAPI($user);
	$shots = $DribbbleAPI->getPlayerShots($images);

	if($shots) {
		$html[] = '
<ul class="wp-Dribbble">';

		foreach($shots as $shot) {
			$image = $shot->image_url; // url of the image
			$fileName = $shot->id . '.png'; // generating a filename image_id.png

			if (!file_exists($this->pluginPath . '/full-images/' . $fileName)) { // check if the full image exists
				$rawImage = wp_remote_get($image); // get the full image
				$newImagePath = $this->pluginPath  . '/full-images/' . $fileName;
				$fp = fopen($newImagePath, 'x');
				fwrite($fp, $rawImage['body']); // save the full image
				fclose($fp);
			}

			// generate thumbnail url
			$localImage = $this->pluginUrl . '/timthumb.php?src=' . strstr($this->pluginPath, 'wp-content') . '/full-images/' . $fileName . '&w=' . $width . '&h=' . $height . '&q=100';

			if($caption) { // if caption is true
				$captionHTML = '

' . $shot->title . '

';
			}

			// combine shot url, title and thumbnail to add to the ul list
			$html[] = '
	<li class="wp-Dribbble-list"><a title="' . $shot->title . '" href="' . $shot->url . '"><img src="' . $localImage . '" alt="' . $shot->title . '" /></a>'.$captionHTML.'</li>
';
		}

		$html[] = '</ul>
';

		return implode("\n", $html);
	}
}

Adding Classes

It’s always a good idea to add classes to each element of your plugin. This provides the advanced users of your plugin with the freedom to customize it. Avoid using inline CSS for content that is generated through your plugin.

Step 4 – Setting up the Shortcode

Shortcodes, as the name suggests, allows users to easily add complex content into blog posts.

We already have the add_shortcode hook ready in our plugin class constructor. Now, we’re going to write the shortcode method inside our class, which will exract the shortcode attributes and return the Dribbble images by using the getImages() method.

We’ll be calling our shortcode [Dribbble]. As mentioned previously, the name of the shortcode is determined by the first parameter in the add_shortcode function. It will be used with the attributes required for the getImages() method. For example: [Dribbble user=haris images=5 width=100 height=100 caption=true].

public function shortcode($atts)
{
	// extract the attributes into variables
	extract(shortcode_atts(array(
		'images' => 3,
		'width' => 50,
		'height' => 50,
		'caption' => true,
	), $atts));

	// pass the attributes to getImages function and render the images
	return $this->getImages($atts['user'], $images, $width, $height, $caption);
}

Add Shortcode support for WordPress Widgets

By default, WordPress widgets don’t support shortcodes, however, by using the widget_text filter, we can force shortcode support in WordPress widgets.

We can add the filter in our WPDribbble object constructor.

public function __construct()
{
	// Set Plugin Path
	$this->pluginPath = dirname(__FILE__);

	// Set Plugin URL
	$this->pluginUrl = WP_PLUGIN_URL . '/wp-Dribbble';

	add_shortcode('Dribbble', array($this, 'shortcode'));

	// Add shortcode support for widgets
	add_filter('widget_text', 'do_shortcode');
}

Step 5 Setting up the Template Tag

The template tag can be used directly in WordPress themes. The basic purpose of the template tag will be to create a new instance of our WPDribbble class, and call the getImages() method. The template tag will be a simple PHP function and it has to be registered outside the plugin class. It needs to have a unique name; otherwise, it will conflict with functions / plugins with similiar name. Since our plugin is called WP-Dribbble, we’ll call the template tag, wp_Dribbble().

function wp_Dribbble($user, $images = 3, $width = 50, $height = 50, $caption = true)
{
	$wpDribbble = new WPDribbble;
	echo $wpDribbble->getImages($user, $images, $width, $height, $caption);
}

Voila!

Congratulations! You have successfully written a WordPress plugin with OOP. If you have any questions, leave a comment below, and we will do our best to help you.

Source:

1. Nettuts: Create WordPress Plugins with OOP Techniques.

Can’t help yourself get out of this anymore?

Then please watch Nick Vujicic speaking in this video, and how can he use things he miss to make people understand the meaning of life:

A Pack of 152 Sticker PNG free icons, contains 16, 32, 48, 64, 128, 256, and 512 variants.

Password for StickersPNG.zip file: IdeasCart

Links:

1. MediaFire: 152 Free Sticker PNG Icons MediaFire Link.

// defines file type using MIME Type
header("Content-type:MIME Type");

// tells the browser to download the file, not to show it and defines the destination file name
header("Content-Disposition:attachment;filename='file name'");

// defines the source file path and name
readfile("path/to/file");

And here is an example on making a download for a text file named “downloaded.txt” from a source files named “source.txt”.
Create a file and name it “download.php” for example, then paste the following code in it.

// defines file type using MIME Type
header("Content-type:text/plain");

// tells the browser to download the file, not to show it and defines the destination file name
header("Content-Disposition:attachment;filename='downloaded.txt'");

// defines the source file path and name
readfile("source.txt");

Then create another file with any content and name it “source.txt” and put it beside “download.php” file.

Hints :

1. You can change the readfile() function to echo() function to print any text dynamically from database for example.
2. You can find more of MIME Types in the link below.

External Links :

1. PHP header() function manual.
2. List of MIME Types.

Gravatar (Globally Recognized Avatar) is simply “an avatar image that follows you from blog to blog appearing beside your name when you comment on gravatar enabled sites”.

I think now you can guess what is it.

It really follows the e-mail that you have registered with in gravatar.com.

So when you type this e-mail at any website supporting Gravatar, the website contacts Gravatar service to check if this e-mail is already registered or not.

If it was found then Gravatar reply with the avatar you have assigned to this e-mail, so you can easily have your picture following you at any blog you visit.

Resources :

1. http://www.gravatar.com

External Links :

1. http://en.gravatar.com/site/signup