PHP supports two different types of regular expressions: POSIX-extended and Perl-Compatible Regular Expressions (PCRE). The PCRE functions are more commonly used, are more powerful than the POSIX ones and faster as well

In a regular expression, most characters match only themselves. For instance, if you search for the regular expression “foo” in the string “only a fool does not use regular expressions” you get a match because “foo” occurs in that string. Some characters have a special meaning. For instance, the dollar sign ($) is used to match strings that end with the given pattern. Similarly, a caret (^) character at the beginning of a regular expression indicates that it must match the beginning of the string. Characters that match themselves are called literals while characters that have special meanings are called metacharacters.

The dot (.) metacharacter matches any single character except newline (\). Hence, the pattern h.t matches hat, hothit, hut and h7t. The vertical pipe (|) metacharacter is used for alternatives in a regular expression. It behaves much like a logical OR operator and you should use it if you want to construct a pattern that matches more than one set of characters. For instance, the pattern Monday|Tuesday|Wednesday matches strings that contain “Monday” or “Tuesday” or “Wednesday”. Parentheses are used to group sequences. For example, (fri|satur)day matches “friday” or “saturday”. Using parentheses to group characters for alternation is called grouping.

If we want to match a literal metacharacter in a pattern, we have to escape it with a backslash.

To specify a set of acceptable characters in a pattern, we can either build a character class ourself, or use a predefined one. A character class lets us represent a bunch of characters as a single item. We can build our own character class by enclosing the acceptable characters in square brackets. A character class matches any one of the characters in the class. For example a character class [abc] matches a, b or c. To define a range of characters, we just add the first and last characters separated by hyphen. For example, to match all alphanumeric characters: [a-zA-Z0-9]. We can also create a negated character class, which matches any character that is not in the class. To create a negated character class, we start the character class with ^: [^0-9].

Metacharacters +, *, ?, and {} affect the number of times a pattern should be matched. + means “Match one or more of the preceding expression”, * means “Match zero or more of the preceding expression”, and ? means “Match zero or one of the preceding expression”. Curly braces {} are be used differently. With a single integer, {n} means “match exactly n occurrences of the preceding expression”, with one integer and a comma, {n,} means “match n or more occurrences of the preceding expression”, and with two comma-separated integers {n,m} means “match the previous character if it occurs at least n times, but no more than m times”.

CouchDB can be a little bit of a pain to install, because it needs a few pre-requisites and they in turn have a few of their own quirks. This outline should help you get CouchDB with all it’s necessities installed. We’ve used MacOS, but you can substitute your OS where applicable.

The CouchDB source code and installer packages are downloadable here. As of this writing, version 0.11.2 is the latest stable version, with 1.0.1 just around the corner. You will also need Spider Monkey, Mozilla’s C implementation of JavaScript.

Installing SpiderMonkey

Once downloaded, extract the tarball and move into the sources folder:

tar -xzvf js-1.8.0-rc1.tar.gz

cd js/src

If you’re installing SpiderMonkey on a Mac, there is a small hack to the jsprf.c file. Adding the following two lines (in orange below) after line 60 should resolve the build issue:

60: #define VARARGS_ASSIGN(foo, bar) VA_COPY(foo,bar)
61: #elif defined(va_copy)
62: #define VARARGS_ASSIGN(foo, bar)
63: #elif defined(HAVE_VA_LIST_AS_ARRAY)

Now we should have no issue running make:

make BUILD_OPT=1 -f Makefile.ref

sudo sh

sudo make BUILD_OPT=1 JS_DIST=/usr/local -f Makefile.ref export

Installing ICU

ICU is a library for International Components for Unicode and CouchDB relies on it. Let’s download it from icu-project.org here. Once downloaded, extract the package and move into the sources folder and change some permissions before building the code:

tar -xzvf icu4c-4_4_1-src.tgz

cd icu/source

chmod +x runConfigureICU configure install-sh

./runConfigreICU -h (select the suffix for your OS and and supply it as argument to runConfigureICU, eg: ./runConfigureICU MacOS)

make

sudo make install

Installing Erlang

