Reddit Tabbed Links
Put simply, I was just tired of shift+clicking the links on Reddit, so I made a Greasemonkey script that does it for all the main links and comment links:
Here's the direct link to the script:
Enjoy.
MemcacheD + PHP + MySQL = Dream Team
When using development frameworks like CakePHP, Zend or even Smarty, I always took their ability to cache data for granted. After all, I hadn't built all of my applications using frameworks and those that were lacking didn't seem to be hurting too badly. It just seemed like a bonus for using their environments and while I was very aware of the fact that caching reduces stress on the database, I hadn't really built anything that was in dire need of caching as a means of improving overall functionality.
Once I started learning about memcached, I actually started to think about my non-frameworked applications and whether there were any noticeable lags. It wasn't long before I had thought of a few glaringly obvious examples where (mem)caching could be used to significantly improve performance. But before I go into those examples, here is a brief explanation of what memcached does for you (taken directly from memcached.org):
What is Memcached?
Free & open source, high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.
Memcached is an in-memory key-value store for small chunks of arbitrary data (strings, objects) from results of database calls, API calls, or page rendering.
Memcached is simple yet powerful. Its simple design promotes quick deployment, ease of development, and solves many problems facing large data caches. Its API is available for most popular languages.
So first on my list was Blogflare.com, with its MySQL-based statistical cruncher running on regular intervals and its PHP-based image tickers, the load on the database was strained on a very regular basis. I noticed if I just adjusted the simple database calls to push updates to memcached and then check memcached for data before I even touch the database, performance significantly increased on the front-end. Additionally, this same improvement was helpful in terms of serving out ticker images that are normally database-driven. With these two simple changes, load on the database dropped enough to make scaling much less of a pain. This is relevant, too, as the site has grown steadily over the past few months and shows no signs of stopping.
The next item on the list is one I can't actually link you to but an application that I've built for the University's Art School to handle finance planning and reporting for graduate students. After a few moments of thinking about its structure I realized the database is very read-heavy, particularly in the reporting area. Reports are generated from stored procedures and perform some pretty heavy calculations on each student's data in order to provide administrators with a very accurate picture of spending and planned spending. Updating the database calls for insert/update/delete methods to perform calls to memcached first proved to be ENORMOUSLY effective at speeding up use of the database. While this helps to reduce load on the server, the most important factor in this case was how much better the overall user experience was. Lagginess became intermittent rather than constant.
When I was researching memcached and wondering about how such a thing would scale, I found a clipping from this article entitled How to Dramatically Speed Up Your Web Application: An Introduction to memcached very helpful-
No doubt if you took Computer Science in school you were cautioned of the temptation to abuse caches because there is a law of diminishing returns in regards to the size of your cache: the larger your cache gets the more costly it is retrieve and store information within it. Memcache however is not heavily constrained in this way, because the cache at large is made up of lots of little caches. This allows memcached to be much more responsive even when the cache itself begins to reach sizes that might be really inefficient in other circumstances.
So this little bit managed to assuage my fears and give me the confidence to jump right in and start testing it with my lesser-applications. The results, even this early, have been astounding and I can now see how they are a very vital part of modern web application development.
Use jQuery to Tally Forms
Recently, I had the task of creating a simple form to be submitted to a specific department member here on campus. I felt this was a great opportunity to utilize jQuery and to see just how simple I could make adding new fields, since I wanted the form to be somewhat dynamic (adding/removing of inputs and such).
After trying a few methods here and there, I was able to utilize a few jQuery functions and a nice plugin (jquery-formatcurrency) to make everything work as desired.
Here is what I came up with:
$(document).ready(function(){ var total = 0; $('.currency').blur(function() { total = 0; $('.add').each(function(i,obj){ total += $(obj).val()*1; }); $('.subtract').each(function(i,obj){ total -= $(obj).val()*1; }); $('#total').val(total); $('.currency').formatCurrency({symbol:''}); }); });
What's neat about this method is that it handles everything on the blur (loss of focus) of any element with the 'currency' class applied. That means it won't do anything to the field while a person is typing in it -- annoying for some people -- it waits until the user moves on to the next field or away from the field altogether.
The really cool part of what happens first is the mathematical operation. Notice the similarity between the following methods:
$('.add').each(function(i,obj){ total += $(obj).val()*1; }); $('.subtract').each(function(i,obj){ total -= $(obj).val()*1; });
The first method looks at all elements with the 'add' class applied. The .each jQuery function cycles through each matched element and feeds two variables to the attached function: an incremented index and the object reference itself. This makes a tally extremely simple as jQuery will automagically cycle through all the elements you want to either add or subtract based on what class you have applied. The same applies to both classes and, of course, can be extended if you want to do more complex mathematics or formatting to your fields.
After these methods run, the total variable now holds the correct sum for all fields properly classed either 'add' or 'subtract.' This can now be applied to the input field with an id of 'total':
$('#total').val(total);
This will set the 'total' input field's value to the sum of the fields.
Lastly, it will format all fields to currency using the formatCurrency function:
$('.currency').formatCurrency({symbol:''});
Notice I specify here that I do not want any currency symbol (e.g. '$') as I specify that outside the field itself to display to the user.
Again, all of this happens every time a field gets updated and loses focus. So yes, it's magic.
I am a Web Ninja
Click to Enlarge
I doubt I'll be applying for a job in Amsterdam anytime soon, but I thought I'd see if I could work my way through this test anyway. It doesn't really involve any sort of real web development prowess, really, but it does require some reasonable know-how with Firebug (one of my most favorite tools ever).
The test took me about five minutes (four of which was spent on number three), the last minute was spent on the other questions. That's pretty decent in my mind, but who knows how well other people did?
I really like this style of interviewing though, and I think more companies should use it to weed out the riffraff. It does require a lot of creativity on the design end but, I'd imagine, reduces man hours (spent interviewing and processing) like crazy. If I ever hire more developers, I plan to come up with a puzzle test like this.
If you're interested in seeing how you'll do, click here to take the web ninja test.
-Scott