FB and G+, the new OS-wars

Posted by on November 8, 2011 No comments

Back when Linux was a gangly youth, there was a great excitement every time you did an update. Unlike Windows and Mac with their expensive three-year-nothing-then-a-service-pack-with-cool-stuff routines, in Linux, there were so many cool free packages around, and /every one/ of them would have something new almost every week.

So, I spent quite a lot of time compiling and recompiling, everything from wget up to the KDE behemoth. And I’d be reading the weekly release notes as well to see if there was any new trick out that week.

I can’t tell you how excited I was when I first installed a copy of Linux where I didn’t have to configure X11 using a text-mode Xconfigureateur!

Or when I recompiled my kernel the first time, or when I recovered from a bad update straight from the GRUB command-line. Or the first time I ejected a CD from across the room (logged in remotely), or freaking out the wife by playing some music on her laptop from a different room.

In the last few years, Linux development has matured, though, so there’s not the same edge-of-the-seat excitement that there used to be, but I think there’s still hope for the techadrenaline junkies out there, because Facebook and Google+ are the new cool, and there’s a /ton/ of stuff that can be done with that!

My eyes are on how FB and G+ evolve. now that FB has competition, I expect some /really/ cool stuff is going to come out of the woodwork.

first and last saturday of a month

Posted by on October 21, 2011 2 comments

I’m working on an expenses application. In order to do it, I need to display the entire month, with full weeks in each (from Saturday to Friday).

To do this, I need to know what date the Saturday in the first week falls, and the date of the first Saturday in the following month.

Here’s the code (assuming year is a 4-digit year, and month is a 1-12 number):

      // { start date
      var start=new Date(year, month-1, 1);
      var day=start.getDay();
      day=(day+1)%7; 

      start=new Date(start-3600000*24*day);

      // }
      // { end date
      month++;
      if (month==13) {
        month=1;
        year++;
      }
      var end=new Date(year, month-1, 1);
      var day=end.getDay();
      day=7-((day+1)%7);

      end=new Date((+end)+3600000*24*day);

      // }

can’t be bothered explaining it – just trust that it’s right ;-)

separating buttons in jquery-ui dialog

Posted by on October 12, 2011 No comments

By default, the jQuery-UI dialog will place buttons on the right side of the popup:

This causes a problem because if you have “OK” right next to “Delete”, and you click the wrong one, well …

The obvious solution is to move the “Delete” to the opposite side.

To do that, add the following two lines after creating the dialog:

$('.ui-dialog-buttonset').css('float','none');
$('.ui-dialog-buttonset>button:last-child').css('float','right');

Now the buttons are on opposite sides:

installing WebME in Fedora 16

Posted by on October 5, 2011 No comments

I got a new laptop today, and as I’ve still got work to do, I need to get the system up and running so it can install WebME.

Here’s a minimal instruction set for installing WebME on your Fedora computer.

As ‘root’, run this in a console:

yum install httpd mysql-server php php-gd php-mysql php-pear-Log php-xml svn
echo "127.0.0.1 kvwebme" >> /etc/hosts

Then edit /etc/selinux/config, change “enabled” to “disabled” and restart your machine.

Login as your normal user, run this in the console:

mkdir ~/websites && cd ~/websites
svn co https://kv-webme.googlecode.com/svn/trunk/ kv-webme
chmod 755 /home/kae

‘su’ to ‘root’ again. Add this to /etc/httpd/conf/httpd.conf:

NameVirtualHost *:80
<Directory /home/kae/websites>
  AllowOverride All
</Directory>
<VirtualHost *:80>
  ServerName kvwebme
  DocumentRoot /home/kae/websites/kv-webme
</VirtualHost>

And finally, in the console again:

service httpd start
service mysqld start
chkconfig --level 35 mysqld on
chkconfig --level 35 httpd on

That’s it – your system is set up. From that point, just go to http://kvwebme/ and follow the instructions from there!

onchange in ckeditor

Posted by on August 31, 2011 No comments

I needed to track changes to source in a CKeditor instance, as my recent work uses a lot of “on-the-fly” updating.

Using Alfonso’s onChange plugin, it was a simple matter to capture changes when in WYSIWYG mode.

But that doesn’t work in source mode.

Assuming you’re using the jQuery extension for CKeditor (and if not, why not?), you can capture source mode changes by adding this to your CKeditor’s config.js:

$('textarea.cke_source').live('keyup', function() {
  $(this)
    .closest('.cke_wrapper')
    .parent()
    .parent()
    .prev()
    .ckeditorGet()
    .fire('change');
});

jQuery maskImage plugin

Posted by on August 25, 2011 6 comments

I had a need today to write some code which involved masking one image with another, dynamically.

There is no simple way to do this in JavaScript. The nearest I came to finding working code online that does it was edge.js, but that’s not free.

So, I wrote my own.

demo

Download: zip (25k), bz2 (24k)

In the demo, what’s happening is that an image such as this:

is being used as a mask for another image:

to create a masked image:

For Firefox and Chrome and other recent browsers, it works using pure JavaScript (even works on the iPhone).

For Internet Explorer (sigh) you need to do a little bit of server-side setup.

Basically, on the server-side, make sure you have PHP installed, with the iMagick extension, then make the ‘cache’ directory writable by the server.

To use, insert an image into your document:

<img id="image-id" src="an-image.png" alt="" />

And then apply the mask using jQuery:

$('#image-id').maskImage({src:"the-mask.png"});

Simple, innit! That’s a few hours of my own life dedicated to saving a few minutes of yours ;-)

immortality and the multi-verse

Posted by on August 17, 2011 No comments

Hello kiddies – it’s madness time!

Don’t worry – these are just idle thoughts. I’m not going over the hill into the twilight zone.

The science madness

A number of ideas in recent (last 100 years) physics revolve around the idea that there are multiple universes, or that the same universe keeps splitting into separate universes every time a quantum decision must be made.

As far as I know, these ideas are not testable, but a lot of physicists think that a multi-verse is the simplest solution to a lot of questions, and as Occam’s Razor says, the simplest solution is usually the right one.

The idea that’s bandied about most often is that the universe splits every time a choice is made, so that both choices actually happen – one in one universe, and the other in another universe.

This has the effect that every possible configuration of the universe’s contents exists at some point. In other words, “in an infinite universe, anything is possible“.

What this means, is that at any point in your life where you had to make a decision – get on the plane, talk to the girl, take the job – a version of you exists for every possible decision.

Personally, I don’t believe that the universe splits at each decision – it seems a bit silly. But, I do believe that in infinite time and space, if the “big bang” can happen once, it can happen again, and each time, it just has to be the tiniest bit different, so in effect, there is a universe somewhere for every single moment of this one’s existence, which differs in just one respect. A consequence of this is that even if the universe doesn’t physically divide at each decision, a universe exists for each decision anyway, so it’s as if it happened anyway.

What is you?

In a lot of those universes, a version of you exists. For all purposes, it is you. It has your memories, is built of exactly the same molecules, and lives in a world exactly like yours.

You can ignore all of the universes that don’t have a you in them (and there are an infinite number of those!), because if you paraphrase the anthropic principle, you realise that they really don’t matter – the only universes you could ever experience are those that you exist in (history is written by the victors. In other words, your present you is only possible because all of the failed “you”s are dead and therefore can be written out of history).

In each of these universes, you had a load of different experiences – you lived, died, were rich, poor, etc., which is interesting to think about intellectually (Remember all those times that you wish you’d done something different? Well, you did in at least one other universe.), but not very useful to dwell on, because that’s them, and you’re more interested in you.

You.

I’m writing this post because I’ve survived some interesting things in the past – self-harming during my late teens, standing on the edge of a 5-storey building pissing off the edge while totally drunk, all the narrow misses while skateboarding, getting beaten to a pulp a number of times, breaking my skull when I was 2.

Every one of those events had an alternative where things went the other way. But I’m here right now, which means that in this universe, I’ve survived.

The fact that you’re reading this is very interesting. You have survived all of the events of your past, and have gotten to this point.

What is “you”? The grammar-nazi in me complains about that sentence, but I mean it that way.

“You” is the sum of experiences that makes up your identity – your “soul”.

Here’s an interesting question: when you go to sleep at night, and you don’t dream, there are a few hours during which you are essentially dead to the world. What if you were transported at this point to another universe during those hours which was exactly the same – when you woke up, it would be as if you simply continued living from the previous day in the previous universe and you would be none-the-wiser.

The multi-verse idea says that this happens all the time, that every moment that you experience could very possibly be in a totally different universe that has been rebuilt from scratch.

Quantum immortality

Now we get to the freaky shit.

