John Crepezzi and I launched GetSparks.org (the CodeIgniter package manager and repository) a little under a year ago, and the response we received from the community was overwhelmingly positive.

The best part of GetSparks isn’t the site itself. It’s a moderately simple app that provides a vehicle for quickly dropping other developers’ code in your codebase.

Many of the packages on GetSparks are very well maintained. I am continually impressed by the amount of effort spark developers pour into their submissions when I peruse the site and try new packages out. One example would be WanWizard‘s DataMapper-ORM: Look at how well thought out it is, and how detailed the docs are.

Another would be codeigniter-payments. I rolled in to the second day of CICon 2011 NYC to find @calvinfroedge talking about a new payment spark he had made — one of the most in-depth, flexible payment libs I’ve ever seen.

GetSparks has almost clocked 50,000 package downloads at this point, but there are handful of sparks that have really stood out in terms of popularity. They are the year’s top 10:

And of course, there are people whose contributions have made GetSparks.org the success it is. A special thanks goes out to:

• Beau Frusetta — First team member (retired), and the guy who made GetSparks look halfway decent
• Mike Pauley — Team member
• Sean Downey — Team member
• Joe Auty — Team member
• Jake Ingman — Who made us a sweet logo
• Joel Cox — For some fine features and great sparks
• Balsamiq — Who donated a copy of their mockup software
• Spicer Matthews of CloudManic, who contributed the “forking” feature (which I have big plans for)

Happy New Year everyone. Keep up the awesome work, and keep knocking out those timeshanks when developing a new app with new sparks (things like payments, emailing, auth, assets, etc).

If you’ve ever had the need to investigate production issues in a load-balanced setup, you’d know why having a tool to pull down all of your remote log files into a single filtered stream can be handy. I think splunk is great at this, but in many cases, overkill.

I wrote chip to accommodate this demanding use case:

I have n production servers. From my local machine, I want to view the web application logs across those servers on a single terminal, while highlighting error lines in red. Additionally, I want those errors emailed to me.

That’s what chip does. It’s a powerful log file monitor (like swatch) and multiplexer. That is, it combines local or remote logs into one stream that you can see. Watch the screencast:

A full description of what chip can do is at the github project page, but the gist is:

chip starts up and tries to open log file(s), either local or remote. If one isn’t specified, it reads from standard input. It goes through each line looking for patterns that you have specified as arguments. When it finds a match, chip does whatever you told it to do with that match.

I use chip daily to watch production logs. When I’m investigating issues, I set up an additional pattern and handler to send certain log lines to my inbox. Just think: An instant monitor set up to watch all of your production logs while you do more important things. Useful for just tailing logs, splitting them, colorizing them, monitoring them, or any combination of the above. You can also use it as a more flexible alternative to `tee` when piping in input.

Anyway, now I can get back to working on the GetSparks.org project

chip is still technically a beta, but has been stable throughout my use of it. Check out chip at https://github.com/katzgrau/chip.

On Twitter, I’m @_kennyk_.

If you aren’t already familiar, a package manager and repository for CodeIgniter libraries was released last week at GetSparks.org. In the few days between then and now, some very interesting and useful packages have been submitted. There’s one for combining, minifying and caching assets, one for database scaffolding, viewing logs, geocoding, template-ing, etc.

Here’s a short screencast that shows how GetSparks.org has already started using some of these sparks in its own development.

If you’re interested in the project, follow it at twitter.com/getsparks. If you’re a developer and you’re interested in following or helping out with development, head to the github repository over at http://github.com/katzgrau/getsparks.org.

As always, if you’d like to join the project, find me at: katzgrau@gmail.com.

If you’re familiar with package management, you’re aware of how awesome it can be. Yum, Apt, MacPorts, homebrew are examples of package managers on the Operating System level. Need to install some common software package like mysql? On OSX, it isn’t any harder than:

$ brew install mysql

