So, if you are a student at university and interested in a Free Google T-Shirt and Some Money for contributing to a PHP Open Source Project, then check it out. I’ve identified three projects that I will be mentoring on if suitable students are found, and there are a number of other projects available if you hate me

For a long time I hated “browser nazis” who were always telling me that I should switch to [Mozilla|Firefox (pre 1.0)|Opera|Something Else] and eventually I gave in and switched to Maxthon. Then Firefox 1.0. Which really did make me feel silly. Once using Firefox 1.0 I realised the others had been right. IE was terrible. Firefox was awesome. But not too silly as Mozilla, Opera and other alternatives before Firefox were pretty rubbish too (Opera is sounding interesting now, but Mozilla and Safari etc still leave me cold).

I still can’t stand the thought that I might not have an “optimal” Firefox extension set enabled, so here’s what I’m using, is there anything you think would be best added to this list.

Firstly, I have three profiles. Lite - Need a browser fast. Default - Just for surfing. Developer - for doing web development. I don’t load firebug/developer’s toolbar and their overhead just to check my online bank. I’m most interested in optimising my Default profile, but that builds on my Lite profile.

(All profiles include the British English spell check add on and talk back crash handler)

Lite
This needs to load fast and provide a fast browsing experience. I have only a few extensions in this:

1. Adblock Plus - Remove banner ads, save network time on them.
2. FilterSet.G Updater - Keep my Adblock Plus filters up-to-date with the excellent FilterSet.G
3. CS Lite - Prevent those horrible advertising types tracking my surfing patterns with a nice “AdBlock for Cookies” style tool.
4. Del.icio.us Complete - The official Del.ico.us extension to replace per-profile bookmarks. I have access to the same bookmarks in all profiles.

Default
This is where I live when not in a rush and not coding. It’s optimised for surfing experience:

1. Deepest Sender - UI For posting to LJ
2. Digger - Right click the “go” icon to mess with the URL, very, very handy
3. ErrorZilla - Better than a server not found message
4. Greasemonkey - Tweak sites my way
5. Leechblock - Keep me off “slacking off sites” when working
6. TwitterFox - Update Twitter
7. Google Reader Notifier - Check my RSS feeds
8. IE View - Open current page in IE, if it’s not working in firefox (useful for MS sites!)
9. Customise Google - but thinking of removing this…

Development
Really, this just adds Developer Toolbar, HTML Validator and Firebug to the above.

What essentials am I missing?

Other than the fact I’m starting to get pretty worried about the security and stability of the software in general, it’s a pain in the rear to have to keep upgrading. So I’m making it easier for me. Wordpress themselves have helped by having a decent system in place for making it easy to get the latest.

I now have the simplest of shell scripts which:

1. Backs up my database.
2. Backs up my Wordpress folder.
3. Gets the latest Wordpress release.
4. Unpacks that release.
5. Deploys that release live.

Being nice, I’m going to share it with you:

