It recently occurred to me that a certain website that I check regularly could be given an unofficial RSS feed by writing a script to pull in data from its SOAP interface and spit it out as a feed. Not many websites have SOAP interfaces, but this one does, and while I’m not sure they created it to allow third-party RSS feeds in particular, I’m sure they don’t mind if I just use it for my own secret consumption. That means I won’t be disclosing which site it is that my script is accessing, although the general principle about how to write a script like this should be more useful anyway. Of course I used PHP for the script, because that’s what webhosts support, so if you want a version written in a nice language like Groovy I’m afraid you’ll have to port this script to that language.
Watching DVDs in Linux has traditionally been thought of as a difficult task, for various reasons, but none of those reasons were a problem for me when I tried watching a (legally bought, commercial) video DVD recently. I, apparently, bumped into all the possible other problems that can make it difficult, although admittedly they weren’t all exactly Linux problems, as hardware faults and user error are cross-platform.
Like the mythical Cassandra, I occasionally find myself aware of an impending disaster but unable to prevent it. The particular disaster I am talking about is writing verbose, ugly, unclear code in PHP that can be written succinctly, beautifully, and readably in Groovy (or at least one out of those three). This would not feel so ironic, were it not for the fact that I never have quite the fluency with Groovy to actually be able to write the alternative code, and thus I am forced to go with the PHP solution that I know to be suboptimal. A recent case, in particular, has highlighted this fact to me, as I had the task of turning a hash (actually a list of hashes) into a CSV file (actually a string in CSV format), while filtering the hash based on a whitelist of keys. Although this turned out to be implementable in 7 lines of PHP, I was sure it must be a one-liner in Groovy.
In a simple computer program, we like to imagine the flow of execution starting at the top and moving down line by line until it reaches the bottom. Sure, it might skip some lines if a condition for executing them is not met, or it might run some lines several times if there is an instruction to loop, but there shouldn’t be any reason for, say, a four line script to execute lines in an unexpected way. Indeed, PHP does execute code in the expected way, but as long as you have spent a bit of time thinking about what the “expected” way should be. To save you the trouble of having to think about this after writing some code which doesn’t work, and wondering why it doesn’t work, I will present an example of how PHP treats “jumping” in a four line script, and what that I mean by that term. Hopefully anyone who reads this will then want to avoid jumps in their code, as they will consider the practice harmful to the goal of writing maintainable software.
I got talking to a colleague from work about the philosophical issues of morality and surveillance (does being surveilled make people more moral?) and we ended up discussing the moral and societal framework of the Garden of Eden, as described in the book of Genesis, in the Old Testament of the Bible. He made an interesting point that, being unaware of the existence or nature of evil, Adam and Eve may not have been best equipped to determine whether a statement was a lie, or even know to ask themselves the question of whether something was a lie or not, being unfamiliar with such things. As programmers, one natural way to express ourselves clearly on such important theological questions was to write some software, and sure enough my colleague wrote a PHP implementation of the Human class, and pointed out the inherent flaw in the design, which was, he claimed, an imperfection in the system that Genesis describes. I was not so convinced that he had implemented the Genesis specification correctly, however, which perhaps shows that Intelligent Design should be left up to God (and even God might want to implement it via an evolutionary algorithm instead), but I decided to give it a go myself, confident that, whatever language God used, I would stand a better chance using Java than I would PHP.
This month I attended an enjoyable party which happened to have some A-list celebrities (of the Free Software world) present. I did feel slightly out of my depth when the topic of conversation turned to compiler optimisation bugs, but as luck would have it, I found myself listening to a conversation about web design. “I know this!” I thought, as the conversation developed into a good-humoured flame war about the semantic validity and practicality of using the table tag for presentation. Fortunately I was not the only one to believe that using the table tag like this should be avoided at all costs, and that meant I didn’t have to argue the point. I did end up, however, talking to someone who was in favour of presentational tables and I tried to understand the precise use case they had in mind that encouraged them to use tables in a non-semantic way. It turns out they weren’t happy with the result even when they used tables, but I couldn’t quite articulate or convince them of the alternate page structure which came to my mind. I knew then that it was my duty to actually write the code and prove to myself and others that a div-based design was the answer.
One interesting thing about software is that because it is written in a language that a computer can understand, it is also possible, in theory, to get the computer to tell you things about that software. There are various classes of utilities from static analysers to code style checkers, but I have recently been considering how possible it is to check for uses of specific deprecated functions and classes in a PHP project. The actual checker I was thinking of creating would use regular expressions and be written in PHP itself, but because the process would be a static analysis one, which I hoped didn’t have to resort to tokenising the PHP source code it was examining, this checker could in fact be written in any language just as (if not more) easily. As is often the case in my blog posts about PHP recently, it turns out that various “features” of PHP make things more difficult (regardless of the language that the checker is written in), although trying to solve a problem the wrong way doesn’t help either.
I recently had trouble buying something online and this resulted in me having to go into a local branch of the bank with which I had the account I was trying to use. There had actually been several issues which had been accumulating with this account, and so I thought that attending in person might be the quickest way to get things sorted out, but the process ended up taking a lot longer than I thought. Fortunately along the way I had an enlightening and somewhat amusing conversation with the cashier who was trying to help me, and I thought that I should share some of the things I have learnt. For privacy reasons I will not go into details about the current state of my account, nor will I disclose which bank it is I have this account with, but I hope it will give people a benchmark to compare their banks against, and I would be interested to know which banks don’t have the same problems as the ones I describe (or have other problems).
Yet again I have found myself on the wrong side of Debian’s strict packaging policy. There is a piece of software that I want to install which isn’t packaged for Debian, but which fortunately is packaged for the sister distro, Ubuntu. This alternative source of packages is only useful, though, if Ubuntu uses sufficiently similar package names and version numbers, otherwise the Debian package management tools will treat the package as invalid due to dependency problems. The last time I had to deal with this sort of problem was with an earlier version of the same package, plasma-widget-adjustableclock, but this time the dependency problem is slightly different and I’ve tried fixing the problem in a different way too. Below I detail what the problem is, and my not-entirely-successful efforts at solving it.
The opportunity to speak with Americans about their federal system is one I rarely turn down, as it helps me understand Europe’s federal system. While talking to a particular American, I found that, despite the stereotypes, they did not believe that the EU was a federal country, and although this meant they agreed with the vast majority of Europeans on the matter, I decided to dismiss their view as uninformed and presented them with a video of the EU president celebrating the EU national day by reading a speech and watching the EU flag being lifted by members of the EU army, followed by a military band performance of the EU national anthem. I feel, though, that to really convince an American (and possibly a European too) that the EU is a country, I must provide a list of the state flowers of each of the EU states, which was, as I explained in an earlier blog post, one of the only things the EU was missing.
I’ve recently made a few changes to my blog and thought that, in the self-referential tradition of bloggers, I should mention some of the decisions I made and how they affect my blog. The most external change, and the one mentioned in the title of this post, is that I do now have a domain to host this blog on. By “external” I don’t just mean it is potentially visible in your address bar when you visit any page of the blog, I also mean that it involved interaction with various third parties. It is a change I had been meaning to make for a while now, and one I should have made long ago, but hopefully it should last a long time.
By a strange coincidence, I’ve recently bumped into another PHP gotcha, well, actually three of them depending on how you’re counting, but I’m sure that these must be the last three unexpected things about PHP and I won’t soon have to write another blog post detailing something else unintuitive that PHP does. The reason these could be seen as one gotcha is that they all involve PHP’s support for floating point numbers, so one workaround would just be to not use that datatype at all in your programs. As I will show though, it is harder than you might think to avoid them, so perhaps the best advice is to avoid using numbers at all. To be on the safe side though, maybe you should just use a different programming language.
A project at work recently reached an interesting crossroads where it had to be decided what the spelling convention should be for some code which the company’s partners would have to interact with. The use of English as a common language had been uncontroversial up to that point, but there had crept into the software words which had different spellings between American English (en_US) and British English (en_GB). As a passionate European, it made sense to me to choose the version of English spoken by the English, but the more I researched it, the more I realised that the correct international standard really was en_US. Perhaps the deciding factor for me was that the coding standard for the European Space Agency requires the use of en_US spelling, which I will mention below in my depressingly convincing argument for that same linguistic standard.
While my previous blog post covered what may be an actual bug in PHP, there are still a couple of gotchas which might be worth mentioning. Firstly there is the inconsistent way it deals with single and double quotes around strings, and then there are the undesirable consequences of how it juggles variable types, for which I have an example. Of course, all languages have their problems, with the obvious exception of Groovy, the superiority of which I will demonstrate with a one-liner, possibly accompanied by an excuse to explain why that simple one-liner was so hard to write.
The title of this post is even less helpful (and less fair) than the title of the blog post which inspired it, so it should probably be viewed as parody. However, I do sadly have a file on my computer called hate.php containing a series of lines of valid PHP source code which produce unexpected and even perplexing results. Admittedly there are only 6 lines, and the behaviour of half of them is as documented, but I hold PHP to a higher standard than I would a “messy” language like Perl, so I thought this deserved a blog post.