Blog

301 Redirect for Expression Engine 2

admin — Wed, 09 Nov 2011 07:21:46 +0000

A great plugin was written for Expression Engine 1.x by Nick Cernis called Redirect301, but it was lacking support for Expression Engine 2.x- so I coded the plugin starting from Nick’s base to support it, and made a couple small changes along the way.

The most noticeable change is that you no longer include the external term inside the plugin. If your URL does not start with “http://” or “https://” the EE site’s URL is prepended to the given URL so redirects are not relative. This was how I wanted it in my particular site, because the URL is coming from a user input, which may be relative, or to an external site. The other change is that you can leave the URL empty, and the plugin will not do anything; this was for the case that it was an optional field in one of your channels.

 'Redirect 301',
  'pi_version' =>'1.2',
  'pi_author' =>'Nick Cernis, Matt Gaidica',
  'pi_author_url' => 'http://nickcernis.com/',
  'pi_description' => 'EE2 - Redirects to another page or site using the 301 header.',
  'pi_usage' => Redirect301::usage()
  );

class Redirect301
{

 	function Redirect301()
	{
		$this->EE =& get_instance();
	    $url = $this->EE->TMPL->fetch_param('url');
	    $url =  trim(html_entity_decode($url));

	    if(!empty($url))
	    {
	    	$permanent = $this->EE->TMPL->fetch_param('permanent');
	    	$external = FALSE;
		    if(strpos($url, 'http://') === 0 || strpos($url, 'https://') === 0)
		    	$external = TRUE;

	    	// Get the site's base URL
			if (!$external)
			{
				$site_url = '';
				$site = ( ! $this->EE->TMPL->fetch_param('site')) ? '1' :  $this->EE->TMPL->fetch_param('site');
				if (is_numeric($site))
					$this->EE->db->select('site_system_preferences')->from('exp_sites')->where('site_id', $site);
				else
					$this->EE->db->select('site_system_preferences')->from('exp_sites')->where('site_name', $site);

				$query = $this->EE->db->get();

				if ($query->num_rows() > 0)
				{
					$row = $query->row_array();
					$prefs = unserialize(base64_decode($row['site_system_preferences']));
					$site_url = $prefs['site_url'].$prefs['site_index'];
				}
			}

		    switch ($permanent)
		    {
			    case "no":
					if ($external)
						Header( "Location:".$url );
					else
						Header( "Location:".$site_url.$url );
					exit();
				default:
		        	Header( "HTTP/1.1 301 Moved Permanently" );
					if ($external)
						Header( "Location:".$url );
					else
						Header( "Location:".$site_url.$url );
					exit();
		    }
	    }
	}

	// usage instructions
	function usage()
	{
		ob_start();
?>
-------------------
HOW TO USE
-------------------
Redirect to the specified channel and template using the SEO-friendly 301 header:
{exp:redirect301 url="channel/template"}

If your URL does not start with "http://" or "https://" the site's URL is prepended so redirects are not relative.

Redirect without the 301 header:
{exp:redirect301 url="channel/template" permanent="no"}

If you're using the Multiple Site Manager, simply specify the name or ID of your site, like this:
{exp:redirect301 url="channel/template" site="site_short_name_or_id"}

-----------------------------------------
SAMPLE REDIRECT TEMPLATE
-----------------------------------------
The redirect301 plugin can be used to create a short link to long post names. Here's how:

1) Create a template group called "go"
2) Edit the index file to include the following code:

{exp:channel:entries  limit="1" entry_id="{segment_2}" disable="member_data|trackbacks|pagination"}
{exp:redirect301 url="{channel}/{url_title}"}
{/exp:channel:entries}

This will take a URL such as http://yoursite.com/go/33/ and issue a 301 redirect to the full URL,
such as http://yoursite.com/articles/you-look-nice-today/

------------------------------
OPTIONAL ADDITIONS
------------------------------
To create a link within your posts that readers can share, simply append the post ID to the
short URL address, like this:

{exp:channel:entries}
Short link to this page
{/exp:channel:entries}

Optionally, you can add the following code between your  tags to help spiders determine that
the content is the same. This is good practice but isn't required for the redirect to work.

{exp:channel:entries}

{exp:channel:entries}

I left the documentation essentially the same. I use this plugin as an option in conjunction with the Structure add-on in Expression Engine 2. I setup a channel called “Redirect”, and assigned it as a “Page” inside of Structure; I also assigned it to a template I will share below.