What if an accident were to happen right now – a meteorite drops through your ceiling, or a microwave explodes, or your partner slips in the middle of knitting and impales you.

In some universes, you would die, and in some, the event would be narrowly missed (and in some, not occur at all).

The important thing to note is that the only “you” that would experience the event is the “you” that survived. You may be damaged by the event, but you would survive and live another day (otherwise, you would not, and that universe can be ignored).

Please dwell on that thought – the only possible you that is reading this article is a you that has survived all previous experiences, but as a consequence of this crazy logic, you will also survive all future events as well.

Let’s look at the logic again:

  • There are an infinite number of universes.
  • There are an infinite number of universes that have “you”s living in them.
  • Every time there is the slightest chance that you would survive an event, there are an infinite number of universes in which you do survive that event.

A very weird consequence of this is that you, the you that is reading this, will never die. Every time an event happens that might lead to your death – a choice you made, a decision someone else made, a natural accident – there are infinite universes in which that event does not happen, and so “you” survive.

No-one else, though

Unfortunately, because of the probabilistic nature of physics, everyone else will die in time. Yes, there are an infinite number of universes in which your loved ones will survive with you, which there are many “bigger” infinities in which they die, and those win out.

This is another mind-bender, because it makes everything very subjective.

From my point of view, I am immortal, and you will eventually die, but that’s because my own experience leads me through a different set of infinities where I am the immortal one.

Every other person that exists has their own set of infinities as well that leads them to immortality.

Conclusion

Well – that’s my moment of madness concluded for today.

In short – shit will happen, but you’ll get over it, a million million times over the next load of centuries.

new API for WebME

Posted by on August 13, 2011 2 comments

As I said in the last post, an API would be required to make the system more testable and more consistent.

I started straight away and wrote up something quickly. Over the next week, it solidified into something that appears to cover any needs that I have.

So here’s how the API works:

Requests are sent to a URL which is generated like this:

/a
[/p=plugin-name]
/f=function-name
[/other-parameters]

The plugin name is optional. Leaving it out means you want to call a core function.

Parameters can be added by adding /key=value pairs to the URL.

An example URL might be this:

/a/f=login/email=kae@verens.com

Sending that, with a POST parameter for the password, will log me in.

To log out, I can use this URL:

/a/f=logout

Simple!

Function Names

mod_rewrite is used to direct a request through a script which tears the URL apart into parameters.

If a p parameter is given, the function is named after the plugin, rewritten to match the WebME coding standard.

For example, if the URL is /a/p=comments/f=editComment, then the “comments” part is rewritten as Comments, and ‘_’ and “editComment” are appended to form the function name “Comments_editComment”, which is called and the result returned to the browser.

For double-barrel plugin names, such as “image-gallery”, the name is rewritten to “ImageGallery”.

If no p parameter is given, then the request is a core function, and “Core_” is prepended to the function name.

For example, the login URL above, /a/p=login calls the function Core_login.

If a function name begins with “admin”, it is an admin function (see below for more on this).

File names

If no plugin name is supplied, then the core API file, /ww.incs/api-funcs.php is loaded. This contained common API functions that might be used by any core script or plugin.

If a plugin name is supplied, then the API file is expected to be located at /ww.plugins/plugin-name/api.php for common functions, and /ww.plugins/plugin-name/api-admin.php for admin functions.

For core functions, common functions are at /ww.incs/api-funcs.php and admin functions are at /ww.incs/api-admin.php

Security things

Having a central point for RPC means that we can apply security rules in one place and know that they cover all scripts. Before-hand, I would sometimes come across scripts and realise that they were open for abuse if someone knows that magic URL incantation. I would silently curse myself or whoever had written the script and fix it up. Now, though, having one single point of entry means I can secure everything at once.

If a function name starts with “admin”, then the script checks to see if the user is logged in and is a member of the administrators group. If not, the API will return an error. It’s as simple as that!

Of course, this doesn’t stop abuse by people that are logged in as admins or who are victims of XSS, but it helps stop a few problems caused by developers not noticing their scripts were open to use by anyone at all.

Conclusion

So now, when people are creating new plugins for WebME, the following could be used as a bare-bones directory structure:

/ww.plugins/plugin-name/plugin.php    details, server-side functions
/ww.plugins/plugin-name/api.php       common RPC functions
/ww.plugins/plugin-name/api-admin.php admin RPC functions
/ww.plugins/plugin-name/admin.js      admin scripts in JS

