$url = 'http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=KSFO';
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_HEADER, 0);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_TIMEOUT, 10);
  $data = curl_exec($ch);
  curl_close($ch);

  $xml = simplexml_load_string($data);

  $weather = $xml->weather;
  $temp = $xml->temp_f;
  $icon = $xml->icons->icon_set[9]->icon_url;

From this, you can set the three parsed variables into your html, and you are all set.

<img src="<?= $icon ?>"/>
<h3 style="margin-bottom:30px;">It's currently <?= $temp ?>&deg; and <?= $weather ?> in California.</h3>

I am finding the call to take about 0.20s, which is acceptable to keep it all in PHP right now. Hope this helps in your quest.

Google’s Nexus S (mfg. by Samsung) will officially come out for Sprint on May 8, and I was lucky to get mine a couple days early- all I can say so far, after coming from an iPhone, is that I love this device. We decided that our shop had to diversify a bit, and because NFC was right up my electrical-engineering-alley, I hopped on the line with Sprint. My predispositions about Android were bad, we always made fun of our friends with Android-based phones because they were buggy and sluggish compared to the iPhone. However, these got broken with the Nexus S; I think the mixture of Google’s oversight, the 1GHz “Hummingbird” processor, and the latest release of Android (2.3) coined “Gingerbread” makes this snappy, and lets the features of Android shine.

*Photographed with the case on, available from Sprint stores.

From iPhone to Nexus S

I don’t think its fair to group the Nexus S into the same category as all Android devices, because it is right on par with the iPhone 4′s touch sensitivity and reactiveness, which I don’t think can be said about any other little green robot devices right now. There is one thing that sums up my thoughts about these two devices after making the switch: All the standards and design rules on the iPhone make it very clean and organized, but also make it stale and less efficient for many tasks.

First of all, on the Nexus S you have 4 hardware “action” buttons instead of one, and I think this feature is really under-rated for how powerful it is. Putting all the inner-workings of Android and iOS aside, here are what these buttons open up:

• With the back button you have the control to “go back” to what you were doing last, which in most cases removes the need for a top or bottom bar in the browser and apps.
• You can click the options button for more choices of what to do next, or application-specific settings.
• The search button provides access to in-app searches (useful in contacts, Gmail, etc.)
• The home button acts essentially the same as the home button on the iPhone.

Not only do these features let you do things quicker on the Nexus S, but it also increases the screen real-estate in a many cases. The screen is already larger than the iPhones (4″ vs. 3.5″), but the first thing I noticed when reading some CNN Mobile was that the story covered my whole screen (no bottom bar), which made it a much cleaner and immersive experience.

I Don’t Launch an App for Weather

Another major feature I was a bit unsure about was this whole modular home screen thing; Windows has a pretty lack-luster integration of “widgets”, and I think thats why I was scared. However, after having this feature, it makes you realize how far behind Apple’s grid system is. Things that are important to me from my mobile: Twitter, Facebook, Weather, Calendar, and all my other apps. With the Android widgets I have the ability to make those my priorities, and instead of having to launch an app to browse tweets, or to see if I have meetings today, it is just a swipe away. You just can’t make certain things a “priority” in a square grid model- if Facebook is all I care about, then it can take up half my screen right when I turn on the phone, which is a powerful time saver.

NFC and Hotspots.. Baby

The entire controversy of “will NFC be big” has been put to rest in my book, NFC will change the mobile environment. I say this because we currently look at QR codes and SMS (text messaging) as a viable and useful way to trade information, and they are horribly time consuming and painful. If you haven’t experienced it yet, wait until you do the same thing by just passing your phone near another NFC device; its like “damn, that was easy”. I mean, imagine if every time you had to use your credit card you couldn’t swipe it, and you had to type in each number- thats the difference of NFC versus the current methods.