There is a custom field called “redirect_url” for this channel, and here is the template it uses to actually make the redirect.

{exp:channel:entries channel="redirect" status="not closed" limit="1" disable="member_data|trackbacks|pagination"}
	{if no_results}
		{redirect="site/index"}
	{/if}

	{exp:redirect301 url="{redirect_url}"}
{/exp:channel:entries}

I invested time into this because I wanted to remain using the Structure add-on as it is, but have the ability to do simple redirecting. This need is pretty common in my experience, and the .htaccess file is not one I want to client accessing. Also, if I can avoid turning on PHP in the template and junking it up with intermixed EE tags, I prefer it that way. Good luck with it.

A Quick Weather API with PHP

Matt — Fri, 26 Aug 2011 16:45:07 +0000

I wanted to add a small weather status to the top of a web application, just to remind me what was going on in that city. This is some really simple code, based off of WunderGround’s API, using a city airport’s conditions. Not going into much detail on this, or offering a completely robust solution, but here is the code I have in place.

  $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.

"/>
It's currently ° and  in California.

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.

Why I love the Nexus S (vs. iPhone 4)

Matt — Sat, 07 May 2011 19:31:44 +0000

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.

High Tech Mobile Marketing – NFC (Near Field Communication)

Josh — Tue, 03 May 2011 15:29:22 +0000

What is NFC?

For those who aren’t familiar with NFC (Near Field Communication), it is a growing wireless technology used for sharing data. NFC uses re-programmable tags that require no batteries or power source, they are simply powered by induction when an NFC-enabled device gets near them. NFC tags are durable, they can be used behind glass or other non-metallic materials, and don’t require any ambient light or use of a camera to detect them.

Several cellular companies have already released phones with NFC capabilities. Google has produced the Google Nexus S, a smartphone manufactured by Samsung. Samsung has also come out with the Star, Aliva, Player One, and Tocco Lite. Nokia in particular has made a commitment to incorporating NFC into all of their smart phones starting in 2011 (Leading Mobile Operators announce their commitment to NFC Technology), and has already released a compatible Nokia C7 model. Even though the technology hasn’t become a popular demand in phones, many companies believe that it will take off if people see its potential. Google has announced that it is abandoning QR codes and investing on NFC technology (Google Kills QR Codes in Favor of NFC).

Day or Night, and Weather Resistant

The idea is that instead of using a QR reader to scan a barcode, it would be quicker and easier if you could simply wave your phone next to a NFC tag to acquire information. This would allow people to get the same information without having to worry about it being too dark to scan a QR code and worrying about the weather, as NFC tags are weather resistant. The NFC-enabled cell phones also use a type of messaging system with the tags so that webpages can be prompted to open right as an NFC tag is in range.

NFC Marketing and Applications

This technology holds potential for some very cool applications in the future. NFC tags could be used for tourists by applying them at “points of interest,” to create a virtual tour guide. Businesses could use a NFC tags to quickly direct someone with a smart phone to their website, or a specific marketing campaign. Imagine using these in a parking garage, you would be able to scan the NFC tag when you arrived, and when you were done it could use a mobile website to help lead you back to your car. The possibilities with NFC are truly endless, and 2011 will be there year we will either see these tags flourish, or left behind for something superior.

We believe the tipping point for NFC will be the support from Apple, and rumors continue to swirl that point to the iPhone 5 as being an NFC-enabled device. To see a list of the current phones that support NFC, visit A definitive list of NFC phones.

Also see:

High Tech Mobile Marketing – Short URL’s

High Tech Mobile Marketing – QR Codes

Written by Joshua Bez, edited by Matt Gaidica
Josh is an intern for Prime from Walled Lake Western High School. Josh has worked on many projects relating to mobile marketing, mobile websites, and has assisted in more advanced color theory and programming topics during his internship.

High Tech Mobile Marketing – QR Codes

Josh — Mon, 02 May 2011 10:43:52 +0000

QR Code, 2D Barcode, Square Thing-a-ma-jig

A QR (Quick Response) code is essentially a barcode used to encode information; commonly used for URL or prize codes. Popular uses for QR codes involve mobile phones that have a QR reader application that use the phone’s camera. They are two dimensional and similar to a standard barcode, yet they can hold more information and can be specially formed to launch a website on a mobile device.