testing KV-WebME

Posted by on August 6, 2011 1 comment

I’ve been working on my CMS for about 10 years. It’s monstrously huge (41,000 lines, not including external libraries), and for most of those 10 years, I’ve been too busy building it to concentrate on niceties such as comments, testing, code formatting, etc.

This has caused problems in the past. As most programmers know, when you change any one thing, it has a ripple effect and can break things in places that don’t seem obvious at all.

Recently I’ve been remedying this. I’ve been religiously using PHPCS to make sure my code is neat and consistent, and I’ve started writing a test suite.

The most difficult part of the testing is that the CMS is composed of many separate technologies. If it was just a plain old HTML and PHP application, then PHPUnit would be enough, or maybe Selenium.

The problem is, though, that the system uses a large amount of AJAX – especially in the administration areas. No single testing system would do it all.

Another problem has to do with AJAX itself. In jQuery, you can speak to the server by writing something like this:

$.post('/a/server/script.php', {
  "id": 2
}, function(res) {
  // do stuff
}, 'json');

This makes it incredibly simple to speak to any server-side script at all on the server, and promotes it. It becomes tempting when writing new functionality to build new server-side scripts specifically for the new client-side stuff.

This has the effect that there is no single point for RPC (remote procedure calls) which can be tested, making it very difficult to be sure you have covered all potential problems.

To help solve this problem, I’ve recently started converting WebME’s coding style so all RPC is done through a single API (application programming interface) script.

This has a few extra effects which are beneficial:

  • Having a single point of entry into the system makes it easier to secure it.
  • Having an API promotes the construction of a solid method of adding functionality to it – there’s no need to start from scratch anymore, potentially building disparate scripts that are hard to abstract. Instead, it’s now easy to force the code to match a minimum spec.
  • APIs tend to have specific rules for how parameters are passed into it, making it easier to remember what the right parameters are when writing new client-side code. Also, it makes it easier to “guess” what the right parameters are if you’ve forgotten.

The main benefit, though, is that it makes it much easier to test. The URL of the API always stays the same, and the only thing that changes is the parameters sent to the URL. Previously, each separate script would have a different URL and could have any parameter scheme at all.

So, currently, I’m writing tests that use the API directly, speaking to the server directly through URL calls. After I’ve finished writing all of those (hah! if ever), I can get on to testing that JavaScript.

growing up

Posted by on June 23, 2011 No comments

For a long time, whenever I did something that I thought was interesting, I would write it in an article.

I don’t write as much as I used to. Not because what I’m doing is not interesting, but because it’s taking a lot longer now to complete the interesting jobs, now that they’re basically full projects and not just little snippets here and there.

As an example, we’re doing some interesting work over in the KV WebME project. The most recent is an upgrade to image galleries allowing the gallery layouts to be defined using templates, instead of saying “you want layout 1, or layout 2?”. This work is then also used in the products plugin to let people sell images in their online stores.

There are a number of bits in that project that deserve full posts themselves, but as I basically commissioned the piece and got others to do the work, it’s no longer mine to describe. For me, the cool little tricks are now just a smaller part of a bigger picture.

The bigger picture right now is 20eu.com, where you can create your own online store within literally minutes for only €20 (compare that to the “free” getting business online project, which doesn’t have an e-commerce aspect).

It’s now harder for me to write about, because there are no longer single cool aspects that I can point to that can be re-used by other people.

I was walking to work today with Conor (an employee), discussing stuff along these lines, and these points stood out:

  • In the beginning, I was a programmer, and every task had something new to me but nothing I could write about that would interest experienced programmers.
  • After a few years, I was a good programmer, and I did less tasks, but they were larger, and there were often aspects to them that were brand new, so I ended up being one of the first to build them (it helps that my field is Ajax, which is basically new-born).
  • And now, I’m tired of being just a programmer and have started branching into managing other programmers. I’m more interested now in getting full projects done than in the nitty-gritty.

Unfortunately, this means there is less to talk about that is even vaguely techie. I feel like I’m shifting focus into marketing and project management.

Ick!

On the plus side (for me), it means that eventually, I’ll have enough resources that I can get the projects done that I’ve always wanted to do.

So, I plan on starting to write about the business end of my work.

Don’t worry – I’ll categorise it correctly, so if you’re only interested in my PHP or Linux posts, then just change your reader settings to only read from those RSS feeds.