The Nexus S has a special “Tags” app which can read NFC tags that can contain text, web links, contact info, and much more. The Tags app also stores the tag information and allows you to bookmark your favorite tags. The last feature of the Tags app is pretty revolutionary, it allows you to turn your phone into an NFC tag, and transmit your choice of information. Say goodbye to apps like Bump, with the Nexus S you can share everything a normal NFC tag can share, and even switch between an “active” tag, and ones you have created in the past. Last neat note, the biggest NFC tag manufacturer, NXP Semiconductors, has an app that allows you to read, write, and lock NFC tags, which makes this a “lab tool” for mobile dev’s like ourselves. Read what we have to say about NFC and mobile marketing.

NFC is by far the coolest wireless feature on the Nexus S, but the other one to make mention of is the WiFi hotspots and tethering. I am actually typing this article from my phones wireless network, and it is using Sprint’s 3G network for all the data transfer (4G where available). I called Sprint and had them turn on the $30/mo feature, which they said I can cancel tomorrow and only pay for the day I used it ($1)- but so far, even at 3G speeds, it rocks. And yes, up to 4 of your friends can use the WiFi network too (Apple is reluctant to allow this). There is always the option to do USB tethering which may save some battery power.

Apps: Better or Worse

I don’t think it is a secret that the iPhone paired with iOS makes the worlds most stable mobile device, but again, you run into the whole grid-based app layout, and top and bottom bar navigation. iPhone apps always “feel” like iPhone apps, however Android app’s seem to take on their own personality, which I have found to be great in most cases. The app’s have been pleasantly stable, nicely designed, and it is refreshing to have the entire screen to work with. This said, the worst thing about Android is the “App Market”- it looks like a third grader’s concept with an even worse implementation. This is where the Apple devices will beat the Nexus S and any Android devices, because they have a larger and more respected app community. However, both platforms have good apps, and both have crappy ones too, and in general all the major players like Facebook, Twitter, etc. have teams devoted to both.

The Final Words

I expect that I will run into some issues with the Nexus S, probably related to Android and particular bugs within third party apps, but as of right now, and as the title says, I love this phone. Here are just a few other side notes that I didn’t detail:

• The iPhone 4′s camera is a little better, but as a photographer, I want to get my photos right in the camera, so setting things like white balance, exposure, and having the option for black and white is great.
• The web browser on the Nexus S still needs some work. The JavaScript handling falls short compared to the iPhone’s, which is becoming a huge component to the mobile web.
• The power management widget is another example of how with one swipe and one tap I can turn off WiFi or Bluetooth, whereas the Apple method is pretty arduous.

I am extremely happy that my Apple iOS shell was broken, it is kind of like seeing a forest through the trees- there are a lot of ways to make things happen on mobile, and Apple doesn’t have all the best ones right now. Will the iPhone 5 have better notifications, include NFC, and let me browse Twitter from my home screen? I hope so, because I love Apple, and want all the mobile companies to make things more usable and intuitive for everyone.

Our fix was to clear all the variables used in the Code Igniter Form Validation Class, which basically sends it back to an empty state. Here is an example:

<?php
  //we POST to this function from our form
  function save() {
    $modules = array(
      'patient_info',
      'patient_history'
    );

    $this->load->library('form_validation');
    $errors = array();
    foreach($modules as $module) {
      $function = 'save_'.$module;
      $errors = $this->$function();
      //reset form validation class
      $this->form_validation->_field_data = array();
  	  $this->form_validation->_config_rules = array();
  	  $this->form_validation->_error_array = array();
  	  $this->form_validation->_error_messages = array();
  	  $this->form_validation->error_string = '';
    }
    //do checks on $error array, return or echo accordingly
  }

  function save_patient_info() {
    $this->form_validation->set_rules('first_name','First Name','required|xss_clean|max_length[300]');
    $this->form_validation->set_rules('email','Email Address','required|xss_clean|max_length[300]|valid_email');
    if ($this->form_validation->run() != FALSE) {
      //do work
      return TRUE;
    } else {
      return validation_errors();
    }
  }

  function save_patient_history() {
    $this->form_validation->set_rules('last_visit_date','Last Visit Date','required');
    $this->form_validation->set_rules('tetanus_shot','Tetanu Shot in past 5 years','required');
    if ($this->form_validation->run() != FALSE) {
      //do work
      return TRUE;
    } else {
      return validation_errors();
    }
  }
