The language files can be found at the official Simple:Press Forum translations website.

Enjoy!

Related posts:

1. Brazillian Portuguese (pt_BR) language file for WP-Filebase released
2. 5 best practices on developing Wordpress plugins
3. Smartly resolving your Wordpress pages and posts JavaScript and CSS dependences

For me as a Linux^w user I always had to type long lines to start my SSH^w sessions. It’s no rocket science, you know, but for he who types thousands of characters each day, each character save is golden.

We usally start our SSH sessions by typing the following command string:

ssh user@domain.tld

I’ve tried to shorten this by adding the domain and its TLD^w to my hosts file with a shorter alias like

hname hostname.tld

But obviously that crashed against Apache^w Vhost^w capability, the request never make it to the other end.

I personally have SSH keys on some of my servers to avoid typing passwords, that is good to prevent against MITM^w attacks and keyloggers, but I still have to type the string mentioned lines above.

Then, with 3 lines in a SSH’s configuration file on my home directory (yes, you don’t need to alter the server’s SSH configuration file and yes, you can do that on your shared hosting’s shell account).

It’s very simple. SSH allows some user-based configuration in your ~/.ssh directory (note that ~ stands for your home directory (usually /home/yourusername) and it also provides Aliases^w capability.

The aliases can be configured in such a way that you won’t need to type neither the FQDN^w nor even type a single username EVER MORE!

Your old

ssh user@domain.tld

will be shortened to

ssh aliasname

Ok, talk is cheap, show me the code!

Creating the need files and directories

All the magic occurs on the config in your already-mentioned ~/.ssh/ directory. If you don’t have one, create it and secure it, as the following:

mkdir ~/.ssh/
chmod 700 ~/.ssh/

If the file does not exists, create it and secure it propperly, like:

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Syntax model

Host [alias name]
HostName [host's fqdn]
User [username to log-in as]

Without the braces, please!

For a user called jdoe on mydomain.com being shorted md, the code would be the following:

Host md
HostName mydomain.com
User jdoe

Save the file and you can start typing less with SSH:

ssh md

And that’s IT!

Wow that’s great! What else this beauty can do?

Omnipresence

Do you have the same username in a large number of machines, like in a local network? So you have to love the * wildcard.

Host *
User jdoe

I have many names

Want to follow a naming pattern but also wants to have shorter ones? Give multiple aliases!

Host gdf, gandalf
HostName gandalf.mydomain.com
User jdoe

Avoid the front door

Security through obscurity is always fun! Have your SSH aliases even in hosts with sshd running in a different port.

Host md
HostName mydomain.com
User jdoe
Port 11

Be backwards compatible

Have outdated SSH servers? I hope not! But if you do, you may also define a different protocol in a host-based manner.

Host md
HostName mydomain.com
User jdoe
Protocol 1

Handle multiple keys

You may specify the specific (what?) SSH key file for a host.

Host md
HostName mydomain.com
User jdoe
IdentityFile ~/mykey.pub

And it also works on SCP!

Oh yeah, file transfers are easier now!

scp somefile.txt md:/path/to/upload

More parameters can be found on SSH manual, page 5.

man ssh 5

Phew! That’s all folks! Hope it helps someone as much as helped me! Anyone have any neat SSH trick?

Related posts:

1. Ubuntu is going Windows-way
2. Quick Tip: Forcing www. to avoid duplicate content

Wordpress^w’s excellent plugin infrastructure with their hooks and actions provides us a beautiful and clean form of including our JavaScript in specific pages.

In this tutorial, we will be using three Wordpress functions: get_post_meta() and wp_enqueue_script() and wp_enqueue_style().

Custom Fields

Well, you may have noticed that get_post_meta() is about the custom fields and you’re just right.

We’ll be using posts and pages custom field to add scripts and stylesheet files. I’m using the keys ‘js’ and ‘css’ to JavaScript and CSS files respectively.

If you don’t know how to use custom fields, please visit the Wordpress documentation on Custom Fields.

The documentation on these functions are available at Wordpress documentation site:

get_post_meta

http://codex.wordpress.org/Function_Reference/get_post_meta

wp_enqueue_style

http://codex.wordpress.org/Function_Reference/wp_enqueue_style

wp_enqueue_script

http://codex.wordpress.org/Function_Reference/wp_enqueue_script

get_post_meta

This function is responsible by getting our custom field entries and returning them as an array.
If one or more entries are found, the array is returned with normal indexes (0..1…) and with the custom field values. If no entries are found, an empty array is returned.

Well, our return type will be always array so foreach will fit perfectly even on an empty set.

header.php file

All code described in the following examples must be placed at least one line before the wp_head() function in your header.php file. if your header.php file is missing a wp_head() call, it shouldn’t. wp_head() function does lots of important things and many plugins use it. Please consider adding it to your code.

wp_enqueue_script and wp_enqueue_style

Some plugin developers may be not aware of these beautiful functions or even how scripts and stylesheets are managed by Wordpress.

All scripts and style, when properly set, are enqueued and inserted automatically when wp_head() is called. Enqueuing your scripts and style are a better way other than just hooking wp_head() and printing to the output buffer.

This assures that our scripts and styles will be included only at the wp_head() call and will not be printed out from nowhere messing out peoples templates and plugins.

NOTE: Due the printing menace of script tags and JavaScript code chunks, WP-Minify parses the ENTIRE site output in order to properly minify them.

This technique also prevents overlapping includes of twicely defined entries.

Wordpress gives us respectively wp_enqueue_script and wp_enqueue_style for enqueueing scripts and stylesheets. Both functions receive a script or stylesheet unique identifier as the first parameter and the path as second (more parameters are available, please refer to the documentation for more understanding on this subject).

As this is an automated process, I’m using as unique identifier the md5 hash of the file’s path (the custom field value).

NOTE: This solution is made for JavaScript and CSS files that follows a unique parent directory. Please refer to the examples for more explanation.

So let’s get back to our header.php file just before the wp_head() call that we mentioned before. We also remember that the custom field key for JavaScript files that we’ll be using in this example is ‘js’.

JavaScript files

The following code will use get_post_meta to get the array (empty or not) of JavaScript files that have been set through custom fields under the js folder under our template directory.

foreach($js = get_post_meta($post->ID,'js') as $jscript) wp_enqueue_script(md5($jscript),get_bloginfo('template_directory').'/js/'.$jscript);

CSS files

The following code will use get_post_meta to get the array (empty or not) of CSS files that have been set through custom fields under the css folder under our template directory.

foreach($css = get_post_meta($post->ID,'css') as $style) wp_enqueue_style(md5($style),get_bloginfo('template_directory').'/css/'.$style);

Simple huh? One line each and your problems are solved.

You may now call wp_head() and go drink your coffee!

Related posts:

1. WP-Minify’s new version vanished Wordpress’ HTTP requests issue
2. 5 best practices on developing Wordpress plugins
3. Brazillian Portuguese (pt_BR) language file released for Simple:Press Forum Wordpress plugin

As Wordpress is a Procedural Programming^w oriented platform the function wrapped to the hooks and actions have no scope when called except global this can be hell when developing plugins. We must take extra-care to not compromise our plugin security and compatibility.

In our road developing plugins we learned some lessons, here is our share.

1. Enable your WP_DEBUG

This caused me some nightmares the first time I turned it on. Lots of plugin developers doesn’t have the habit of working with PHP’s error_reporting at the E_ALL level (Maximum Level, including notices of undefined variables) and I god SEVERAL notices on screen.

WP_DEBUG can be enabled by simply adding the following line to your wp-config.php file.

define('WP_DEBUG',true);

PHP is a very friendly (if we can call this way) programming language that doesn’t cares very much to variable initialization but you should initialize all your variables and check if they are set with the language’s native isset() function.

If you have WP_DEBUG you will se NO errors at all so if your script breaks somewhere at the development, you’ll suffer lots of pain trying to blindly debug your code. Lots of experience had me finding unclosed brackets, parentheses and semicolons but, come on, I’m no masochist.

The best tip here is to have a development Wordpress installation. If this is not possible (or you are just too lazy), as lots of plugin developers (very popular ones) aren’t caring about notices showing up to your visitors if you have WP_DEBUG enabled you can always use the good and old PHP code to enable debug only if you are the visitor.

# 200.200.200.200 is an example IP and should be replaced by your own
# if you don't know your IP you can visit www.whatismyip.com
if ($_SERVER['REMOTE_ADDR'] == '200.200.200.200') define('WP_DEBUG',true);

2. Have a cleanup deactivation routine

Had you ever took a look at your wp_options table after a long time activating and deactivating plugins? If you so you probably had seen the garbage left out there.

If you are going to write an option with add_option or update_option please, please, please, be sure to remove your options upon plugin deactivation. I'm pretty sure no one wants your options leftovers as a souvenir.

To achieve such thing, you must register a deactivation hook by the register_deactivation_hook as following

register_deactivation_hook( __FILE__, 'plugin_deactivate' );

And obviously you will have to code an appropriate deactivation function, like plugin_deactivate in the example.

NOTE: Your deactivation function must be at the script's main PHP file.
NOTE: Your deactivation function may have any name.
NOTE: The __FILE__ part specified at the deactivation hook is referencing your own script file.

I personally put all my options that goes to the wp_options database in a global associative array so if I add more options my cleanup function will still be compliant.

global $aOptions;
$aOptions = array(
    'myplugin-default-lang' => 'en_US'
);

I also put my deactivation and cleanup functions apart so I can call the cleanup from within the deactivation function. This is made so if I want to add more deactivation functionalities else than cleanup I can do this without polluting my cleanup function with non-cleanup procedures.

The plugin_deactivate function will look like the following:

function plugin_deactivate() {
    // Cleanup
    plugin_cleanup();
} // end :: function :: plugin_deactivate

And the cleanup function as it follows:

function plugin_cleanup() {
 
    global $aOptions;
 
    // Delete our options
    foreach ($aOptions as $sOptionKey => $sOptionValue):
        delete_option($sOptionKey);
    endforeach;
 
} // end :: function :: plugin_cleanup

This should be enough to keep your options table tidy.

3. Protect files that shouldn't be accessed directly

Almost all your plugin files shouldn't be access directly. Exception goes to scripts that receives data from outside the Wordpress framework like thumbnail generators, image replacement techniques, AJAX, and such.

To disable direct access to your PHP files you must check if some Wordpress function is present and if not, shutdown the script if a good and old exit(); call.

The example goes as:

if (!function_exists ('add_action')): 
    header('Status: 403 Forbidden');
    header('HTTP/1.1 403 Forbidden');
    exit();
endif;

The example above also sends a 403 header in both formats (Internet Explorer and decent browsers, respectively).

4. Use internationalization even if you aren't going to translate yet

Even if you are not planning release you plugin with many languages I strongly recommend that you build yours i18n-ready by wrapping your texts on gettextw functions so other users can help (or even you in the future) to translate your plugin.

The basics

Internationalization basics in PHP is very simple. There are mainly two functions: __() and _e(). The difference is that __() returns the internationalized string _e() echoes it.

When text is within a variable or returned by a function you should use the __() function and if you want to echo it, _e() instead.

Echoing internationalized text in a template file

<h2><?php _e('My text goes here','My text domain goes here'); ?></h2>

Returning internationalized text in a function

function somefunction() {
    return __('My text goes here','My text domain goes here');</h2>
} // end :: function :: somefunction

Internationalization is a wide subject and is covered greatly in the Wordpress "Writing a Plugin" page.

Internationalizing your plugin is also a good marketing strategy since if someone releases a language file for your plugin, is also making it available in a wider market-share slice.

5. Employ current coding best practices

There are some wide best practices that are not exclusively to the Wordpress Plugin scope.

Separate your code

Applying this technique on Wordpress Plugin development is such as having the plugin's main php file just making the calls and registering the hooks and have your functions properly laid under a lib/ function or such. Same things goes to images/, js/ (JavaScript) and css/.

Document your code

Ok, this is like telling grown-ups to not touch the hot oven or putting the finger in a wall socket but many people still lacks in documenting code.

I suggest to keep your functions, classes and files documented in the phpDocumentor syntax.

This kind of syntax is inherited from Java and other languages apply it since is very readable and parse-able.

It goes like the following:

/**
 * My loved function
 *
 * This function collects some data and process in this way to give the desired result.
 *
 * @param    string   $varname    Description of the variable
 * @param    int   $othervarname    Description of the variable
 * @return    void   This function returns nothing
 */

Stay DRY

Try to avoid two functions that do basically the same thing. If you have two functions in separate classes that to the same thing (like string sanitization), consider having a utility class.

Bonus Tip!

Avoid kidnapping people's wp_head() and wp_footer() with your plugin propaganda. If you want to make such thing, do as HTML code comment or make this branding stuff optional.

If you are going to make your plugin free, make it free, not AD dependant. If you think your plugin should be paid, then make it paid. Placing plugin ADs in the themplate may scare out some users. Your free plugin shall make your own propaganda by being useful and rich-featured, not by printing it out.

What's your tip?

Related posts:

1. Smartly resolving your Wordpress pages and posts JavaScript and CSS dependences
2. WP-Minify’s new version vanished Wordpress’ HTTP requests issue
3. Brazillian Portuguese (pt_BR) language file released for Simple:Press Forum Wordpress plugin

This plugin is a great download / file manager that covered just all holes that we need in our clients’ projects. It features a highly configurable theming, internationalization, categorization, download counter, traffic/bitrate limiter and more.

This is certainly a recommended Wordpress Plugin for all.

The language file was translated from the provided template.po.

Please submit any fixes for translation errors that you may find.

Download pt_BR.mo language file for WP-Filebase
Optional download pt_BR.po language file for WP-Filebase

Related posts:

1. Brazillian Portuguese (pt_BR) language file released for Simple:Press Forum Wordpress plugin
2. 5 best practices on developing Wordpress plugins
3. Smartly resolving your Wordpress pages and posts JavaScript and CSS dependences

The game released by Cisco as part of its CCNA training has the objective of training your binary skills. You will be asked for the bits corresponding to a certain value or vice-versa.

Very interesting, can get really naughty sometimes.

Play at your own risk at Cisco’s website.

No related posts.

The C-like syntax for control structures are very intuitive but can deal lots of trouble when your code has lot of pages and lots of ifs, fors, while and therefore lots of opening and closing braces.

NOTE: As remembered by jakyra on DZone, if you keep your code tidy you shouldn’t have functions that long and though not having this kind of problem, but this alternative syntax still have good benefits.

The alternative syntax

The alternative syntax consists in changing the opening brace ({) to a colon (:) and each closing brace to its respective closing function: endif;, endfor;, endforeach;, endwhile; and endswitch;.

Closing functions list

opens if ([parameters]):

closes endif;

opens for ([parameters]):

closes endfor;

opens foreach ([parameters]):

closes endforeach;

opens while ([parameters]):

closes endwhile;

opens switch ([value]):

closes endswitch;

Benefits of this alternative syntax

The benefits of using this syntax are clear when put into practice. A far more readable code with no more commenting out braces like } // end :: if. You can instantly know which structural condition this closing brace belongs to and will no longer get confused between these and function braces.

Disadvantages of the alternative syntax

I personally do not consider this as a disadvantage but some people might consider since some text editors and IDEs have the ability to highlight the matching brace.

Examples

If

NOTE: else and elseif control structures follow the same structure.

// Standard syntax
if ($variable === TRUE) {
	$otherVariable = "foo";
	$aThirdVariable = "bar";
} elseif ($variable == "foo") {
	$otherVariable = "foo";
	$aThirdVariable = "foo";
} else {
	$otherVariable = "bar";
	$aThirdVariable = "foo";
} // end :: if

// Alternative syntax
if ($variable === TRUE):
	$otherVariable = "foo";
	$aThirdVariable = "bar";
elseif ($variable == "foo"):
	$otherVariable = "foo";
	$aThirdVariable = "foo";
else:
	$otherVariable = "bar";
	$aThirdVariable = "foo";
endif;

Foreach

$array = array("foo","bar");
 
// Standard syntax
foreach ($array as $key => $value) {
	$foo = $key;
	$bar = $value;
} // end :: foreach

$array = array("foo","bar");
 
// Alternative syntax
foreach ($array as $key => $value):
	$foo = $key;
	$bar = $value;
endforeach;

For

// Standard syntax
for (
	$i=0;
	$i<10;
	$i++
) {
	$foo = $i;
	$bar = $i*10;
	print $foo+$bar;
} // end :: for

// Alternative syntax
for (
	$i=0;
	$i<10;
	$i++
):
	$foo = $i;
	$bar = $i*10;
	print $foo+$bar;
endfor;

While

$i = 10;
 
// Standard syntax
while ($i > 0) {
	$foo = $i--;
	print $foo;
} // end :: while

$i = 10;
 
// Alternative syntax
while ($i > 0):
	$foo = $i--;
	print $foo;
endwhile;

Switch

// Standard syntax
switch ($foo) {
case "foo":
	$bar = FALSE;
	break;
case "bar":
default:
	$bar = TRUE;
} // end :: switch

// Alternative syntax
switch ($foo):
case "foo":
	$bar = FALSE;
	break;
case "bar":
default:
	$bar = TRUE;
endswitch;

Photo: Andy Fitz @ Flickr

Related posts:

1. Smartly resolving your Wordpress pages and posts JavaScript and CSS dependences
2. Quick-tip: PHP mail() header misuse “vulnerability”
3. 5 best practices on developing Wordpress plugins

For years optimization techniques such as Caching in many levels (Disk/Memory), Compression, Clustering and other were developed to acheive greater performance.

Global Warming is there for years and is getting worse every year but it seems that movements under IT has begun in order to create greener solutions. Many hosts such as Dreamhost (which we’re proud of being our hosting company) have already started their effort in reducing or even neutralizing their Carbon Footprint and now developers can help on their side too.

The Concept

Well, we don’t have to go too far to realize where optimization crosses paths with sustainability. It’s simple, it’s all about electricity (power) saving.

Again, it’s all about electricity. Every single bit minor instruction spends a very little piece of energy that goes through the processor and memory I/O operations and spends some little more sending data over the ethernet ports.

Let’s go from the beginning. The user has requested a website, the request goes through all the routers and switches in the way to the requisition.

NOTE: We are not considering this power consumption because it is not dependent on the application’s optimization.

Here is where optimization makes the difference: the way back.

Larger image or source files will take more CPU cycles to be processed, more Disk usage and more space allocated in memory. Then these big files have to be sent to the client and if you have many files this means more HTTP connections and headers being sent.

Techniques such CSS Sprites (heavily used by Google and other big companies) aid to reduce the HTTP Connections between the server and the client.

Each HTTP connections contains not only the file’s data but it is preceded by header data with the file’s type, modified date and some other info so two square 20px images are bigger than one rectangular 40px per 20px image (the two 20px square images side by side).

Then the requested files come from the server to the client by all the router and switches in-between them spending more power in transmission until it gets to its destiny where will consume more power to be rendered by client browser’s engine and window manager (Windows, Gnome, Kde etc).

How to collaborate?

Optimize your software. Yahoo’s YSlow and Google’s Page Speed are great kickstarts. You can also check our articles on caching.

As all great saving and recycling, results will only take place with everyone’s effort. These taken under huge proportions can result in great saving and thus more breathe to our planet.

Think green.

Other considerations under power saving on software development

In this 2007 article, Mark Ontkush showed his study where dark-pallete-themed web applications required less energy from users’ CRT monitors.

“an all white web page uses about 74 watts to display, while an all black page uses only 59 watts. I thought I would do a little math and see what could be saved by moving a high volume site to the black format.”

Mark Ontkush

And then the results came when he compared to traffic reports of huge websites such as Google:

Take at look at Google, who gets about 200 million queries a day. Let’s assume each query is displayed for about 10 seconds; that means Google is running for about 550,000 hours every day on some desktop. Assuming that users run Google in full screen mode, the shift to a black background [on a CRT monitor! mjo] will save a total of 15 (74-59) watts. That turns into a global savings of 8.3 Megawatt-hours per day, or about 3000 Megawatt-hours a year. Now take into account that about 25 percent of the monitors in the world are CRTs, and at 10 cents a kilowatt-hour, that’s $75,000, a goodly amount of energy and dollars for changing a few color codes.

Mark Ontkush

Black is the new black!

Unfortunately, dark-themed websites tend to be less accepted by the users, and some have even reported that white characters tend to blur by reading stress while reading an extensive text.

And you developer? What are you doing to save the world?

Related posts:

1. WP-Minify’s new version vanished Wordpress’ HTTP requests issue
2. Ubuntu is going Windows-way

This was one of the first cryptography method with historical registry, used by the Greeks (Spartans, more specifically) to cypher messages during military campaigns thus not letting the enemy know their moves even if the message carrier gets caught, tortured or killed.

The cypher

A very simple approach implements transposition cypher with a strip of leather, cloth or paper around a baton. Baton diameter inflicts directly in the encryption result so we can say that it is this algorithm’s symmetric key

Encryption process

To encrypt the message, the sender rolls the strip of leather (or cloth, or paper, etc) around his baton and draw the message (vertically, character by character) across the strips, going back to the first strip on the next “line” when writing to the last strip, like word-wrap.

This example from Wikipedia ilustrates well the concept:

_____________________________________________________________
       |   |   |   |   |   |  |
       | H | E | L | P | M |  |
     __| E | I | A | M | U |__|
    |  | N | D | E | R | A |
    |  | T | T | A | C | K |
    |  |   |   |   |   |   |
_____________________________________________________________

Decryption process

As most symmetrical-key cypher systems, the decryption process is given by reversing the encryption process with the same key applied. The person with a baton with the same diameter (the same key) would be able to roll the strip over it and decrypt the message.

Key value restrictions

For a baton with 1cm diameter, the message will look just like the original, so we will discard key values of 1. The same occurs if key value is equal to the message length.

The algorithm

The key represents the number of characters in each line of text:

key value: 2

2 characters per line

key value: 4

4 characters per line

For the explanation of this algorithm we’ll encrypt the following message: “HEAVYWORKS” (nice huh?)

Chunk split

The message is split into chunks of N characters, being N being the key value.

HE
AV
YW
OR
KS

HEA
VYW
ORK
S

HEAV
YWOR
KS

Key relation

All the character sequences are now ordered in columns after we splitted the message in chunks with the length of the key value. You should realized already that the number of columns will be equal to the chunk length and thus the key value.

Transposition

The transposition is made by creating new (encrypted) chunks with the characters from each column. These chunks will be of the same length of the corresponding column.
At the end of the process, all cyphered chunks are put together.

HAYOK EVWRS

HVOS EYR AWK

HYK EWS AO VR

HAYOKEVWRS

HVOSEYRAWK

HYKEWSAOVR

The C++ Way

The Scytale class got very simple, as the algorithm is very simple. It uses only three libraries: iostream, vector (for variable-length arrays) and cmath (for some ceil calculation).

The binary is called from command-line with the -k keylenght and -m message (quote escaped).

Under the hood

The main function fetches the options using GNU getopts and thus does some early input checking and error handling.

All OK, the key is set by Scytale’s class’ setKey method and message is passed as a parameter to the encrypt method. From this point validate method is called in order to validate if the key and messages are fit into the needs on try/catch statements.

Passing the validation, the createStack method creates the character chunk stack (oh, really!?) from the plain-text message with two nested for laces (first for rows, second for char position) that is handled over to scrambleStack in order to perform the transposition with another two netsted for laces (now the first for column and the second for row).

Finally, the encrypted message

NOTE: If validation fails, program exits with a EXIT_FAILURE error code and the error message is echoed to stderr.

Source

The source file is well documented using a kind of Javadoc syntax and can be downloaded here.

MD5 Sum

a33edf6a4c4670380ce8c8e40edcb3d7 scytale.zip

Compiling

In order to compile with g++ use the following line:

$ g++ -Wall -ansi -pedantic -o scytale scytale.cpp

NOTE: I was not able to compile this under Windows XP with MinGW’s g++. Got compiling errors because of getopts and vector. If someone succeeds in compiling under Windows XP post a comment!

Drawbacks

This system cannot assure authenticity because it has no way to prove the author of the message so it can be crafted by the enemy that deduced, guessed or stolen the key.

Related posts:

1. Smartly resolving your Wordpress pages and posts JavaScript and CSS dependences

Joseph speaks in a very well-humorous way about “Advanced SQL Injection” covering from Error-based SQL Injection to Blind SQL Injection, pretty nasty and nice! Gives another good overview under what we developers should look when protecting our code.

Here is the video:

DojoSec Monthly Briefings – February 2009 – Joseph McCray from Marcus Carey on Vimeo.

Don’t forget to check out other DojoSec videos at Marcus Carey’s Vimeo channel and LearnSecurityOnline.com to great security-related material!

Related posts:

1. Ordering by fields that contains null values