Ahh, the case.  The Antec Fusion Remote.  A lovely case, it seems.  The construction feels fantastic, nice and sturdy, and the front looks wonderful.  But, man!  The thing is a beast!  I swear that it’s almost as big as my desktop PC.  The unit we have to put the HTPC on is just about big deep enough – so long as we don’t want any cables at all attached to the back!  It’s either that (and what’s the point of having the HTPC if we can’t hook it up to anything?) or have the case hover over the edge of the unit, which’d look sloppy.  No, the case, albeit probably very nice, is going back.  But what to do?  Every case I look at and like is about the same depth.  All the really slim cases would also require me sending back my PSU, probably the wifi card as well, and possibly wouldn’t accommodate the graphics card.  Thankfully I came across the Silverstone GD02 which will allow for a standard ATX PSU, a graphics card up to 11.5″ in length and still looks quite nice to boot.  Best of all, it’s about 8cm shorter in depth than the Fusion Remote!  I’m hoping that I didn’t need to go for the GD05 which is a further 4cm shorter than even the GD02, because I like the ability to have an external 3.5″ device on the case (for adding a memory card reader or similar further on down the line).

Now, the GD02 case doesn’t have a few things that the Fusion does.  It doesn’t have a display on the front.  To be honest, I’m coming around to the idea of that actually being a really good thing.  Do I really want to have a really bright (from what I’ve read) display on the front of the case while watching a movie?  No, I think that’d be distracting.  It also doesn’t have a remote.  Well, the diNovo keyboard with integrated touchpad should do the trick there.  And it doesn’t have a volume control on the front of the case.  OK, that’s only an added bonus and nothing I’d miss anyway.

So the new case was ordered yesterday from Scan (along with a 1.5TB hard drive), and bless ‘em, it’s already been dispatched and I should have it today!  Whoever I ordered the CPU from needs to get in gear because I want to get buildin’!

This is what we went and ordered this past weekend:

• Antex Fusion Remote case
  probably a little bigger than I wanted, but lots of people seemed to like it
• AMD Phenom II X4 955 CPU
  may as well have something that can encode reasonably well!
• Asus Micro-ATX M4a785 HTPC mobo
• LG Blu-ray reader/DVD multi-format burner
• 2GB Crucial RAM
• ATI HD 5450 graphics card
  even though mobo has the 4200 line built-in, I think it’ll be better to use a dedicated card
• Logitech diNovo Mini keyboard

Got a few other things as well, such as a wifi card, bluetooth dongle, etc.  The only thing I don’t currently have is a hard drive.  I’m thinking of a small, fast drive for the program partition and a couple large drives in RAID 1…  Actually, is that possible?  Can I have one drive in the computer not in raid and two others in raid?  Or is it a case of they all need to be in some format of raid or not at all?  Guess I’ll soon find out!

Very excited about all of this… Some parts have already been allocated and invoiced, so hopefully have everything within the next 10 or so days.

If you’ve never seen a QrCode before, it looks something like this:

Now how cool would it be to be able to generate that automatically for each page on your site and allow people to be able bookmark that site on their phone? Well, I think it’d be pretty cool! So I came up with a very simple ZF view helper to do it for me.

This is the view helper code:

<?php

/**
 * Output a QR code block.
 *
 * Currently, only via Google Chart API is supported, but it has
 * room to add other sources of qrcode generation.
 *
 * @category   Amnuts
 * @package    Amnuts_View
 * @subpackage Amnuts_View_Helper
 */
class Amnuts_View_Helper_QrCode extends Zend_View_Helper_Abstract
{
    protected $template = '
        <div class="qrcode">
            <p>Bookmark this page on your mobile</p>
            <img src="%s" alt="QR Code image" />
            <p class="hint"><a href="http://en.wikipedia.org/wiki/QR_Code">What is this?</a></p>
        </div>
        ';

    /**
     * Constructor.
     *
     * @return Amnuts_View_Helper_QrCode
     */
    public function qrCode($template = null)
    {
        if (null !== $template) {
            $this->template = $template;
        }
        return $this;
    }