?>

Remember that your global $_POST variable will remain set throughout the entirety of the all the function calls, so each function will validate against it, as it should. This saves you from having to making a massive validation function, which may break if a particular module wasn’t included on the form. This was an easy way we found, if you have a better one, we would love to hear about it!

5 Methods, 5 Lines

Let’s start with the core of what we are talking about, and the five lines of code (methods) that spell out GUIDE.

 function get($a,$b=array(),$c=0){$d=$this->db->get_where($a,$b);$e=$d->result_array();if($c)return $e[0];return $e;}

function update($a,$b=array(),$c){$this->db->update($a,$c,$b);return $this->db->affected_rows();}

function insert($a,$b){$this->db->insert($a,$b);return $this->db->insert_id();}

function delete($a,$b=array()){$this->db->delete($a,$b);return $this->db->affected_rows();}

function explicit($a){$b=$this->db->query($a);if(is_object($b))return $b->result_array();return $b;}

You notice we minified those methods, because if we are happy with them time after time, why should they take up pixel real-estate on our screens? Let’s start with the GET method, and examine it un-minified:

function get($table,$where=array(),$single=FALSE) {
  $q = $this->db->get_where($table,$where);
  $result = $q->result_array();
  if($single) {
    return $result[0];
  }
  return $result;
}

The real only explanation is the $single option in the function. Suppose you know you will only be getting one result back, maybe you specify a user ID in the $where array (see examples below). If this option is evaluated as true, the returned data array will be a single dimension. Essentially, if you are going to run the result data through a loop, you want a multidimensional array; if you the result as a simple array, use the single option.

The next three methods, Insert, Update, and Delete, just provide direct access to Code Igniters already-established active record tools, with return values that might be helpful in our application. You can refer to their use on the Code Igniter Active Record Class page.

function insert($table,$data) {
  $this->db->insert($table,$data);
  return $this->db->insert_id();
}

function update($table,$where=array(),$data) {
  $this->db->update($table,$data,$where);
  return $this->db->affected_rows();
}

function delete($table,$where=array()) {
  $this->db->delete($table,$where);
  return $this->db->affected_rows();
}

The final method is named Explicit, and is for explicit queries. The only added logic is detection of an object on the query result. If the result is an object, the function returns a result array, and otherwise, it returns the raw query result (likely a boolean-compatible value).

function explicit($query) {
  $q = $this->db->query($query);
  if(is_object($q)) {
    return $q->result_array();
  } else {
    return $q;
  }
}

Basic Usage

If you are not that familiar with Code Igniter, remember that it uses a fairly strict MVC architecture when it comes to the separation of controllers and models. Because of this you will want to place these methods inside a file in your model’s folder, perhaps “fav_model.php”. From your controller, you would call these methods like this:

//get all users in the users table
$users = $this->fav_model->get('users');

//get the user with an ID=5 from the users table, return a single array
$user = $this->fav_model->get('users',array('id'=>5),TRUE);

//update the users table with new data for user with ID=5
$data = array(
  'middle_name'=>'Henry',
  'birthday'=>'946684800'
);
$affected_rows = $this->fav_model->update('users',array('id'=>5),$data);

//insert new user into the users table
$data = array(
  'first_name'=>'Matt',
  'last_name'=>'Gaidica',
  'password'=>md5('abc123')
  'created'=>time()
);
$id = $this->fav_model->insert('users',$data);

//delete user ID=5 from table users
$affected_rows = $this->fav_model->delete('users',array('id'=>5));

//get all the information about user with ID=5 from users table
$data = $this->fav_model->explicit('SELECT * FROM users WHERE id=5');

Limitations and Bewares

There are some instances where these methods will not work, and where they might be outright dangerous to use. Here is a short list of just some instances that come to mind:

• Your table names might change. If you use the table name as a variable in your model, and then change the table name inside the database, you will have to redo all those calls in your controllers. The alternative is to create a new method in your model for every table you are manipulating, so if it changes, you only rewrite the table name once.
• You want to sort the data, or get really specific. Unless you are using the Explicit method, there is no ordering beyond the default database behavior, and no limits or offsets to the data returned. Well-planned queries are important when dealing with large data sets, or highly-efficient applications.
• You want readable model methods. Creating one-fits-all code is sometimes counter-productive, and while the end result may work, it is hard for other developers (or on-lookers) to understand. A scaleable application is written so it makes sense to you and your team, even a year after writing it.

Thats All Folks

This is an easy breezy way to start out your model, and when things get more complicated, you can expand on the methods used in this GUIDE. Hope you learned something new, any questions or comments are welcome.

The Setup

We wanted to keep this test pretty bare-bones, so we could really nail down the overhead of just the active record processing. We loaded up a fresh copy of Code Igniter version 1.7.3, and created a typical controller-model relationship. Next, we created a simple timer using PHP’s microtime() function, and wrapped our calls in a for-loop, so it would repeat 1000 times. On each loop it logged the time difference of just the query itself, and at the end it exported to a .csv file so we could chart it up.

GET Query Times

Average Times (s)
Explicit Query: 0.000168
Active Record Query: 0.000309

INSERT Query Times

Average Times (s)
Explicit Query: 0.000161
Active Record Query: 0.000259

UPDATE Query Times

Average Times (s)
Explicit Query: 0.000172
Active Record Query: 0.000321

DELETE Query Times

Average Times (s)
Explicit Query: 0.000172
Active Record Query: 0.000321

Conclusions

As you might see, and as you might expect, there is a “significant” overhead using CI’s active record; however, I put that in quotations because the time scale we are looking at is so darn small. When you are building applications that require 10e-5 precision on your database queries, well, you probably aren’t a general-purpose, curious developer.

What it does

In short, the goal is to take a snippet, function, or page of PHP and condense it. It will replace variables, remove comments, and/or remove whitespace. To call this tool an obfuscator is not really right, but it does make code harder to read. It also has some fancy options that allow you to exclude certain variables from being replaced so your classe’s calls don’t get mushed up.

What it doesn’t do

The Tiny PHP tool does not attempt to minify function names, class names, or any references related to those objects. Were not trying to take your entire app and make it stupidly hard to maintain, there are lots of other programs out there to do that.

How we use it

There is really no reason to use this type of tool in production code. If you are just messing around though, it is sometimes nice to take a set of methods or functions, and condense them into four or five lines, if their only purpose is to simply exist and never be edited. Also, if an application has spiraled into a mess of variables that have absolutely no meaning, there becomes no difference between them being long and annoying, or short and sweet.

Give it a try, let us know about any bugs.

Take Me to Tiny PHP

The Solution: This simple script has an input of those three things- data, current page, and items per page. It will return a new data set (array) only containing the data that would belong on the particular page you requested. It also returns how many pages there are in the set, and what page you are currently on (just for convenience). Lets take a look:

<?php
function paginate($data,$page=1,$per_page=5) {
  $min = (($page*$per_page)-$per_page)+1;
  $max = $page*$per_page;
  $count = 1;
  $page_data = array();
  foreach($data as $item) {
    if($count >= $min && $count <= $max) {
      $page_data[] = $item;
    }
    $count++;
  }
  $pages = ceil(count($data)/$per_page);
  return array(
    'page_data'=>$page_data,
    'pages'=>$pages,
    'page'=>$page
  );
}
?>

It is not the hardest problem in the world, but it is interesting to solve! Let’s plug some stuff into it and see what happens. Also, because I found the variables to be a bit arbitrary, I threw it into my PHP minify script so its fun to look at.

<?php
function paginate($a,$b=1,$c=5){$d=(($b*$c)-$c)+1;$e=$b*$c;$f=1;$g=array();foreach($a as $h){if($f>=$d&&$f<=$e){$g[]=$h;}$f++;}$i=ceil(count($a)/$c);return array('page_data'=>$g,'pages'=>$i,'page'=>$b);}