Erlang is the language used to build CouchDB, and you’ll have to install it if it’s not yet present. Download Erlang version 14A (latest as of this writing) from erlang.org here or use wget or curl as in the steps below.
cd /tmp
wget http://www.erlang.org/download/otp_src_R14A.tar.gz
tar -xzvf otp_src_R14A.tar.gz
cd otp_src_R14A
./configure –enable-hipe –enable-smp-support –enable-threads (–enable-darvin-universal for Mac)
make
sudo make install

Installing CouchDB

Now finally we’re ready to install CouchDB.

cd /tmp

wget http://www.apache.org/dyn/closer.cgi?path=/couchdb/0.11.2/apache-couchdb-0.11.2.tar.gz

tar -xzvf apache

cd apache-couchdb-0.11.2

./configure

make

sudo make install

sudo couchdb start

Testing our CouchDB installation

Besides the countless client libraries written in almost any language, we can simply use Telnet to create a database and do some basic data manipulation to test our installation.

telnet localhost 5984

If there are no errors and you get a response like below, you’re all set.

Trying 127.0.0.1…
Connected to localhost.
Escape character is ‘^]’.

A good introduction to CouchDB’s commands can be found here.

In Apache, we achieve this by enabling content encoding. When a user requests a file like http://www.msn.com/index.html, the browser communicates to a web server, and the conversation goes a something like this:

1. Browser: GET me /index.html
2. Server: Found indes.html, it’s 187KB! Response code is 200 (200 OK) , requested file is coming
3. Browser: 187KB, loading

