Cody Taylor

TinyURLs can be very useful when you have a long url to type into something like an iphone or some other mobile device where the keyboard is rather tedious. On a few of my sites I was looking for a way to automatically generate a tinyURL with the least amount of effort. Since I use wordpress for most of them I decided to go with a shortcode.

Shortcodes seem to be gaining a fair amount of attention in the wordpress community and with good reason. The Shortcode API, which was new in wordpress 2.5, is a simple set of functions for creating macro codes for use in your posts. Shortcodes are written by providing a handler function and they accept parameters too. Here is a wordpress shortcode to generate a tinyURL for a post.

//Generate Tiny URLS For A Post 
function get_tiny_url($arguments)
{
  if(empty($arguments))
    $url = get_permalink($post->ID);
  else
    $url = urlencode($arguments['url']);
  if($url)
    {
      $tiny_url = 'http://tinyurl.com/api-create.php?url='.$url;
      $new_url = file_get_contents($tiny_url);
    }
    else
      $new_url = "Error";
    return $new_url;
}

add_shortcode('small_url', 'get_tiny_url');

If the url parameter is not defined then the function will attempt to use the wordpress function get_permalink($post->ID) which will return the current posts url. Also you can pass in a parameter if you want to show a tinyURL to another location. Using curl instead of file_get_contents would probably be faster but I didn’t want to make the example to long. The add_shortcode function is what tells the API to use the get_tiny_url function when it encounters the small_url shortcode. Note that this will call on the tinyurl api every page view so it would probably be prudent to set the tiny urls in the database so you only have to check once on a production site although I’m not sure if they expire or not.
This shortcode can be called in the post by typing :

[small_url]  // or
[small_url url='http://codytaylor.org']

I was reading about some php performance tips at work today and decided to throw together some of the ways to make your php site faster.

Here’s a couple of short tips to avoid making your site lag for the user:

1. Unset your variables. This frees up a surprising amount of memory
2. Use memcache
3. Turn on apache’s mod_deflate
4. If your database is local then close your connections when you’re done with them
5. If your database is remote then use persistant connections
6. Don’t use functions inside of a for loop control expression unless absolutely necessary. Example :
   

   
   for($i=0;$i<some_big_calculation(20);$i++)
   

   
   The some_big_calculation function will be called every iteration.
7. Use string concatenation instead of embedding variables in strings.
   

   
   $some_string = "asdf $asdf2 asdf"; //bad
   $some_string = 'asdf '.$asdf2.' asdf'; //good
   

8. When including files, use at least a relative path so PHP doesn’t have to look in the entire path.
   

   
   include("./some_file.php"); // looks in the current directory
   include("wrong.php"); // searches every directory in the path
   

9. Try not to use include_once or require_once. They are more expensive and it really isn’t that hard to only include files once
10. Not everything needs to be an object. There is a fair amount of overhead when doing everything OOP.
11. Use output buffering to make everything seem faster.

Hopefully I didn’t miss any of the big ones.

I didn’t know enough about antenna gain to define it if someone asked me to so I did some research. Gain itself seems to be a tricky term to define, so I’m going to have to explain a few other things along with it.

Antenna gain is basically measure of the effectiveness of a directional antenna as compared to a standard nondirectional antenna.

One of the major parameters used in analyzing the performance of radio frequency (RF) communications links is the amount of transmitter power directed toward an RF receiver.

This power is derived from a combination of:
1 – Transmitter power
2 – The ability of the antenna(s) to direct that power toward an RF receiver(s).

Directivity
The directivity of the antenna is determined by the antenna design. Directivity is the ability of an antenna to focus energy in a particular direction when transmitting or to receive energy better from a particular direction when receiving. To determine the directivity of an antenna, we need a reference antenna with which to compare our antenna’s performance.

Over the years there have been several different reference antennas used. Today an isotropic radiator is preferred as the standard antenna for comparison. The isotropic antenna transmits equal amounts of power in all directions (like a light bulb).

To increase the directivity of a bulb’s light (the antenna’s energy), similar to a flash light or automobile head lamp in this example, a reflector (antenna) is added behind the bulb. At a distance, in the light beam, the light bulb now appears to be much brighter. The amount that the bulb appears brighter compared to the bulb without a reflector is the directivity of the reflector (antenna).

When the directivity is converted to decibels we call it the antenna gain relative to an isotropic source (dBi). Typically the higher the gain, the more efficient the antenna’s performance, and the farther the range of the antenna will operate. Roughly for every 6 dBi in gain, you double the range of the antenna.

It should be noted that many issues need to be considered when selecting the “best” antenna for the application, and you should discuss any antenna selection with someone knowledgeable in RF radiation and antenna performance.