    /**
     * Generate the QR code image via Google's Chart API.
     *
     * @param  array  $params
     * @return string
     */
    public function google($params = array())
    {
        $default = array(
            'text'       => $_SERVER['SCRIPT_URI'],
            'size'       => '100x100',
            'correction' => 'M',
            'margin'     => 0
        );
        $params = array_merge($default, $params);

        $params['text']   = urlencode($params['text']);
        $params['margin'] = (int)$params['margin'];
        if (!in_array($params['correction'], array('L', 'M', 'Q', 'H'))) {
            $params['correction'] = 'M';
        }
        if (!preg_match('/^\d+x\d+$/', $params['size'])) {
            $params['size'] = '100x100';
        }

        $url = "http://chart.apis.google.com/chart?cht=qr&chl={$params['text']}"
             . "&chld={$params['correction']}|{$params['margin']}"
             . "&chs={$params['size']}";
        return sprintf($this->template, $url);
    }
}

As it’s a view helper, it’s very simple to use within your view. Just do something like:

<?php echo $this->qrCode()->google(); ?>

If you want to change the default template for one instance, you can do that such as:

<?php echo $this->qrCode('<li><img src="%s" /></li>')->google(); ?>

And, of course, you can change the parameters that the QrCode uses, too. By default, if you don’t supply the ‘text’ parameter then it will use the script uri. But you could change that with something like:

<?php echo $this->qrCode()->google(array('text' => 'Visit my site at: http://blog.amnuts.com/')); ?>

There are other options as view helper code shows. But this should get you started on easily using QrCodes on your own site.

01022010

Cool.

I have to say that to documentation seems quite lacking on the ZF site (for all the the Feed components, really, not just the Writer). Because of that, what follows may be idiotic and there really is an easy way. If so, I hope that you will post up a comment and let me know because I’d love to learn!

On with what I did…

My set up is actually to take an email sent to a particular address and add the contents to an RSS feed as-and-when the email arrives. So when the first email comes in the RSS feed file needs to be created. Using the Zend_Feed_Writer_Feed component, this is a really easy job. Once saved the XML looks well structured and everything is as expected. But then what happens when the next email comes in? Obviously I wouldn’t want to create a new feed file because it’d remove any previous entries. Also, I want to tweak the pubDate so that it reflects when this new email came in. I also wanted to use the Zend_Feed_Writer_Entry component so that the structure of the new item matches the previous ones.

The first thing to do was to load the RSS file and tweak the pubDate.

$now = new DateTime();
$now->setTimestamp(time());
$feed = new Zend_Feed_Rss(null, file_get_contents($feedFile));
$feed->pubDate = $now->format(DATE_RSS);

Then I created the entry:

$entry = new Zend_Feed_Writer_Entry();
$entry->setId($entryId);
$entry->setTitle($emailSubject);
$entry->addAuthor(array(
    'name'  => $emailFromName,
    'email' => $emailFormAddress
));
$entry->setDateCreated($emailDate->getTimestamp());
$entry->setContent($emailBody);

At this point it would be really nice to have some kind of Zend_Feed_Rss::addEntry(Zend_Feed_Writer_Entry|string of entry xml), or ::appendEntry()/::prependEntry(), but I was not able to see anything of the sort. So what I did was to create a DOMDocument with the feed file contents, render the entry and append it to the channel node.

$rss = new DOMDocument();
$rss->loadXML($feed->saveXML());
$rss->formatOutput = true;
$rss->substituteEntities = false;

$renderer = new Zend_Feed_Writer_Renderer_Entry_Rss($entry);
$renderer->setRootElement($rss->documentElement);
$renderer->render();
$element = $renderer->getElement();

$channel  = $rss->getElementsByTagName('channel')->item(0);
$imported = $rss->importNode($element, true);
$channel->appendChild($imported);

file_put_contents($feedFile, $rss->saveXML());

Now, that’s not a lot of code, but does it seem even remotely logical to do that when there’s already a fairly inclusive API for the feeds – perhaps just not inclusive enough?

Like I mentioned at the start, though; if you know a better way then please let me know – I’m always happy to learn!

http://www.zend.com/webinar/Framework/webinar-leveraging-zend_form-decorators-20091216.flv

It’s a great introduction to decorators, how to implement them and how to do slightly more complex things with them. Well worth a watch!

For those too lazy to read that post, it can be summarised something like this:

Have a number of divs on your page that have different size blocks of text in them? Want to make all the divs have the same height, but can’t accurately determine what that height should be in advance? No problem! Use javascript to tweak the heights when the page has loaded and the browser knows the size of the divs. Use this plugin to do it automatically based on a class you supply the elements you want to change the size of. Better yet, make them all match either the smallest height or the largest height!

