I’ve decided to upload my Visual Studio 2010 Fonts and Colors settings for public consumption. The colour scheme is loosely based on the Railscasts TextMate theme. Here’s a couple of screenshots to give an idea of appearance:

(Click to view larger).

To install:

• Download the theme settings file.
• In Visual Studio 2010, go to menu Tools -> Import and Export Settings…
• Import selected environment settings
• I recommend you save your current settings – just so you can revert them later if you don’t like the theme!
• Hit Browse… when asked to specify a collection of settings
• Make sure that everything is ticked to import, and hit Finish

By default, the theme uses Consolas size 12. You can adjust these settings easily by opening menu Tools -> Options and finding the Fonts and Colors section under Environment.

Note that Visual Studio is a prick, and has something in the order of 100 different colours that can be set. I have only set up colours for things that I am commonly doing, such as coding in C#, HTML, or XAML. Every now and then you might come across a colour that looks funny against the dark background. This can of course be modified by hand in the Color settings by tracking down the appropriate item in the colour list.

• Disable the automated behaviour:
  • In options, open the Projects and Solutions section
  • Untick Track Active Item in Solution Explorer
• Enable a keyboard shortcut to track the active item when you want to:
  • In options, open Environment -> Keyboard
  • Search for the command View.TrackActivityinSolutionExplorer, and enter your desired keyboard shortcut

Not sure if this works in other versions of Visual Studio, but it’s working a treat for me!

To explain the feature, first let me explain the problem it solves. Supposing I have a number of similar lines of code:

Item1.Text = GetData("Item1")
Item2.Text = GetData("Item2")
Item3.Text = GetData("Item3")
Item4.Text = GetData("Item4")
Item5.Text = GetData("Item5")

… and I want to make a similar change to each of these lines, such as:

Item1.Value = Convert(GetData("Item1"), String)
Item2.Value = Convert(GetData("Item2"), String)
Item3.Value = Convert(GetData("Item3"), String)
Item4.Value = Convert(GetData("Item4"), String)
Item5.Value = Convert(GetData("Item5"), String)

Currently, I can use tools such as Find and Replace to replace e.g. “.Text = GetData(” with “.Value = Convert(GetData(“, but replacing “)” with “), String)” is a bit more tricky. For that I would probably copy and paste “, String)” onto the end of each line. Either way, this is a very repetitive task. And if there’s one thing that we know, it’s that computers are excellent at automating repetitive tasks. I would love a tool that, after I’ve changed a couple lines, spots the repetition and intelligently asks if I want to apply the same modification to subsequent similar lines – ideally with a preview to check accuracy.

Another example. Supposing I have a list of blank <select> options that I’ve quickly copied and pasted ready for population:

<option value=""></option>
<option value=""></option>
<option value=""></option>
<option value=""></option>
<option value=""></option>

… and I fill the lines in like so:

<option value="Item1">Item1</option>
<option value="Item2">Item2</option>
<option value="Item3">Item3</option>
<option value="Item4">Item4</option>
<option value="Item5">Item5</option>

Again, I would fill in the first couple of lines, but this one would work a bit differently. The tool would realise that the value and text of each item is the same, and automatically fill out one based on what I type in the other. I.e. I’d type “Item3″ into the value field of the third option, and it would automatically put “Item3″ as the inner HTML. Taking it a step further, in this particular example, it could also pick up the sequential numbering of items, and suggest to fill out the remaining items automatically. A step further again, and you could get it to work with e.g. form elements or project datasource columns, to automatically produce entire forms and classes based on a bit of initial prompting – i.e. write out some code that mentions the first and second columns of a given datasource, and it suggests lines of code similar to the lines entered, but with the other column names.

Of course this tool is completely hypothetical – at least as far as I’m aware… But in theory would not be too drastically hard to create, and would save developers everywhere a lot of time; I’m allowed to dream, aren’t I? If it became a reality, it would be a huge feature – the next big thing perhaps?

If you have been browsing the internet lately, you have more than likely seen a Facebook Connect box. It looks like this:

This particular screenshot is taken from Gameplanet Forums, but Facebook Connect makes it easy for any website developer to embed the panel into their website. I could put one on tom.net.nz, if I was so inclined.

Now, Facebook would argue that this frame is a naive, harmless feature, because the information is never passed directly to the website in question, but rather the website just embeds a little piece of code, and Facebook generates the actual content of the pane. The code embedded is identical for any user visiting the website.