So a better definition of antenna gain is:
A relative measure of an antenna’s ability to direct or concentrate radio frequency energy in a particular direction or pattern. The measurement is typically measured in dBi (Decibels relative to an isotropic radiator) or in dBd (Decibels relative to a dipole radiator).

Everyone seems to be all about Twitter so here’s some simple examples of how to update your Twitter status from a command line prompt, web server or simple html web site. These three examples require curl so install it if you don’t already have it. For these examples I’ll be using my Twitter user name ‘codytaylor1234’. My password is not ‘mypassword’ so make sure you put in your own information.

The easiest way to update your Twitter account is to just call curl from the command line with this command.

curl --basic --user "codytaylor1234:mypassword" --data-ascii 
"status=This Twitter update brought to you by curl on the command line" 
"http://twitter.com/statuses/update.json"

To update your Twitter status with PHP you are going to want to do the same sort of thing but with a bit more typing.

<?php
$username = 'codytaylor1234';
$password = 'mypassword';

$update = 'This Twitter update is from a php script using curl';

$url = 'http://twitter.com/statuses/update.json';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "$url");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "status=".$update);
curl_setopt($ch, CURLOPT_USERPWD, $username.":".$password);
$result = curl_exec($ch);
curl_close($ch);

if($result)
    echo 'success';

?>;

Since a cross-domain request in Javascript isn’t really an option we have to create a proxy using PHP in order to authenticate the user on the Twitter API. If anyone knows an easy way authenticate a Twitter user using only javascript I’d love to hear it. Anyway if we replace a small amount of code in the above example and put it in a file then we can use a simple ajax request to update our Twitter status. So the new PHP file would be:

<?php
$username = $_POST['username'];
$password = $_POST['password'];

$update = $_POST['update'];

$url = 'http://twitter.com/statuses/update.json';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "$url");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, "status=".$update);
curl_setopt($ch, CURLOPT_USERPWD, $username.":".$password);
$result = curl_exec($ch);
curl_close($ch);

?>

For this example I called that php file ‘twitter-update.php’. Now that we have our simple proxy we can update our twitter status with a simple html form and a little ajax. I used the prototype framework for my javascript.

<script src="includes/prototype.js" type="text/javascript">
<script type='text/javascript'>
function update_twitter()
{
  var param_string = "username="+$('username').value+"&password="+
        $('password').value+"&update="+$('update').value;
  alert(param_string);
  var options = {
    method: "post",
    parameters: param_string,
    onSuccess: function (xhr, Json) {
      alert("Response received successfully.");
    },
    onFailure: function (xhr, Json) {
      alert("Request was unsuccessful.");
    }
  };
  
  var oRequest = new Ajax.Request("twitter-update.php", options);
}

</script>

Obviously this is for example purposes only and if you’re actually using it for production then you should edit it a lot. Now for the last little bit here’s the simple html form that starts it all.

User Name : <input type='text' id='username' value='codytaylor1234'><br>
Password  : <input type='password' id='password' value='mypassword'><br>
New Status : <input type='text' id='update' 
value='Twitter Update from html/javascript/php'><br>
<input type='button' value="Update Twitter" onclick='update_twitter();'>

It seems that the guys at valve are finally going to allow community content to be played by the mainstream user. Along with a non beta version of the sdk that is said to release next week the l4d devs are also going to be overhauling the matchmaking system to support “Add-on Campaigns” which will allow you to select campaigns that you have installed.

Because of the recent announcement of Left 4 Dead 2, a lot of fans are wondering whether it’s worth the trouble creating any custom content because the it may not work with the new game. I found this quote from one of the writers for most of Valve’s games which addresses the issue.

Chet_Faliszek wrote:One thing we do know for sure is we want to make sure that everyone making a Left 4 Dead 1 map now or campaign now it’s still going to work in Left 4 Dead 2. You will be able to start Left 4 Dead 2 up, you will have the new creatures automatically, you’ll have the new weapons you will have all of that in the world, if you want to do some of the new director stuff or some of the new ways we control item placement you can go re-do it and add that, but you can also just leave it the exact same way and it will work.

When I was first reading about this on the Left 4 Dead Blog I started thinking of playing de_dust with hordes of zombies which was apparently done in the demo but never released. But then I remembered that I only have the game for XBOX 360. In the few news reports that I’ve read I haven’t seen any mention at all of XBOX changes. If you read that blog Yasser Malaika talks about how easy it will be to install the add-on by double clicking the VPK file. More than likely Microsoft will make me pay for every custom map that is freely available for the PC version.

Last week the Public Safety Minister, Peter Van Loan, introduced a bill that could force ISP’s to allow police access to all our network data without a warrant. If this were to pass then all the internet service providers would save all our private data and give it up anytime the cops want to have a look at it. This seems to be pretty common practice in many other countries but I was always proud to live in a place where your every action isn’t logged and processed.