The actual headers and protocols sent between the two are much more formal (monitor them with HTTPFox, Live HTTP Headers or others if you like.

Now, everything worked just fine in our little scenario, the browser got it’s requested file (index.html) of 187KB in size and probably also loaded include files such as javascript, css and a bunch of images. Especially on lower speed Internet connections, it took a few seconds for the page to load all files.

That’s where compression comes in. Html, javascript and css are plain text and are ideal candidates for compression, while images and videos usually underwent some compression algorithm when saved as jpg, png, avi or flv. Compressing those files would provide very little to no improvement in file size and add processing overhead to the web server. So we want to ensure we exclude those.

1. Browser: GET me /index.html, compressed if available
2. Server: Found index.html, it’s 35KB, compressed! Response code is 200 (200 OK) , requested file is coming
3. Browser: got index.html, extracting and loading

How do the browser and server know whether to send a file compressed or not?  The agreement has two parts:

And there is Redis, the new kid on the block. Redis is a high speed storage or cache system, much like Memcache on steroids. Redis writes data into memory, which makes it really fast. And in contrast to Memcache, it writes data periodically to disk depending on the amount of data that has changed. Redis is been said to be able to handle in excess of 10’000 reads/writes per second!

In contrast to Memcache, Redis has its own client language. The basic “set” and “get” are pretty much standard, but we can increment values, set lists and sets and easily handle key replacements and checks for existing values.

As of this writing, version 2 is in Release Candidate 4. For production environments, you’re highly encouraged to use the stable version 1.2.6. To install Redis, download the desired version, untar and switch to the Redis directory. There is no configure script, we just call make, then copy “redis_server” and “redis-cli” to your desired location (eg. /usr/local/bin) and copy redis.conf to /etc/. Let’s start it up! Although I downloaded version 2 RC 4, the server shows version 1.3.17:

redis-server
[3926] 11 Aug 10:42:33 * Server started, Redis version 1.3.17
[3926] 11 Aug 10:42:33 * The server is now ready to accept connections on port 6379
[3926] 11 Aug 10:42:33 – 0 clients connected (0 slaves), 1074272 bytes in use
[3926] 11 Aug 10:42:33 * Server started, Redis version 1.3.17
[3926] 11 Aug 10:42:33 * The server is now ready to accept connections on port 6379
[3926] 11 Aug 10:42:33 – 0 clients connected (0 slaves), 1074272 bytes in use

We can now use Telnet to connect on port 6379 or use the Command Line Interface that comes with Redis (redis-cli) and issue some commands:

redis> get firstName
(nil)
redis> set firstName Peter
OK
redis> get firstName
“Peter”
redis> setnx firstName Peters
(integer) 0
redis> get firstName
“Peter”
redis> setnx firstNames Peters
(integer) 1
redis> get firstNames
“Peters”
redis>

Complete command reference can be found here and it’s highly encouraged that you play around with them and get familiar with the CLI commands. It is really amazing what Redis provides in terms of powerful memory storage solution coupled with such an easy setup and usage. One thing is for sure, we’re hooked.

1. Enable Gzip Compression

While compressing pages adds just a tad to your web server’s overhead, it will reduce bandwidth and transmission time and make pages appear to load faster for your users. Gzip is a open source compression algorithm that can be used to compress the content of your website before your the web server sends data to a client browser. You can learn how to enable Gzip in Apache here.

2. Minify Javascript/CSS

Minify is the process (and software) of removing unnecessary formatting characters and white space from javascript code. The result is smaller files, faster transmission and quicker page loads. You can learn all about minify javascript here.

3. Use A Content Distribution Network (CDN)

A CDN is a system of interconnected servers around the glove, that distribute content and assets around among them to reduce the distance between a server and a client’s browser. They are commonly used by large media web sites, such as Youtube and Break. You can find a list of free CDNs here.

4. Optimize Images

Take advantage of image compression and reduce the size of photos and graphics on you site dramatically. Never use a raw bitmap (.bmp) on your site, instead save photos as JPEG and graphics as PNG. Smaller images tend to be ok with a smaller quality setting, while large photos should be high to enjoy.

5. Use External Hosts Javascript And CSS

The Http protocol sets a limit as to how many concurrent files can be downloaded from a given host. This is currently set to two, which means the browser will have to wait for one to finish before getting the next file. While this isn’t true of all file types, it is a good enough reason to host applicable files on alternative subdomains. Hosting your Javascript and CSS files on a different subdomain increases the amount of files the browser can download simultaneously.

6. Avoid Using Redirects

While redirects can be very useful, it’s important to remember that implementing them forces your web server to do slightly more work per applicable request. Always avoid redirect strings (301 -> 301 -> 200 or even worse 301 -> 302 -> 200) and use these tools only when no other alternatives are available.

7. Use Fewer Files

Of the most simple and quick way to improve load time is to combine files into one. Remember the limit of downloads discussed in item 5 above? Try combining Javascript and CSS files, and make use of CSS sprites. It’s a method of combining several images in one file and use CSS for positioning. You can read how popular websites using sprites here.

But there is no automated method out of the box, and there are now several scripts floating around the Internet that may work or just partially work. A major concern is the ability to update, easily switch to PHP 5.3 when the application is ready and also easily add / remove extensions.

With these considerations in mind, this is the best way to install PHP 5.2 on Ubuntu 10.04 Lucid Lynx:

We will install PHP 5.2 using apt-get and install from Ralp Janke’s repository.

• Let’s install Phyton software properties, as it makes adding the repo much easier:
  sudo apt-get install python-software-properties
• Add the repository and install the GPG security verification key:
  add-apt-repository ppa:txwikinger/php5.2
• Now we need to create a file called /etc/apt/preferences.d/php that locks the PHP version.
     This way they remain at 5.2 and don’t get upgraded to 5.3 whenever you run apt-get to upgrade:
  sudo vim /etc/apt/preferences.d/php then copy / paste the lines at the end of this article, save and quit vim.
• Finally we do an update and the proper packages are pulled from the repositories:
  sudo apt-get update

If you want to verify what version you’re running, simply place a file into the root of your web server with this line “<?php phpinfo(); ?>”, save it as phpinfo.php and call it in your browser.

6. BuiltWith Technology Profiler

BuiltWith is a web site profiler tool, that returns all the technologies it can find on a particular page. BuiltWith extension helps developers, researchers and designers find out what technologies web pages are using and in turn help them to decide what technologies to implement. BuiltWith currently tracks widgets (snap preview), analytics (Google, Nielsen), frameworks (.NET, Java), publishing (WordPress, Blogger), advertising (DoubleClick, AdSense), CDNs (Amazon S3, Limelight), standards (XHTML,RSS), hosting software (Apache, IIS, CentOS, Debian).

5. Session Manager

With Session Manager you can quickly save your current browser state and reload it whenever necessary. You can manage multiple sessions, rename or remove them from the session library. Each session remembers the state of the browser at its creation time, i.e the opened tabs and windows. Once a session is opened, the browser is restored to its state.

4. CSSViewer

CSS Viewer shows the css parameters of any element in a web page, to enable/disable it simply click the toolbar icon. It’s a simple CSS property viewer for designers and web developers based on the firefox add on.

3.Chrome SEO

The Google Chrome SEO Extension provides an overview to Search Engine Optimization Tools which can help with Competitive Analysis, Keyword Research, Back-link Checks, PageRank analysis and other valuable SEO tasks.

2. Web Developer

The Web Developer extension adds a toolbar button to the browser with various web developer tools. This is the official port of the popular Web Developer extension for Firefox written by the same person.

1. Firebug Lite for Google Chrome

Firebug Lite, as the name implies is the sibling of the famous version we used for so long now in Firefox. It provides the rich visual representation in HTML elements, DOM elements, and Box Model shading. It provides also some cool features like inspecting HTML elements with your mouse, DOM inspection, JavaScript debugging and live editing CSS properties.

Following is a short list of useful commands to inspect a running memcached instance.

How to find the IP address and port to connect:

ps aux | grep memcached will give us the process running memcached, with listening ip address and port. If this command does not yield any results, you likely not running the daemon and need to start it up first.

We can now connect using this info:

telnet 127.0.0.1 11211 (replace your IP address and port)

Supported Commands:

The following is a list of the most important memcached commands. For a more complete list of supported commands, check out the memcached wiki document.

Traffic Statistics:

stats will give you general info on version, traffic, hits/misses, connections and more.

Example Output:

STAT pid 14868
STAT uptime 175931
STAT time 1220540125
STAT version 1.2.2
STAT pointer_size 32
STAT rusage_user 620.299700
STAT rusage_system 1545.703017
STAT curr_items 228
STAT total_items 779
STAT bytes 15525
STAT curr_connections 92
STAT total_connections 1740
STAT connection_structures 165
STAT cmd_get 7411
STAT cmd_set 28445156
STAT get_hits 5183
STAT get_misses 2228
STAT evictions 0
STAT bytes_read 2112768087
STAT bytes_written 1000038245
STAT limit_maxbytes 52428800
STAT threads 1
END

Memory Statistics:

stats slabs gives you detailed memory statistics

Example Output:

STAT 1:chunk_size 80
STAT 1:chunks_per_page 13107
STAT 1:total_pages 1
STAT 1:total_chunks 13107
STAT 1:used_chunks 13106
STAT 1:free_chunks 1
STAT 1:free_chunks_end 12886
STAT 2:chunk_size 100
STAT 2:chunks_per_page 10485
STAT 2:total_pages 1
STAT 2:total_chunks 10485
STAT 2:used_chunks 10484
STAT 2:free_chunks 1
STAT 2:free_chunks_end 10477
[...]
STAT active_slabs 3
STAT total_malloced 3145436
END

Items Statistics:

stats items lets you know the item count and their age.

Example Output:

stats items
STAT items:1:number 220
STAT items:1:age 83095
STAT items:2:number 7
STAT items:2:age 1405
[...]
END

Using Telnet to get details about memcache is a nice way of looking under the hood or a running production system, where outputting variables in PHP or ASP .NET is not feasible. Zero values in hit/misses indicate that memcache in not used for some reason, connection errors may hint to a networking or permission issue. And with too many evictions you may need to increase the allocated amount of memory.

It is not something intuitive or readily available (at least it seems), but the solution is short and very simple.

While this query:

SELECT DISTINCT column1
FROM table1

gives us all records without the duplicates, this one returns only the duplicate ones:

SELECT DISTINCT column1
FROM table1
GROUP BY column1
HAVING COUNT(column1) > 1

And by increasing the having count, you can retrieve records with multiple occurrences.

Let’s look at how this would work by pulling CNN’s breaking news feed as JSON:

curl http://twitter.com/status/user_timeline/cnnbrk.json

or XML:

curl http://twitter.com/status/user_timeline/cnnbrk.xml

That will give you the last 20 tweets in either JSON or XML format.

An even more interesting option is to get messages where you have been mentioned. It’s a bit more complicated, as we need to supply login credentials, but no rocket science either:

curl -u “username:password” http://www.twitter.com/statuses/mentions.json (or .xml if you prefer)

That’ll give you the last few tweets mentioning the user supplied with the curl command. Now all you got to figure out is how to parse the messages and plug them into your application.