This is all well and good, however (!), the content that Facebook generates for this pane will differ depending on whether or not the user viewing it is currently logged into Facebook. If they are, then Facebook tries to show information more “relevant” to that user. For example, in the above screenshot, “Matt” is my friend on Facebook (and the only person in my friends who has “liked” Gameplanet on Facebook). The other people are generated randomly, but no matter how many times I refresh the page, Matt will always appear in the list. Do you see where this is going?

One might assume that Facebook has put some measures in place to stop the site from scraping this information, however the tech savvy can follow the following link which generates the box for Gameplanet’s Facebook Connect pane: link. If you view the source, there are all the names, in plain HTML, with links to both the photo, and (perhaps more disturbingly), the profile of each person. I was also able to scrape my own user ID from the HTML. Fortunately, in most modern browsers, XSS (Cross-Site Scripting) protection prevents the parent page from accessing the DOM of Facebook’s frame, but this is still a major potential security problem for older browsers which don’t have such protection built-in. By inspecting the list of users on a few page loads and looking for duplicate names, a malicious site could ascertain who is friends with the user browsing the page. The parameters passed to the frame source allow significant customization of the response, for example with a bit of tweaking I was able to come up with the following source, which now shows 100 users instead of the default 15. To take it a step further, a malicious page could potentially load this frame without even showing it, meaning the user would be completely unaware that the site was doing anything to do with Facebook, meanwhile it’s scraping the user’s private information.

Of course, those using a remotely modern browser do not have to worry about this sort of attack… But I think it does highlight the potential risks associated with these completely unnecessary “features” – not to mention the dangers of using an out-of-date browser. I would have hoped that at the very least Facebook would have performed some source obfuscation or dynamic JavaScript DOM population.

Those aspirations had always been in the back of my mind, while I worked on my Bachelor of Engineering, and worked at Canary. After an initial application attempt to Microsoft in 2008 that was thwarted by the recession, I decided to prepare my CV once again at the end of last year (2009). Without much further thought, I submitted it to Microsoft. Then about a month ago, I received an email that I was to be having an interview over the phone. As far as I could tell, this phone interview went atrociously, but contrary to my expectations I received an email a week later detailing plans to fly me over to Sydney to interview in person with a few recruiters. I arrived back from said flight this morning.

Long story short, I will be moving to Microsoft’s Redmond HQ in Seattle, USA. This will be taking place in late September.

This is pretty much a dream come true, and I’m stoked to actually be seeing those aspirations from so long ago become reality. I have long said that I would not be looking for another job in New Zealand, and I have truly enjoyed my time working at Canary. However, the opportunity to be able to work in another country and see some more of the world was simply too great to pass up. I believe that I will also find more room for personal growth and career advancement in a larger company. By the way, quick plug for our job ad, if you’re a software developer in Auckland.

This change is not without its drawbacks, and I will miss much about my life in New Zealand, not the least of which being proximity to family, and the friends that I have grown close to in Auckland over these last few years. I will miss you all like crazy. I hope to have a blast with my last few months in New Zealand (let’s hit the snow!), and no doubt I’ll be spending the majority of my annual leave here (New Year’s anyone?).

Keep an eye out for some sort of leaving party!

Cheers.

• Home
• Pools

Hopefully if I keep this up, I’ll be inspired to write some actual code…

And now… Now I’m not sure if I’ll ever be bothered to do anything with it. If I haven’t started coding come the time when the domain expires, I might just let it go. I just didn’t get inspired enough to start implementation. I think I need a really fresh, engaging project to start on. Open to ideas.

(Click through for full size).

It’s a little unclear, but it’s a number of perfectly reflective spheres hovering above a green plane, being imaged from above. There are several bounce iterations, two light sources, and full specular shading/shadows. Notice the non-jagged edges (indicating that the antialiasing is functioning as intended).

Here’s a closer view with some additional stochastic anti aliasing:

From a very young age, my family has owned computers. There is a photo of me at about 2-3 years of age grasping a joystick and playing Jet Set Willy on an AMSTRAD CPC 6128. While I don’t have the actual photo, here’s what such an AMSTRAD looks like:

This particular AMSTRAD came with a few floppy disks with programs and games on them, and a book. The computer was programmed using a stripped down version of BASIC, and the book contained a bunch of example programs, often many pages long. I learnt to type pretty quickly with two fingers, as I would laboriously type out these big long programs. Often one mistake would result in them not working properly (or not at all), but there was always a certain sense of satisfaction (and fascination) when the computer would spring into life and actually do something based on what I had just typed in. My interest was piqued.