mysqldump --host=localhost --user=wordpress --password=wordpress wordpress > wordpress.sql
tar -zcf wordpress_backup.tgz wordpress_live
wget http://wordpress.org/latest.tar.gz
tar -xzf latest.tar.gz
cp -r wordpress/* wordpress_live/
rm -r wordpress


Of course this assumes that you have a wordpress database in a localhost MySQL instance with username and password wordpress and that your live wordpress folder is wordpress_live so you can cope with a temporary wordpress folder from the unpack. It also assumes that mysqldump, tar and wget are available in your shell.

Also, I don’t just do this on live. I back up my live, put it on my portable instance and test the new version first. Then I do it on live. Then I update the versions of my plugins.

What an arse. This is why I prefer Geeklog. It’s more secure and doesn’t change at an alarming rate.

Now I can SSH into my server and type ./upgradewordpress.sh when I’m ready then hit http://inanger.com/[secretlocationofadmin]/wp-upgrade.php and finish things off. Job done. I still have a pain in the rear as I have to test the release locally first (./upgradewordpress.sh on local instance of course, after restoring a fresh backup of live into it and adjusting the config to refer to my local instance).

And I think this is less risky than tracking Wordpress via SVN on live.

Firstly, you must get your database under version control if you ever plan on releasing more than one version. You must have an authoritative source of schema and procedures etc, you must do versioned releases. This is not in contention. But other points in K’s series and Jeff’s unquestioning support for this are.

Secondly, some background, I’m a Development Manager for a Microsoft Technology Stack web based application which is maintained and released as a product. We have a lot of tables, a lot of stored procedures and other database entities. And a lot of developers.

Taking the approaches outlined by K in his posts on Change Scripts and Views, Stored Procedures and the Like on face value, they are hopeless. They’ll get you into trouble. Fast.

K’s process is one script for the database schema and one script per stored procedure in the master definition. He then references Phil Haack’s Bullet Proof Sql Change Scripts post for an idea of how to provide better change programs than his simplistic ones.

Phil’s stuff is good in principle, making sure that your SQL Change Scripts can execute many times, but, they are laborious. We’ve rolled all the checks you could possibly want into a set of functions dbo.ColumnExists(TableName, ColumnName). dbo.IndexExists(IndexName, TableName) etc.

But with a system like ours with thousands of stored procedures (literally) and doing a re-deploy of all sps is painful. So we script only the updates and roll them out. But that will be a lot of updates in a release designed to take any version of our oldest supported version up to our newest major release (iApplication XP Panoramic Web 2.0 Version). Executing each of these individually and tracking the results is a hassle.

The next step is to roll these scripts together into one to make a quick deployment, just get the installer/dba to execute “Update_1.1.0.1.sql” on the target database and there you go. *

Only that’s when it gets really problematic. SQL Query Optimiser pulls the rug out from under your feet. What it will do is change the order of execution to optimise it. It’ll create new tables, add rows and script stored procedures at times to suit it’s own optimisation desires. And then everything will fail. Columns won’t exist, so stored procedures won’t compile. Views will fail. Commands to add indexes will explode. There will be bits of schema all over the place.

So then you have to wrap every alter table command, every DROP usp_ and CREATE usp_ in sp_executeSQL. Which means you have to escape every ‘ character correctly. So then you need to write a tool to generate the change scripts cleanly.

Then, you find that if you are executing hundreds of changes in batch in a single change program, you’ll find that it’s hard to stop a change logging itself when only part has fallen over, so then you have to wrap each item in a check for @@ERROR to see if anything went wrong. And wrap the whole lot in a transaction and roll that back if any errors happened at all.

Right, so now we have something approaching bullet proof. Now we need to make sure our team of developers do it right every time. We write a process document and run a training session. We explain how each development starts with getting the latest SP/Table definition from Source Control making your changes, generating your change program. That your change program must be tested and shown to execute cleanly leaving the full trace etc, and must contain the right assigned version number.

Whoever writes this change script will test it thoroughly and against a variety of test data, then commit the change script into source control. The schema change is officially published. The schema change will start to appear in developer workspaces as they update from source control, and on test machines as new builds are pushed into QA and beyond.

That just doesn’t work. You will despair as even your best guru programmers, the ones who really care about their craft, make mistakes and take short-cuts because the process is onerous and is seen as a tax. So then you need to have a nightly build process that restores a clean database, executes every change against it, checks the results and the database. That runs a parse on the change program beyond the SQL Execution to make sure the rules are adhered to and Change_1_0_1_0_2.sql actually records itself as 1.0.1.0.2 and not 2.0.1.3.4 which is it’s number on a different branch etc etc. K’s text is incredibly hand-wavy.

1. Never use a shared database server for development work.

The convenience of a shared database is tempting. All developers point their workstations to a single database server where they can test and make schema changes. The shared server functions as an authoritative source for the database schema, and schema changes appear immediately to all team members. The shared database also serves as a central repository for test data.

Like many conveniences in software development, a shared database is a tar pit waiting to fossilize a project. Developers overwrite each other’s changes. The changes I make on the server break the code on your development machine. Remote development is slow and difficult.

Avoid using a shared database at all costs, as they ultimately waste time and help produce bugs.

So having a single instance per developer on their local machine is a panacea for all your “shared database” problems. All those bugs created by people over-writing each other’s schema changes etc.

What about when a developer neglects to update their local instance and produces a fix based on an out-dated schema or stored procedure? Same thing. How do you ensure all your developers are keeping their local instance sufficiently up to date? Auto-update their instances with each commit as it’s stabilised? What if that wipes out their changes?

I’m not saying a shared database solves these issues, or that you won’t run into the issues he mentions on your shared database. But it’s only one point to control. We periodically re-stabilise our test and development databases where developers are patching their work for peer testing. We’re working on improving this process all the time. Some development requires an isolated environment to avoid breaking everyone’s ability to work, and they do have isolated local environments, but only for the length of that development.

Database version management is an incredibly hard problem to resolve. And although getting people started with it as K and Jeff have done is good, it’s not enough. You have to go further. And if you’ve gone further than us, please tell me where we go next!

* - (Using isql with the right voodoo to supress all the line numbers and pointless messages just leaving us the completion state, piping the output to a text file which we can parse to ensure that everything completed AOK and the database is not left in an inconsistent state, prior to us then needing to validate that the database IS actually in a decent state and the scripts haven’t falsely reported success…)

It’s been suggested that Polyglot programming be in the list. Even though I do subscribe to the notion that learning other languages are beneficial to one’s craft, it simply is not pragmatic advice. It is not practical to recommend that someone study Ruby, Groovy, Scala and who knows what other language is vying for your attention. Stick to a couple of languages and do it well. Some languages are better than others for certain tasks. However the biggest fallacy of all is that, a dynamic language is not considerably better than a static one. It’s no magic bullet.

The main thing to note, is the paragraph is not completely wrong. The author does note that “the notion that learning other languages are beneficial to one’s craft”, but unfortunately caveats that with it’s just not pragmatic or practical and that the reader should stick to a “couple” of languages.

I strongly disagree.

As a professional programmer, in your day job you should code in one technology set. Note I say technology set, not language. For some that may be one language. For others that may be several. For me, the last time I was a hands-on-programmer as my day job, that was Javascript, CSS, XHTML, ASP(VBScript), Visual Basic 6 and T-SQL.

You should strive for a deep and complete depth of understanding of that technology set. This should clearly start with a basic competency of the limited set of those technologies that relate to the product/project you are working on. But you should deepen and broaden this understanding as fast and well as humanly possible.

You should know how to do anything that VB6 can do, not just within the context of your web development. You will need to learn the aspects of VB6 programming that can never be used in a web context, but along the way, you will learn many things you would not have otherwise learnt. These things may be things you can directly use in a web context, or things that just improve your approach to problem solving, design and development issues, a fresh perspective on the language.

The next step from here is to take that solid grounding in your primary weapon and mature and expand it with exposure to other languages and technologies.

The development communities around each language are akin to separate nations. Sometimes diplomatic channels are open and citizens freely move between the nations. Other times there is open hostility. Each nation has it’s own way of life. There is always some common ground between all languages, but, often between them they have vastly differing ways of approaching a common problem. Continual exposure to these different languages opens you up to more ways to solve the problems you are faced with. You will be able to deal with a vastly wider range of problems as a result.

And this is a critical skill to develop.

Do not let yourself become an island nation. Have that deep mastery of a key language/technology set and use it daily, but make sure you are also constantly looking around for other languages and ideas to broaden your understanding of your craft. Travel widely. Use the languages for “real” in anger development to really understand the different pain points. Ruby may solve one pain for you at the cost of other deeper pains.

Without you, and people like you, doing this language tourism, building this breadth, there won’t be a new top 5 interesting technologies in [whatever language] in 2009, because the [whatever language] community will stagnate as it examines it’s own navel.

And the documentation did not help at all. So, allow me to elaborate for the benefit of the huddled masses.

The introduction in the caching section of the manual gives a decent enough overview of the basics, if I want to cache a page with a nice simple ID, such as “Page1″ with a set lifetime I can do so in a few lines of code.

However, another page goes on to mention how you can also “tag” records with multiple tags. Another page talks about how to clear the cache by a single tag, or combination of tags.

But nothing explains the relationships between tags and ids, and how the clear works with tags or ids.

Now, I’m working on a system which has two views of a music catalogue for a radio station. There is the requests system and there is the discography system. They both present differing views of the same data. The request system filters the list of artists, albums and tracks on the station to those that can be requested and displays a “request optimised” set of screens with some of the data. The discography section shows everything about an artist, all their albums, all tracks, reviews and so forth, without the cruft needed for the request sub-system.

We cache these screens for obvious reasons. What we need is the ability to clear the cache of an artist, album or track possibly within the requests or the discography, or both. So, I figured on a system of unique keys like artist_123 and album_123 etc then to use the tags to “lump” things together. So album_123 would have the artist_123 tag in both discography and request view plus the discography tag in the discography and the requests tag in the requests view. Something like:

$cache->load("album_123", array("album_123", "artist_123", "requests", "en_GB", "album");

I could then simply invalidate the cache of all albums, request pages, artist_123 pages or British English generated pages or any combination of those items

This does not work.

The first important thing is that the ID is the unique key. Not the combination of the ID and the tag(s). So if you save page1 to the cache with the tags tag1 and tag2, then try and load page1 from the cache with tags tag3 and tag4, you’ll get the result of saving with tag1 and tag2!

Insane, but true. Try it. The tag has no effect whatsoever it seems on the load code. If it can find an item by ID, then it loads it, irrespective of tags. I’m not sure if this is behaviour by design, or a bug on my system using the file backend, but it is consistent. I just think it’s mad.

To get what I desire, I’m going to have to cache with:

$cache->load("requests_artist_123_album_123_en_GB", array("requests", "artist_123", "album_123", "en_GB", "albums");

Then I can still do a clear on the appropriate tags, if for example I want to remove all albums from the requests cache:

$cache->clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG, (array("requests","albums"));

It’s a bit of a pain in the rear, but, once you’ve figured out the $tags argument on the load method is pointless, it’s fine.

Of course, figuring all this out was further compicated by the fact that the examples in the manual often use load() with $key and $tags and save() with no arguments. I assumed therefore that the point of the $tags argument on load() was to set the tags that would be used auto-magically on save(). Only, if you don’t pass $tags to save() it saves with no tags. Which is also silly, since it does respect the $key used in the load() method.

On these occasions, I either turn to Query Analyser to mine our SQL Server databases directly, or use the data import tool in Excel and try and crunch the data swiftly in that. Sometimes, those needs become a long running need to manage some data, where Excel is often the preferred format, because I can do some initial crunching and manage the data in there and the rest of management can then take a copy and further manipulate it and play with it to get additional information as and when it occurs to them they need it.

The problem I face is that Excel is designed for accountants and management types with no programming knowledge to manage spreadsheets of data they understand. It’s too damn user friendly. I find it very hard sometimes to find a good way to manage my data in Excel. I often throw my hands up in dispaire and lash up a software tool specifically to manage the data. I’m talking about a full on database driven web application in most cases. It’s so much faster for me to work with the data that way, and I can then use the Data Import tool in Excel to shove the data in raw forms into spreadsheets if the people asking for the data want to take it away and play with it.

There has to be a better way. There has to be a more productive way for me to do this. A more developer focussed tool for doing this, that allows you to achieve with scripting/programming what you would achieve in Excel by mucking around with excessively user friendly wizards and obscure dialogue screens.

John Udell thinks the answer might look something like Resolver, which is a new spreadsheet application written in Python that allows you to use Python directly in cells and to have full access to .NET and IronPython through the whole application.

This just seems to be the wrong solution to me. With Excel we have a spreadsheet product that is so good it’s destroyed all competition that non-programmers use and love. It can be extended by programmers with add-ins and macros. You can write .NET code or VBA code (easy for non-programmers to learn) in the Macros etc. However, the formulae are restricted to the old style “icky” functions. Stick=if(condition,forumlae,formulae) in, which just makes programmers recoil from the keyboard in horror.

The right answer to the question is to have a simple option to enable direct access to the .NET runtime in cells. Then people can code formulae in any .NET enabled language they choose, including IronPython.

Do not throw the baby out with the bathwater.

Steve starts out, much like I did by pointing out that what he says only relates to recruiting people for the kinds of places he works, and may not apply outside of the recruitment of technical people for companies that produce their own software, and even within that niche, may not apply to everyone:

I’m just talking about software engineer resumes today, and specifically just the subset intended for applying to companies that build their own software. I have no idea how much (if at all) this stuff applies to resumes for other kinds of positions, or companies. Maybe not much. Sorry!

It seems the companies he’s worked for take a different approach to reviewing CVs to any company I’ve ever worked for. It seems they have a large CV screening panel, phone screens (possibly multiples) and multiple panel interview sessions. We do it differently.

Steve’s first point is right, in bullet form, no-one cares about you yet, but he also suggest stripping out anything with personality in it. Which I disagree with strongly. I do want to know what you’re like other than as a professional software engineer. I recently came across a candidate who was a Reiki healer and psychic reader. Who offered his services for £25 an hour over MSN or email. This information was gleaned from “personal interests” on his CV and listing his personal webpage address. Valuable information saving me from interviewing a total fruit-cake.

Steve’s point 2 asks for unformatted ASCII CVs. This is because where he works they pump them through automated manglers. That is not true anywhere I’ve applied for a job or worked in my life. It’s true that Pimps screw them up, something I was planning on writing about soon, but, in general I’d prefer to see a nicely formatted word doc, that has had some care and attention lavished on it than a nasty plain .txt file.

Points 3, 4 and 5 have merit. Don’t set off my bullshit detector with too much weasel and wank talk. Make sure it’s spelling and grammar checked, if it’s a word doc, and a UK install f Word has put a red squiggle under anything other than an obscure techie term, you’re a moron. But, don’t rely on the spell checked, I’ve seen far too many CVs with spell-checking mistakes.

However, my biggest contention is point 6, certified looser. If you are a contractor, get certifications, do them in your own time, it shows your skill, gives me more confidence you have at least a basic level of understanding of the subject and technology. A safety net. it’s also quite common for UK companies to put people through certification courses to ensure their staff have that rounded skillset, that they know the right way of doing things, and to give the employee something back to move their career on. Certification is great.

But, just a few things there, the certifications, the format of the cv, the lack of personal information. Submit a “perfect for Steve” CV to me and I’ll reject you. Submit a perfect for CV to Steve and he’ll reject you. It’s impossible to get this right. The single best tip in Steve’s article?

You can apply for 18 jobs, but you should send 18 different resumes, each targeted at that job, and you shouldn’t send them all at once.

Tailor it for the job. It’s web development? Emphasis your experience in that area, and trim down the references to the Linux Device Driver work you’ve done. And try and get a feel for the company you’re applying for. If it’s a Big One, like IBM, Microsoft, Amazon, Google etc, there is plenty you can find out about what the recruiters are looking for. Talk to the Pimp, ask them what kind of CV the recruiting managers like to see.

Do your research first, it really helps.

Two of the guys I’ve worked with in the past and have equally successful careers, following similar tracks, who are of similar age and position in their career, have totally different approaches. Clive goes for the “everything in a good level of detail” approach. Pete’s CV is two sides, and he thinks it needs trimming down.

I think Pete’s CV comes from the approach that it seems a number of managers take, they want to get the details quickly and don’t want to wade their way through a load of self-promoting rubbish to get to them. Clive’s approach comes from the desire to give all the information so that every base is covered and people won’t miss any of your brilliant skills.

Personally, as a recruiting manager, I like to see a good level of detail on a CV. I want enough to really know whether it’s worth seeing the candidate or no. I want to get a feel for the candidate in advance. I want a chance for them to make mistakes.

But not all managers want that. They follow the Pimp Path, they want to find a few keywords, such as 10+ Years C++ experience on Windows Drivers. Or whatever. If they can’t get this information, they’ll reject the C.V.

The big problem is you don’t know what kind of manager your C.V. is going to.

I’m starting to come down in favour of a hybrid approach. The first page of the C.V. should be a totally lightweight highlights and basic facts page. With detail to follow.

Something that is also important to understand is what information you do need on the C.V., what order and level of detail to present it, and unfortunately that changes based on where you are in your career. For a graduate, clearly education history should come first, it’s the most relevant information. For an experienced engineer, the education history gradually becomes less and less important. But I still feel it’s necessary to include that information.

I think a front page should probably detail personal details, in a small contained area, current role and a brief statement of what you’re looking to achieve in your career. If there is room, a brief summary of key technical skills. Brief please, and the key ones. Not an exhaustive list of everything you’ve ever worked with.

Then, follow this with a career history, education history and some personal stuff.

With the later part, people are rather conflicted on too. Some people think a bit of “personal interests” adds something to a CV, others think it’s a no-no. Which seems odd, because technical skills are not everything, you also need to know if that person is going to fit in with your team and company. Are they going to have the right attitude to work? All information that can be indicated very roughly from the information given there.

So, summary, and then a set of detail. Attempting to keep as many people happy as possible. Really, an example would help. But I don’t have one to hand. And this is the worst article I’ve written ever. I’ll try and come back to it when I’m more alert.