For software development, you have Python’s eggs and Rails’ gems, which each work a bit differently, but generally achieve a solution to a big problem: Using, installing, and contributing other developers’ libraries should be easy.

So if you’re a CodeIgniter developer, picture this common scenario: You need a library to interact with Amazon’s new Simple Email Service, but you know someone out there must have already written one. You end up on some guy’s blog, and it looks like he has a working library. You copy/paste, download, whatever.

Maybe the lib was written to work with CodeIgniter, or maybe it’s just a general PHP lib. Maybe it works, maybe it doesn’t. Maybe it has solid documentation, maybe it doesn’t. If it’s not to your liking, back to Google you go, and search for something else. This is all time-consuming.

As of today, this problem is solved for CodeIgniter. It’s called CodeIgniter Sparks, and you can read all about it at http://getsparks.org.

CodeIgniter “Sparks” is still in an alpha state at the time of this writing, but it’s planned to be a full package manager for CodeIgniter applications. You can install it by using a one-liner.

Thanks to some early contributions, you can now get some Amazon SES functionality by:

$ php tools/spark install amazon-ses

And boom-shakalaka! It’s installed in your application. A special thanks to Joël Cox for that one.

Phil Sturgeon and Dan Horrigan each came through with their respective ‘template‘ and ‘tag‘ packages.

It’s still very early in the project’s lifetime, but I don’t think its too early to say that this could be very beneficial to the frameworks as a whole. As I put in the “GetSparks.org Manifesto”:

1. There are plenty of feature requests for CodeIgniter, especially when it comes to libraries. 99% of the suggested libraries don’t belong built-in to the framework. We hope that Sparks helps keep CodeIgniter one of the lightest, fastest frameworks for PHP.
2. Some fantastic and useful libraries have been written for CodeIgniter, but they remain scattered around the internet on blogs, wikis, forums, and github. Using these in your projects is a chore of copy and paste.
3. When you’re thinking of using someone else’s code, there isn’t much of a way to gauge whether it’s ready for the big-time. Is it fault tolerant? Unit tested? Relatively recent?
4. Most importantly: CodeIgniter developers don’t have an easy way to share their code and contribute extensions to CodeIgniter functionality.

It all comes down to making code easier to use and share among CodeIgniter developers.

If you’re interested in helping out on the project, reach out to team@getsparks.org. Right now, the team consists of me, John, Beau, and Mike. If you just want to follow along, check out http://github.com/katzgrau/getsparks.org. I’ve already received a ton of feedback, and it’s all appreciated.

PS: John and I put together a podcast explaining why we thought all this was needed by CI a couple weeks ago. Check it out!

Over the weekend I put a full day into creating and completing a WordPress plugin that probably doesn’t appeal to anybody except for developers: A tool to list your github and bitbucket projects right inside a post or on your side bar.

You can see it in action on my projects page.

Basically, I was tired of updating my long-obsolete project list. These days, everything I do is kept on a publicly-hosted repository anyway, so why not pull my project info from those places so it updates automatically?

The plugin is simple to use. Just insert something like:

{{github:katzgrau}}

In your post or page where you want the list. Here’s a real-life example of the output:

• KLogger — 87 following

  A Simple Logging Class For PHP