Simple, yes?

Well, that was with Prototype… But a while ago now I created a version for jQuery. So here it is.

/**
 * Same Height, jQuery plug-in.
 *
 * This plug-in allows you to automatically have all of the elements marked
 * with a particular class to be the same height, either by smallest or
 * largest.
 *
 * By default, 'samemaxheight' and 'sameminheight' will be used.
 *
 * Examples of use:
 *
 *     $(document).ready(function() {
 *         $('body').sameheight();
 *     });
 *
 *     $(document).ready(function() {
 *         $('#mainContent').sameheight({
 *             max: 'mymaxclass',
 *             min: 'myminclass'
 *         });
 *     });
 *
 *     $.fn.sameheight.defaults.max = 'mymaxclass';
 *     $.fn.sameheight.defaults.min = 'myminclass';
 *     $('body').sameheight();
 *
 * @copyright Copyright (c) 2009 Andrew Collington 
 */
(function($) {
    $.fn.sameheight = function(userOptions) {
        var options = $.extend({}, $.fn.sameheight.defaults, userOptions);

        var maxH = 0;
        $('.' + options.max, $(this)).each(function(){
            var h = $(this).height();
            maxH = (h > maxH) ? h : maxH;
        });
        $('.' + options.max, $(this)).each(function(){
            $(this).css({
                'height'   : maxH + 'px',
                'overflow' : 'hidden'
            });
        });

        var minH = 0;
        $('.' + options.min, $(this)).each(function(){
            var h = nodes[i].height();
            minH = ((h < minH) || !minH) ? h : minH;
        });
        $('.' + options.min, $(this)).each(function(){
            $(this).css({
                'height'   : minH + 'px',
                'overflow' : 'hidden'
            });
        });
    };

    $.fn.sameheight.defaults = {
        max: 'samemaxheight',
        min: 'sameminheight'
    };
})(jQuery);

]]> http://blog.amnuts.com/2009/12/24/same-height-for-elements-2/feed/ 0 http://blog.amnuts.com/2009/12/21/pointless-error-message/ http://blog.amnuts.com/2009/12/21/pointless-error-message/#comments Mon, 21 Dec 2009 15:11:42 +0000 Andy http://blog.amnuts.com/?p=143 Just ran a bit of SQL on Oracle and this was the oh-so helpful error message I got back:

Warning: ociexecute() [function.ociexecute]: OCIStmtExecute: ORA-00932: inconsistent datatypes: expected BINARY got BINARY

So you’re expecting a binary value and what you got was a binary value, but that’s inconsistent with the binary value you were expecting to be binary?!

On with the book review…

The book, as the title makes it plainly obvious, is about developing your team in relation to working with PHP.  It’s aimed at, well, pretty much anyone who has an interest in developing or working in a team, be it managers who need to set up and manage teams or developers working within a team who want to improve their work flow and procedures, or anyone in between.  It does this by giving an overview on several subjects, but doesn’t go as far as to tell you that you must do x, y or z.  This is understandable, though, as every team is different and the book acknowledges this.

Chapter 1 discusses the need for teams and the use of established software engineering patterns that can help as well as touching on some tools such as issue tracking, source control, etc.  This chapter is good if you’re not sure with a lot of terminology as the overview covers a few key topics such as continuous integration and regression, and also touches on software development principles.  It doesn’t go in to depth about any one thing, as they’re covered in further chapters.

Chapter 2 covers MVC (Model View Controller) design principles and how you might form you team to deal with different aspects of the MVC pattern.  To be honest, if you’ve dealt with MVC at all in your job then this chapter holds no surprises, as you will know how the pattern works and how you would give responsibilities to different team groups/members.  However, if you’ve not had any experience at all then it offers a nice little introduction to the pattern.  (Remember, though, that this is not about how you would code the MVC pattern or use it in your project – it’s about making the principles of the pattern known to you and how it may fit in to team working.)