After a few years, the old AMSTRAD gave up and died, and we got a 386DX PC as a replacement (loaded up with the shiny new Windows 3.11). After a frustrating few days trying to enter BASIC commands from the AMSTRAD book at a DOS command prompt, I decided to talk to my uncle, who was in the PC business (and built the 386 for us). He installed QBASIC for me and showed me how to use it. I quickly discovered that the AMSTRAD programs didn’t work so well in QBASIC, and so a visit to the library later, I was teaching myself QBASIC. My first programs were pretty basic, doing things involving displaying text output and taking text input. I can recall a “math quiz” program that generated random math problems and tested for the correct result.

QBASIC was my staple programming language for the better part of 5 years (I would estimate from the ages of 7-12), and after a while I got fairly proficient at it, creating applications with “rich” (at the time) graphics and sound. However, I was inevitably getting a bit sick of it, and my interest in creating QBASIC applications was quickly tailing off. It was about this time that we got a flash new computer – a Pentium 200MHz with Windows 95.

It was at the age of 12 that I then discovered Visual Basic on one of the computers at school. Here was a language that let me apply my BASIC knowledge to creating pretty rich Windows applications in an astonishingly straightforward way. A bit of begging and pleading later, I managed to score myself Visual Basic 6 on my 13th birthday (sad, I know). My interest was once again piqued.

What followed was a raft of fairly complex (if I may say so myself) applications, such as a timesheet application that I used to record my lawnmowing/carwashing/chores hours to charge my parents, an MP3 file renamer, a digital camera synchronisation tool, and a prime number finder. I even made a nifty little application for my Dad that would recognise when ArchiCAD (drafting software he used for work) was running and in focus, and record for how long. He used this for a couple of years to record his working hours when working from home.

Of course, with my ear to the ground, it didn’t take me long to work out that Visual Basic wasn’t the be all and end all of programming languages (in fact, quite the opposite – it’s in many ways the ugly cousin of “true” languages). I kept hearing about this amazing language known as C++. And so when I was about 15 (I think it was for my birthday again), I became the proud owner of a pretty thick book about C++, covering everything from the basics, to pointers and multiple inheritance. For a time I was a little discouraged, as C++ lacked the “glitz and glam” of VB6 (the book only covered writing console applications and the features of the language – in retrospect the right way to learn), as even after 6 months or so I was still writing applications that made text output and took text input. In some ways it was like going back to QBASIC.

After a time I discovered the Win32 API, and how to create a window and make a message queue and so on. After a couple days visiting a local game development studio, I was inspired to create some little graphical applications, such as a 2D particle system and a “starfield” animation, using C++ and Win32. I never totally got into it, though. I hadn’t discovered MFC at the time, and Win32 was a major pain in the ass to write. The peak of my C++ coding was a little 3D game that I made after discovering the DirectX Software Development Kit (SDK). The language always struck me as pretty ugly (especially with the horrendous Hungarian naming that all the Win32 libraries used), and I longed to return to a language that had sensible naming and no preprocessor directives. In my reading about the DirectX SDK, I discovered a newly emerging language: VB.NET. I was about 17 at the time.

I set about translating my C++ 3D game into VB.NET. By the time I had it working (a surprisingly simple process), I was sold. .NET let me take the good bits of VB6 (simple window creation, sensible naming, etc), and combine them with a fast, robust, non-scripted language. Naturally, it wasn’t long before I moved in turn to C#, which continues to be my preferred language to date.

From about the age of 15, I knew that I wanted to turn my interest into a job. It made sense – I enjoyed doing it, why not get paid to do it? And so I decided to go into a Software Engineering degree after high school. At university, the first language we were taught was Java (where my C++/C# knowledge meant that I already knew everything I needed to know). I went drinking the night before the final exam, finished the 3-hour exam after an hour, was first to leave, and still managed to get an A+. Score. After that, we were taught a variety of other languages, including C (again, C++ came in handy), Tcl/Tk, and Lisp. Fortunately things got a little more challenging in 3rd and 4th year, and I was actually learning things about programming again.

I’m not really sure how to finish this post (as my interest is very much an ongoing thing), so to sum it up: I’ve been cultivating a passion for computers and programming from a young age, and I now get paid to do what I love; Code.

When complete, it will be a “betting pool” application (for fake money, of course!). Basically, users can create pools with several options that others can place bets on, and the total pool is divided among those selecting the winning option. Pools can be about anything and everything, and will likely be community regulated (for example, creating a popular pool will net you some of the winnings; and falsifying the winning option will result in you getting a bad rep).

If you have any cool ideas around this project I’d love to hear them!