$data = array(1,2,3,4,5,6,7,8,9,10,11,12,13);

//get page 2 data, 4 items per-page
$page_info = paginate($data,2,4);
print_r($page_info);
?>

The result in my browser is:

Array
(
  [page_data] => Array
    (
      [0] => 5
      [1] => 6
      [2] => 7
      [3] => 8
    )
  [pages] => 4
  [page] => 2
)

I hope that was the easiest way to present this, and maybe one of the easiest pagination scripts you can start with for your application. I use this inside of a Code Igniter library, and was pretty frustrated that most of the tutorials and methods are a bit much for the basics. As always, let us know if you have questions, and thanks for stopping in.

In our main directory of our WordPress install (where wp-config.php lives) we will add a file called “api.php”, where we will build an array of recent posts, and then spit them out in JSON format.

<?php
// Include WordPress
define('WP_USE_THEMES', false);
require('wp-load.php');

$args = array();
if(!empty($_GET['limit'])) {
  $args['posts_per_page'] = $_GET['limit'];
}
query_posts($args);
if (have_posts()) {
  $posts = array();
  while (have_posts()) {
    the_post();
    $content = strip_tags($post->post_content);
    $limit = 239;
    $last_space = strpos($content," ",$limit);
    $excerpt = substr($content,0,$last_space);
    $excerpt .= '...';

    $author_id=$post->post_author;
    $author_data = get_userdata($author_id);
    $author_name = ucfirst($author_data->user_nicename);

    $posts[] = array(
	'link'=>get_permalink(),
	'title'=>$post->post_title,
	'author'=>$author_name,
	'excerpt'=>$excerpt,
	'time'=>strtotime($post->post_date)
	);
  }
  echo json_encode($posts);
} else {
  echo json_encode(array('error'=>'no data'));
}

In this small routine we have an optional limit to the amount of posts we display, we build a custom-length excerpt, we get the authors name, and include the blog posts’ link and post date. You can see this in action at our blog’s api.php location. Now you can interface to your blog, only retrieving the minimum amount of information you need, and parse it really easily without a bloated plugin. The next step is grabbing the information from your main website (or footer) using PHP’s cURL.

<?php
$url = 'http://blog.builtbyprime.com/api.php?limit=4';
$ch = curl_init();
curl_setopt($ch,CURLOPT_URL,$url);
curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,5);
$data = curl_exec($ch);
curl_close($ch);
$blog_posts = json_decode($data,TRUE);
?>

The only thing to point out here is that when we decode the JSON string, we set the second [optional] parameter in the function json_decode() so it returns an array, and not an object- just a personal choice in this situation. In our particular footer, we only use the blog post title and author name, so while we have access to some of the other stuff, we just don’t use it right now.

<h4>Blog</h4>
<ul>
  <?php foreach($blog_posts as $blog_post):?>
    <li><a href='<?=$blog_post['link']?>'><?=$blog_post['title']?> <em>by <?=$blog_post['author']?></em></a></li>
  <?php endforeach;?>
</ul>

It doesn’t get too much easier, right? Hope you found something helpful, and hope you enjoyed our three part footer series! If you have any questions, or want to post a better method, please feel free to do so. Happy coding.

First things first, you will need an API key to connect with the Flickr API, which you can get at the Flickr Services API Key area. It will generate an API key and an application secret, but we will only use the API key in this walk-through. Once you have the phpFlickr class downloaded and on your server, getting your most recent public photos is a breeze.

require_once('phpFlickr.php');
$flickr = new phpFlickr('YOUR_API_KEY');
$extras = 'description,url_sq,url_s,date_upload,path_alias';
$photos = $flickr->people_getPublicPhotos('46560602@N06','',$extras,4,1);

It is always nice to review the Flickr API Doc’s for the function you are working with, and look into the phpFlickr class to make sure you are addressing things correctly. In this instance, we are requesting the 4 most recent public photos from our Prime Flickr account- notice we must use our Flickr user id, which if you don’t know it, you can get it at idGettr. In our string of “extras”, we request a couple different image sizes (square and small) because our layout uses one large image, and three small ones. Here is how we loop through them:

<h4>Flickr</h4>
<?php $count=0; foreach($photos['photos']['photo'] as $photo):?>
  <?php if($count==0):?>
    <a target="_blank" href="http://flickr.com/photos/<?=$photo['pathalias']?>/<?=$photo['id']?>/lightbox"><img src='<?=$photo['url_s']?>' /></a>
     <h5><?=$photo['title']?> <em><?=date('F j, Y',$photo['dateupload'])?></em></h5>
     <ul class='flickr'>
   <?php else:?>
      <li><a target="_blank" href="http://flickr.com/photos/<?=$photo['pathalias']?>/<?=$photo['id']?>/lightbox"><img src='<?=$photo['url_sq']?>'/></a></li>
    <?php endif;?>
    <?php $count++; endforeach;?>
</ul>

We are using PHP short-coding inside of the HTML to make things really clean and easy to read. You will also notice we make things a bit more complicated here because our first image gets formatted a bit differently than the last three. We hope this gives you something you didn’t know, or helped you along the way. Please let us know of any questions!

We will start with Twitter, and most of our code can be attributed to bavotasan.com’s Twitter Feed article; it is a nice script that plain-and-simple gets a twitter feed. We modified the code provided though, so instead of it actually creating the HTML elements, we get an array back so we can mess with it ourselves. Here is the code for a Twitter class, in a file we named “twitter.php”.

<?php
class Twitter {
  function get_tweets($username,$num) {
    $url = "http://search.twitter.com/search.json?q=from:".$username ."&rpp=".$num;
    $ch = curl_init();
    curl_setopt($ch,CURLOPT_URL,$url);
    curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
    curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,5);
    $data = curl_exec($ch);
    curl_close($ch);

    $tweets = json_decode($data);
    $tweet_array = array();
    for($x=0;$x<$num;$x++) {
      $str = ereg_replace("[[:alpha:]]+://[^<>[:space:]]+[[:alnum:]/]","<a href=\"\\0\">\\0</a>", $tweets->results[$x]->text);
      $pattern = '/[#|@][^\s]*/';
      preg_match_all($pattern, $str, $matches);	

      foreach($matches[0] as $keyword) {
        $keyword = str_replace(")","",$keyword);
        $link = str_replace("#","%23",$keyword);
        $link = str_replace("@","",$keyword);
        if(strstr($keyword,"@")) {
          $search = "<a href=\"http://twitter.com/$link\">$keyword</a>";
        } else {
          $link = urlencode($link);
          $search = "<a href=\"http://twitter.com/#search?q=$link\" class=\"grey\">$keyword</a>";
        }
        $str = str_replace($keyword, $search, $str);
      }
      //var_dump($tweets->results[$x]);
      $tweet_array[] = array('text'=>$str,'created'=>strtotime($tweets->results[$x]->created_at));
    }
    return $tweet_array;
  }
}

You will notice we do not close the PHP tag at the end, this is best-practice in a PHP-only file, mostly to eliminate any type of whitespace issues/errors. Now, we can retrieve tweets (in your footer if you want) from Twitter like this:

<?php
require_once('twitter.php');
$twitter = new Twitter;
$tweets = $twitter->get_tweets('primestudios',3);
?>

Remember, our Twitter class is replacing all links inside the tweet with an actual HTML anchor, so most of the heavy-lifting is done. Lastly, we just need to loop through the tweets to display them, having access to two array elements- “text” of the tweet, and the “created” date in UNIX. Here is the actual code we use in our footer.

<h4>Twitter</h4>
<ul>
  <?php foreach($tweets as $tweet):?>
    <li><p><?=$tweet['text']?> <em><?=date('M j',$tweet['created'])?></em></p></li>
  <?php endforeach;?>
</ul>

Of course the CSS will be up to you, and notice that we use the common UNIX date format, so we convert it to something human-readable of our choice with PHP’s date() function. Maybe this can save you an hour or so of work, because thats what sharing is all about! If you need help, please let us know.