• ajax-proxy — 5 following

  An easy-to-use PHP ajax proxy class and script for facilitating cross-domain ajax calls which supports cookies and has minimal dependencies (doesn't need curl)

• WP-Easy-Cache — 1 following

  A PHP class for easily caching data programmatically in WordPress. Oriented for develeopers pulling Twitter feeds, etc. A nice alternative to the weak built-in cache functions.

• ci-robot-helper — 5 following

  A spark that can be used to generate questions and answers to avoid robot form submissions

• wordpress-github — 21 following

  List your github and bitbucket projects on your WordPress blog really, really easily. Why? Because you're a baller.

• getsparks.org — 74 following

  getsparks.org - The CodeIgniter Package Managment Repository

• spark-sdk — 5 following

  A CodeIgniter Spark to assist in developing and validating new sparks.

• chip — 57 following

  A log file multiplexer and monitor. Tail multiple remote or local log files, set actions, and more. A friend to every developer and system admin. Alpha.

• boomcalc — 1 following

  A jQuery plugin that renders a usable calculator in a DOM element.

• notes — 1 following

  An open-source multi-user website building application

• access — 6 following

  A CodeIgniter Spark for easily protecting all or part of your site with HTTP Auth prompts

• codeigniter-amazon-ses — 2 following

  A CodeIgniter library to interact with Amazon Web Services (AWS) Simple Email Service (SES)

I use BitBucket for CodeIgniter-related projects, and GitHub for pretty much everything else. So on my project page, I actually do:

{{github:katzgrau,bitbucket:katzgrau,sortby:watchers,sortdir:desc}}

Which pulls projects from both github and bitbucket, combines them, sorts them, and displays a list. A widget which comes with the plugin will do the same thing if you just want to list projects in your sidebar.

Anyway, check it out. You can find it in the WP admin plugin panel by searching for ‘GitHub’. Then just look for the ‘GitHub and BitBucket Project Lister‘. You can find the github repo (where it’s developed) here: https://github.com/katzgrau/wordpress-github

Brief but intense “holy shit” moments have been hitting me quite a bit in the last couple weeks. For the last 5 years, my social networking experience has largely consisted of Facebook, and I took it for granted as an application that was just really good at what it did.

Maybe that’s even what Zuck thought. (Hey Zuckerberg, comment on my blog whydontcha. I’m having convulsions here.)

I have often wished I was twenty-something in 1995, prime for the internet boom. But in 1995, would I have recognized what was taking place? Would I have realized the extensive impact the internet would have on my life and on human history? I don’t know.

But I’m twenty something now, and I think it’s happening again. Something incredibly profound is happening, and it will affect us forever. It won’t just affect your life online. People will inevitably be 100% connected to this vast social grid, because they want to be.

I am guilty of drinking way too much soda + coffee and getting delusional later in the day, but I don’t think I’m blowing this out of proportion. I’m almost dizzy from thinking about it.

Some questions that are cropping up in my mind include:

1. How will Facebook and other social networks become even more real-time?
2. How will desktop-based social browsers like RockMelt fair? Don’t RockMelt’s social extensions essentially do what Facebook’s more portable Apps can already do if they wanted to? If desktop social browsers prevail, why did they?
3. How many investors invest in social apps because they think anything social will make money, and not because they understand the insanity of it all?
4. What is sum of it all? Where is all this stuff leading us? Social networking is surely not the terminus. There’s a crazy future ahead of us.

That’s all for now. Comment if you think I’m all wrong, or you have some answers for those questions. @seejohnrun? @johnbellone?

After almost two years since the last major release of WPSearch, WPSearch 2 will be released this weekend at Wordcamp NYC.

WPSearch 2 has been the highest rated search plug-in in the WordPress repository, with much thanks to the bug reporters, testers, and donations along the way.

WPSearch 2 was built for WordPress 3, and features:

• A COMPLETELY rewritten codebase
• An in-page progress bar for index builds
• Verbose logging for troubleshooting
• A ‘test’ mechanism that tells you exactly what things you still need to do to run WPSearch (like changing file permissions, and other things like that).
• An engine that can handle close to 10,000 posts
• The one and only word-stemming analyzer for Zend Lucene

I’ll be presenting this with John Crepezzi, co-founder of our company, OConf. We’ll be discussing why the WordPress search is lacking by default, the effect it has on the monetization of your site, and the new release of WPSearch.

We’ll also mention a premium version of WPSearch, which can handle up to 500,000 posts, but uses a proprietary back-end driver.

Come check us out! If you have any questions, drop a comment!

I really can’t stand hard-coding URLs in the views or controllers of my application — and I’m sure most other people can’t either. Here’s an extension for the CodeIgniter Router class that I wrote that gives you a nice way to write routes that are reversible and also have the ability to take parameters.

<?php
 
class MY_Router extends CI_Router
{
    private $_reverseRoutes = NULL;
 
    CONST ARR_ROUTE_POS      = 0;
    CONST ARR_ROUTE_NAME_POS = 1;
 
    function _parse_routes()
    {
		// Do we even have any custom routing to deal with?
		// There is a default scaffolding trigger, so we'll look just for 1
		if (count($this->routes) == 1)
		{
			$this->_set_request($this->uri->segments);
			return;
		}
 
		// Turn the segment array into a URI string
		$uri = implode('/', $this->uri->segments);
 
		// Is there a literal match?  If so we're done
		if (isset($this->routes[$uri]))
		{
			$this->_set_request(explode('/', $this->routes[$uri][self::ARR_ROUTE_POS]));
			return;
		}
 
		// Loop through the route array looking for wild-cards
		foreach ($this->routes as $key => $val)
		{
			// Convert wild-cards to RegEx
            //echo "$key --> ";
			$key = preg_replace('/\:\w+/', '[\w\-_]+', $key);
            //echo "$key <br />";
			// Does the RegEx match?
			if (preg_match('#^'.$key.'$#', $uri))
			{
				// Do we have a back-reference?
				if (strpos($val[self::ARR_ROUTE_POS], '$') !== FALSE AND strpos($key, '(') !== FALSE)
				{
					$val = preg_replace('#^'.$key.'$#', $val[self::ARR_ROUTE_POS], $uri);   
				}
 
				$this->_set_request(explode('/', $val));
				return;
			}
		}
 
		// If we got this far it means we didn't encounter a
		// matching route so we'll set the site default route
		$this->_set_request($this->uri->segments);
    }
 
    function _buildReverseRoutes()
    {
        $reverse_routes = array();
 
        foreach($this->routes as $route => $info)
        {
            # If this is a default route or scaffolding key, ignore it
            if(!is_array($info)) continue;
 
            $name = $info[self::ARR_ROUTE_NAME_POS];
            $reverse_routes[$name] = $route;
        }
 
        $this->_reverseRoutes = & $reverse_routes;
    }
 
    function reverseRoute($route_name, $args_keyval = array())
    {
        if($this->_reverseRoutes === NULL)
            $this->_buildReverseRoutes();
 
        if(!array_key_exists($route_name, $this->_reverseRoutes))
            show_error("No reverse route found for '$route_name'");
 
        $route = $this->_reverseRoutes[$route_name];
 
        foreach($args_keyval as $key => $val)
        {
            $route = str_replace("(:$key)", $val, $route);
        }
 
        return $route;
    }
}

Drop that into application/libraries, then rewrite your routes to look like this:

$route['users/(:username)']  = array('users/$1', 'user-homepage');
$route['companies/(:slug)']  = array('companies/$1', 'company-homepage');

Let me explain that.

CodeIgniter lets you use wildcards in your routes like (:any) or (:num). That’s no more with this extension. Basically, anything you put in (:[name]) format with be treated like (:any). That’s handy, and I’ll tell you why.

Once you rewrite you routes, you can now call a new method on the routing class when you need to, say, redirect the user to his homepage after login:

  # login was successful, and we now have a $user object
  $this->load->helper('url');
  redirect($this->router->reverseRoute('user-homepage', array('username' => $user->username));

The reverseRoute method takes two parameters: The route you want to send the use on, and any wildcards that you need to fill in the url. For the user-homepage route, there is a (:username) wildcard in the route. We can pass the appropriate fill-in for that wilcard with the second parameter with an associative key-value array.

A redirect to a company-homepage would look like:

  # ...
  redirect($this->router->reverseRoute('company-homepage', array('slug' => $company->slug));

Then in the future, if you feel like changing your routes, go no further than the routes file! Mucking around in views is a recipe for broken links.

A common annoyance in the world of AJAX is the ol’ cross-domain request error. That is, a script sitting on domain1.example.com can’t make AJAX calls to domain2.example.com. This is in place for the sake of security, but sometimes developers have legitimate reasons to do so.

A common workaround is writing a server-side script that will sit on domain1.example.com, and make proxy requests to domain2.example.com, and send the output back to the client. Many times, this is a “quick and dirty” solution to a common problem. You can find many of these short ‘n ugly procedural proxy scripts online.

But what if our needs are more complicated? What if our AJAX calls needed to be made over an authenticated session which requires forwarding of cookies? This is much harder to find online, and is a bit more complicated.

Lastly, just try and find an AJAX proxy that doesn’t rely entirely on cURL as it’s request mechanism. Developers using shared hosting or servers with draconian admins might not of the luxury of access to third-party fluff like cURL.

Over the past few weeks, I’ve developed ajax-proxy over at HUGE in Brooklyn, which is a class and script that solves both of the problems above. Additionally, it’s functionality is entirely encapsulated inside of a re-usable class. It was made so that it could stand alone on a server as proxy.php, or be incorporated into a larger framework like Zend, Kohana, or CodeIgniter.

Here are it’s features:

• Uses cURL, but falls back to the less-speedy fopen if the former sin’t available
• Forwards cookies and other headers in both directions
• Has optional error and exception handling for behavior as a standalone script (frameworks would likely not want this)
• Extremely well documented (I’m a documentation fanatic)
• Written entirely in OO PHP 5, to the Zend standards

Additionally, the proxy underwent 2 weeks of development and intensive code review by the HUGE development team before it’s v1.0 push to GitHub. This is by no means a “quick and dirty” solution — it’s a rock-solid, full featured ajax-proxy that’s dead easy to use. Assuming proxy requests were going to be made to a base url of domain2.example.com, the code to run the proxy looks like:

$proxy = new AjaxProxy('domain2.example.com');
$proxy->execute();

If there’s anyone that loves simplicity, it’s me. Of course, there are more constructor options, but that’s better left to the README.

Anyway, the project is posted on GitHub at: http://github.com/hugeinc/ajax-proxy, where there is also pretty extensive documentation on the class’ usage. For documentation about the internal class members and methods, everything is doc’d with PHPDoc.

As a side note, I think it’s about time that I add KLogger to github. I get a fair amount of emails from people telling me they’re using it, and it’s about time I incorporated some new features in, like rolling log files, etc. I’m tired of having dusty old zip files sitting around. I’ll make another post when I put it up there!

I tend to get so wrapped up in the server-side portion of web applications, I probably don’t keep tabs on front-end tips and tricks as well I should. Luckily I work with some of the best client-side developers I’ve ever met over at HUGE, and I generally get exposed to new front-end marvels whether I like it or not.

HUGE is firm that specializes in building sustainable web applications — they’re known for their design team, user experience, and revenue generating ability. Their talent is behind the Reuters iPad App, CNN, iVillage, and a host of other clients.

But HUGE also keeps a team of the best developers you’ll find in NY. And lately, they’ve begun to contribute to the open source world via their GitHub account. Their first release has been something particularly exciting for front-end developers: A cross-browser library for leveraging the local storage capabilities of HTML 5.

Local storage is essentially a mechanism that allows client-side applications to store data — “a mostly arbitrary limit of 5 megabytes” — locally. This works much like a cookie, without the absurd storage restriction of 4 kilobytes.

The library was developed by HUGE developer Sankho Mallik, and he wrote a bit more detail about the library over at his blog. His library, in addition to facilitating cross-browser local storage, also facilitates the use of session storage across browsers (even IE 6, incredibly). That’s something you can’t find in other plugins on the ‘net.

The project page is at GitHub, but I’d recommend reading up at Sankho’s blog too.