Read More

http://www.publicsafety.gc.ca/media/nr/2009/nr20090618-eng.aspx?rss=true

http://www.michaelgeist.ca/content/view/4069/125/

I was forced to use php to generate a cyclic redundancy check (CRC) byte earlier this week. When generating this CRC I needed to check the bit parity of a byte. At first I thought that there would be an example that I could just cut and paste into my code or a library including the function somewhere. I guess that most PHP users don’t really have to work with bits and bytes very often because I couldn’t find an example of doing this. Granted I didn’t really search that hard because writing it was pretty simple. But hopefully the next guy searching for this actually finds this example.

Most of the time we don’t really have to think about types in php. But if you’re dealing with this kind of thing then you usually want to know what you’re working with. This php function example will only work with integers and will return a value of -1 if the first parameter is not a number. The function returns 1 if the number of bits set in the number pased in is odd. Otherwise it will return 0. The second parameter defaults to 4 because that is the number of bytes in a normal php integer. In php if a number becomes larger than an integer can handle, which is called an overflow, it becomes a float. The default integer size is platform dependant but it’s usually 4 bytes. It can be set using the constant PHP_INT_SIZE if you need to change it.

<?php

function odd_parity($something,$number_of_bytes_to_check=4,$double_check=0)
{
    //test to make sure it's a number
    if(!is_numeric($something)) {return -1;}  

    $setbits = 0;

    //get the number of bits that are set
    for($i=0;$i<$number_of_bytes_to_check*8;$i++)
    {
        if($something & (1<<$i)) $setbits++;
    }

    //check if the number of bits set is even or odd   
    $result =  $setbits % 2;
   
    //spit out the results to double check it's working 
    if($double_check)
    echo   "<br>Parity of : ".$something." is ".
    $result." In Binary : ".decbin((int)$something).
    " Checking the right ".($number_of_bytes_to_check*8).
    " Bits";

    return $result;
}

//will return 0 because it's defaulting to 4 bytes
echo odd_parity(0x0100010001);  

?>

Uniform resource locators (URL) are starting to get very long and I’m getting sick of typing ridiculously long strings into safari on my iphone. I don’t really care about the extra bandwidth, It’s just annoying when you’re on the phone telling someone to go check out a 67 character long url and they mistype it three times.

I’ve just started using the tiny url service and so far it’s been useful. On one of my sites I wanted to generate a tiny url for each of my pages to make them quicker to type in and also so people don’t know what get variables I’ve set until they get there. Here is the PHP function that I used to generate a tiny url for every page on the site.

There doesn’t seem to be any documentation at all on the Tiny URL website about this so I’m not sure if it’ll change in the future.
This function passes your desired url to the api-create.php script on the tinyurl domain which returns a nice short url that isn’t a pain to put into your iphone.

function get_tiny_url($url)
{
  $new_url = file_get_contents('http://tinyurl.com/api-create.php?url='.$url);
  return $new_url;
}

$tiny_url = get_tiny_url("http://codytaylor.org");

Not much to it but it made my life easier.

PHP makes life a lot easier for quick or dirty maintenance scripts, cron jobs or web applications but how does it do for older, not so straight forward problems dealing with bits and bytes? I was surprised how easy it was to manipulate bits in a byte with php. Here is an function that made my life a fair amount easier when having to check for a specific bit in a byte.

This function checks whether a certain bit is set or not given a byte and an index. It returns true if the chosen bit is set. It casts the $value argument to a integer just in case. The index $n goes from left to right so the most significant bit is bit one and the least significant is bit eight. This function will only work for integers between 0 and 255 because that was all I needed at the time. It would be trivial to write either a function to separate bytes in an integer or to increase the amount of bits that this function checks. I originally had a different function here but the Internet quickly told me that there was an easier way to do this.

<?php

function check_bit($value,$n=8)
{
    $value = (int)$value;
    if($value & (1<<(8-$n))) { return true; }
    else { return false; }
}

//Check Bit Usage Example
$test_byte1 = "4";

if( check_bit($test_byte1,2))
  echo "Bit 2 is set in ".decbin($test_byte1);
else
  echo "Bit 2 is not set in ".decbin($test_byte1);

?>

Here are the php bitwise operator definitions from the php documentation. Look like C much?

$a & $b	And	Bits that are set in both $a and $b are set.
$a | $b	Or	Bits that are set in either $a or $b are set.
$a ^ $b	Xor	Bits that are set in $a or $b but not both are set.
~ $a	Not	Bits that are set in $a are not set, and vice versa.
$a << $b	Shift left	Shift the bits of $a $b steps to the left (each step means “multiply by two”)
$a >> $b	Shift right	Shift the bits of $a $b steps to the right (each step means “divide by two”)