Chapter 3 is about dealing with complexity.  That is to say, if you have a complex project or application then this chapter gives you an idea on how to manage that and implement things that will make your job easier.  Essentially, what this chapter comes down to is why it’s a good idea to use a framework.  Again, it’s nothing new if you’ve already used frameworks (generally by then you know all the reasons why it tends to be a good thing for complex projects), but if you’re contemplating using one, or sit in a more managerial role and want to know why your developers are using one, then it’s worth the read.  At the end of the chapter the author also gives links to a number of different frameworks – some of which I hadn’t heard of before – along with their license type and a brief description.  What I especially liked about this chapter is that the author came over quite framework agnostic.  He wasn’t saying that one framework is better than another or which you should use – he supplies a list of frameworks and arms you with knowledge of what to look for in a framework (commercial license, documentation, support, code quality, security, etc.) and sets you on your way.  It is, of course, up to you to choose a framework that best suits your project and then integrate that in to your team workings.  This is a Good Thing!

Chapter 4 is about the process to get from the concept of an application to the end product and the steps in between.  There are a number of flow charts throughout this chapter that help you understand the process, and for someone like me who generally goes from being told someone wants an application,  to getting a brief functional requirements set and then making the thing, I can see that I have room for improvement!

Chapter 5 is about Agile development, and probably the chapter I was looking forward to the most.  Agile development was something I’d heard about, had an ever-so vague idea of what it was, but wasn’t too sure.  this chapter tells you what the principles are behind Agile development, how is works when dealing with the customer and a wide general overview.  The chapter then goes on to cover Extreme Programming (XP) a bit, and how Agile and XP can work in the team, pair programming, sustainable working styles for the developers, stand-up meetings, and so on.  It was good to find out a lot of how I work falls under Agile/XP, even though I didn’t know it at the time!  I learned a lot from this chapter and know a number of things I want to try to implement in to my working practice.

Chapter 6 is about collaboration among the team.  Basically it covers how source control is helpful, bug control and reporting, and ways developers can communicate (mailing lists, for example).  Useful stuff if you don’t know about it already, but pretty much any developer I know already uses source control in one form or another, as well as bug reporting, mailing lists, IRC, and everything else.

Chapter 7, the final chapter, is about continuous integration – what happens when your project needs to change, how does the project evolve, how to ensure team success and more.  Even though this is a distinct chapter in itself, I did get the feeling that it was more like a summary chapter of everything that you had just read.  But this was probably just because the author was referencing a number of his earlier chapters because they relatedto what he was taling about at the time.

Conclusion

This book is only 160 or so pages in size and it tries to cram a lot of information in to it.  There are times I wish the author could have gone in to more detail, but could also very much appreciate that the author didn’t have enough room to do so.  I actually quite liked that it was a really high-level overview for the most part, because it gave me a lot of ideas of things I want to investigate further and can now go and find resources that covers those bits in much more details.

Because I know quite a number of principles this book covered, such as the MVC chapters, source control, etc., I didn’t take quite so much away from it as another person may – and I’m sure other developers would feel the same – but I did still learn a lot from it, such as the agile development, and a number of keys principles that mayhelp me manage my time better as well as have a more integrated team.

However, this book wasn’t all roses and there were a number of things I really didn’t like.  The first thing is the authors style of writing.  I honestly didn’t gel with it very well and actually struggled to get past the first couple of chapters.  There was an overabundance of commas – sometimes breaking up the sentence in odd places – and it because a little repetitive and word for no reason.  My wife accuses me of using commas too much, which I probably do, but the amount in this book just caused me a headache!  The writing style I could get over (as mine’s not the best, but then, I’m not trying to sell you a book!), but the one thing that really pissed me off was that fact that the credits included a proof reader!!  WHAT?!  I lost count of the times ‘form’ was used when it should have been ‘from’, or the spelling mistakes, grammatical errors, or missing words entirely!  A couple of my favourites is when the author was discussing the use of functional programming vs. OOP, and then goes on to say, “Be it fictional programming you are using or object-oriented programming…”  Fictional programming!  And this highlights the commas quite nicely, “…we might be about to deal with estimates that are off the mark for some time, in the long run, both, the development team as well as clients and users will become frustrated…”  I don’t so much blame the author for these mistakes – I can’t imagine the pressure of writing a book and trying to get it spot on – but isn’t that why you employ proof readers and editors??

All in all I’d say that if you’ve been developing for a while and had any team experience then this book wont be of much use to you.  However, if you’ve never worked in a team environment, or don’t have much development experience, are a manager or something like that, then you may find this book quite beneficial to you for an overview of working in and establishing team working principles.