Accepted in Asia, Coming to America

At this point, QR codes are being integrated into many applications around us. However, Asia, and Japan in particular, who are often on the cutting edge of cell phone technology, currently offer many cell phones with a QR scanner pre-installed, whereas phones from the U.S. phones require an app. More over, Japan has already heavily integrated itself with with QR codes to the point that people use it in everyday life (QR Codes – From Japan to the US).

QR Code Uses

Companies are often using QR codes as redemption codes; for example “scan this QR code to get a free song” was something I encountered on a Taco Bell drink. Other than that, QR codes can be a simple way to bring a potential costumer or user to a specific web link. They have been used by companies for treasure hunts, on business business cards, and put on objects for people to access blogs, portfolios, Facebook pages, and even tutorial videos.

Also see:

High Tech Mobile Marketing – NFC (Near Field Communication)

High Tech Mobile Marketing – Short URL’s

Josh — Mon, 02 May 2011 09:23:31 +0000

At some point you may have encountered bit.ly or tinyurl.com link, but weren’t sure as to what it was. Bit.ly and tinyurl.com are just a few of many free URL shortening services. URL shorteners will take a URL of any length and turn it into a short redirected link; perfect for overcoming the 140 character limit on twitter! Let’s check it out.

An Example

For example, we can shorten http://builtbyprime.com with the bit.ly service. I will go to bit.ly, enter in builtbyprime.com, and click “Shorten”. The shortened link, http://bit.ly/hNAMMd, pops up, and thats it! If you try clicking the link, you’ll be redirected to our website.

You can now send that link to anyone and it will work for them too. No matter how big a URL you use on bit.ly, it will always end up as http://bit.ly/_____ with six random digits at the end.

Why to use Short URL’s for Mobile Marketing

This service has proved itself very useful, particularly for phones. Entering in a long URL both time consuming and often results in errors. A URL shortener makes entering in URLs much more easier and convenient. Also, many URL shorteners offer simple analytics, so you can see how many people have visited the link.

Words of Caution

There are however a couple downsides to this type of service. If the URL shortener website you used were to suddenly shut down, all of the links it created would instantly stop working. Because the original URL is completely masked by the URL shortener, it can be easily abused to mask spam websites, virus websites, spyware websites, and many other websites that you didn’t want to get to. It is advisable that you only click shortened links given to you by trustworthy websites or people, and use a reliable service.

Also see:

High Tech Mobile Marketing – NFC (Near Field Communication)

High Tech Mobile Marketing – QR Codes

Clearing CodeIgniter Form Validation Rules

Matt — Tue, 22 Mar 2011 19:05:36 +0000

We recently had a case where we created a huge form that had separate sections that we needed to validate, we call them “modules”. Our goal was to send all the form data to a single save function, and then that function could call each form validation function for the included modules. We ran into a small problem with Code Igniter running multiple form validation functions; more specifically, if the first form validation function gave an error, that error would not be cleared in the second form validation function and so on. This meant that all our validation scripts would “carry over” their errors, which is no good.

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:

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!

A GUIDE to Simple Code Igniter Models

Matt — Thu, 17 Feb 2011 00:09:36 +0000

After a lot database code, you realize that the majority of your methods take on the same structure. For a while now, I have started all of our Code Igniter models with five generic methods to interact with the database, and they usually cover a good amount of any basic application’s needs. I am going to flip the CRUD acronym on end and use my own: GUIDE- standing for Get, Update, Insert, Delete, and Explicit.

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.

Code Igniter Query Times: Explicit vs. Active Record

Matt — Wed, 16 Feb 2011 01:59:36 +0000

When dealing with frameworks, such as Code Igniter, there is always a question of what type of overhead it adds to application. One rainy day not too long ago we ran some really simple tests on the difference between active record queries, and explicit queries in CI, and decided it might be nice to share the results. There is always the question of “is it faster”, and while our results show explicit SQL queries to be faster, database execution time is almost always negligible when compared to PHP run time, or page load speeds.

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.

Tiny PHP: A Fun PHP Minifier

Matt — Wed, 16 Feb 2011 00:43:40 +0000

Tiny PHP is a little tool we put into our labs that performs some “minification” on PHP code. Is it a trivial and completely academic exercise because PHP doesn’t benefit from being smaller like CSS or Javascript? Yes. But it’s still kind of cool.

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