Reinventing the Wheel

Known Space

noreply@blogger.com (Anonymous) — Thu, 28 Sep 2017 19:48:00 +0000

Coming soon to iOS, Known Space is the premiere app for astronomical discovery and education...

http://cranium-software.co.uk/known-space/

Neat little Google feature I never noticed before...

noreply@blogger.com (Anonymous) — Sat, 07 Dec 2013 13:28:00 +0000

A Google doodle for my birthday... :)

My rule of three...

noreply@blogger.com (Anonymous) — Wed, 04 Dec 2013 15:01:00 +0000

... is that three times is too many!

I do tend to repeat a variation on "if you have to do some thing three times with only small differences, generalise that code". The example that makes this clearest is copy-paste code with small differences...

So, to give a concrete example I hit this code a little earlier and needed to add an extra instance of the repeated logic here:

protected override void OnGo(){    //FloatyBoostTrail    Transform childTransform = transform.FindChild( "Pickup" );    if( childTransform )    {        GameObject icon = childTransform.gameObject;        icon.SetActive( false );    }        childTransform = transform.FindChild( "FloatyBoostTrail" );    if( childTransform )    {        GameObject trail = childTransform.gameObject;        trail.SetActive( true );    }        PlayFlash();}

Yes, its copy-paste code! I still haven't quite learned the discipline to do it right first time.

Now that I need to add a third case its pretty strikingly obvious that doing the same thing three times here is bad (doing it twice was probably bad too, but in cases less trivial than copy-paste vs. functions its not usually so obvious) so I've added a function - actually two because of utility and the confusion that the combination of 'set' and any boolean state causes for the reader/user where they may or may not expect a parameterless version of the function which sets it to true:

private void SetChildActive( string name ){    SetChildActive( name, true );}private void SetChildActive( string name, bool active ){    Transform childTransform = transform.FindChild( name );    if( childTransform )    {        GameObject child = childTransform.gameObject;        child.SetActive( active );    }}

Simple really... when we look at the call site, even with the new addition, the code is clean and more readable.

protected override void OnGo(){    SetChildActive( "Pickup", false );    SetChildActive( "FloatyBoostTrail", true );    SetChildActive( "Aura", true );        PlayFlash();}

More importantly the number of points of failure in the code have decreased - we can no longer break or misuse the code with a bad copy-paste and there are less lines of code to handle when debugging without taking anything much away. This code 'just is' more robust - breaking it is more easily detected because it will break a lot of things and not one - fixing it is also more strongly verified since it can be seen if it works for most, if not all cases, when testing - rather than a single case.

Now that I've done this, looking at that code the null check is not ideal - i'm tempted to take it out because things shouldn't be trying to make non-existent children active - that's the sort of thing I like to have a crash for rather than a silent failure...

private void SetChildActive( string name, bool active ){    Transform childTransform = transform.FindChild( name );    GameObject child = childTransform.gameObject;    child.SetActive( active );}

Still working on leaving...

noreply@blogger.com (Anonymous) — Wed, 04 Dec 2013 14:56:00 +0000

Its just so unimportant... and so little time to migrate the blog.

Why I 'hate' git...

noreply@blogger.com (Anonymous) — Mon, 18 Nov 2013 07:34:00 +0000

Okay, so I don't really hate git as such, but I have mentally categorised as 'unusable software'.

I made a pretty harsh comment to that effect on Hacker News recently, with some overly strong wording and some confusion about things due to my haste and rage, complete with a stab at all of the 'hipsters' who love to downvote things without thinking... and quite deservedly it has been voted down to oblivion, although a lot of it came with some useful and insightful comments.

EDIT: I should make it clear, I really appreciate all the effort that most of the commenters went to in trying to explain how to solve this problem to me. Like the original 'article' there it does help show that the OSS community doesn't always devolve into name-calling and emotional responses - that its an exception rather than the case. Also its nice to know that people want to educate as well as criticise - the two should always come hand in hand, as its somewhat unfair to make criticism without the ability to suggest improvements or fixes.

To help give some context as to why I have a problem with git I'll explain the exact situation I was in and reproduce a trivialised version of the same scenario, explaining problems along the way.

I wanted to revert a merge on the remote server (as well as in my local copy).

This is the essence of the problem I had, and recreating a trivialised version of this in the same way reveals why it was troublesome for me. There is no obviously visible commit for the merge.

To explain what I did to reach this I created a new git repo on Bitbucket (which I highly recommend for Mercurial hosting - but in hindsight, why didn't i use Github?). I followed their example to commit README.md then created a branch 'test', made a single change to the file then merged 'test' into master. After this I stack another change on top.

I did this at the command line except for the branch and merge, which I did using SourceTree (because this is what I did at work at the time - I don't think thats too important).

Now I am left with this picture of the history

There is no obviously visible commit for the merge.

As an aside it also looks like something has altered history - this might not be the case, but the first time I merged using git this was mildly terrifying for me. I expected to see an actual branch and a merge and some kind of changes for the making of the branch and the merge. I shrugged it off at the time because everyone else on the team was using git and didn't seem to think it was a problem so far... this kind of thinking is always a mistake and I should know better.

Now, when it comes time to revert this change how can I do it?

Following my standard practice when I don't know how to do something I asked the team. Nobody knew. This is really the heart of the problem, we were using a tool and we didn't know how to use it. The first time I used mercurial this was something that I learned how to do on a test repository, because it seemed like a good idea to learn the tool in a safe environment before entrusting it with my code (which I didn't do for a long time after that anyway...).

My next stop was the man page for git revert, it seemed like the operation I wanted to do, I just needed some way to specify what to revert. Now, it seems to want a 'commit' parameter so I look at its suggestion of the git-revisions man page too...

I read through that somewhat at the time, but gave up quickly because it seemed to only tell me how to specify a commit, not how to find the one I was looking for (this was a mistake too - reading it now I have learned that there is such a thing as MERGE_HEAD, although I'm not sure it would have helped) and looked at git rev-list also pointed to on that page.

I ran git rev-list HEAD because it seemed like the right way to find the commit. It lists three commit hashes:

27376d9b1ca61dbcb1cb3c35c9697ac2e7bc894d

a5a1238b9d1e59b80d0738e983af6695254d1077

037c6bb92392e19e9fc2f73ed4f73e1da522afef

These are the commits I can already see in SourceTree. Clearly I am out of my depth or there is something fundamentally wrong here. Maybe SourceTree can help me somehow? So I spend some time investigating its UI and find nothing that is obviously helpful.

The next stop was Google with the search string "revert merge in git" or very similar. I don't think I can go and see what the exact search results at the time were but I think the current ones are probably quite indicative...

So, doing the search today I find several results that look promising:

http://stackoverflow.com/questions/2389361/undo-a-git-merge - okay, so this isn't my situation..
http://stackoverflow.com/questions/11722533/git-rollback-a-merge - and again...
http://git-scm.com/blog/2010/03/02/undoing-merges.html - this looks promising

Now, to me we were already at 'serious UX bug' when I couldn't see a commit for my merge. The length of this page and the number of diagrams reinforces my belief that this tool was made by developers with no care for the end user. This might sound harsh, but its extremely common for development tools - they are made by programmers for programmers, and programmers easily forget just how bad programmers can be - including themselves. This biases me further against git.

Anyway reading through the first example solution it looks just like my problem. I don't want to lose the changes on top of the branch merge so this should work, but as I read further it becomes obvious that I missed something - well maybe I can muddle through if I just rewind back to the first revision on master. No wait... those arrows are backwards! RAGE! Who are these people?!?! etc. Gah.

So I read the thing knowing that the arrows are backwards - this is not my situation at all, I don't want to remove a change from just before a merge (but its useful to know that I can at least). Then suddenly I click that these diagrams are representing merges by commits. I can't find a commit for my merge - and that was the problem I was hoping to resolve here.

The next example starts out much more promising - it actually does describe my situation. However, the opening statement fills me with dread.

Now you either have to revert one of the merges, or go back, remerge and then cherry-pick the remaining changes again (C9 and C10 in this case), which is confusing and difficult, especially if there are a lot of commits after those merges.

I think 'if this guy thinks this is confusing and difficult then I am probably boned'. There were quite a lot of changes on top of the merge - unlike in my simplified example. I read through anyway but, this also wants me to be able to identify the merge commit as well.

All that is left is a slightly confusing paragraph and comment about git merge --no-ff... right well, maybe I should have used that when I did my merge. No help to me now.

What to do next? At this point I've spent too much time on what shouldn't even be a problem. I unpick the changes myself with diff tools and memory (because it was more than one commit and I can't see which ones are from the original branch in SourceTree or Bitbucket) and build a 'anti-merge' commit myself. Maybe there was an easier way to do this - my experience to this point was telling me that the documentation was not going to help me because it seemed to be missing critical information...

Once done and our immediate concern of shipping our product was resolved I moved the repo to Mercurial.

Now, maybe a lot of this is my own fault, but this is considerably more effort than I have needed to make with any other source control solution (I have used most of the other popular ones - cvs, svn, p4, hg) where the built in help at the command line was more than adequate to learn how to solve this problem.

Maybe I am just deluded or wrong - but I doubt it - this is a horrible user experience and frankly, it makes the tool dangerous - especially if you are confident with source control and having used multiple different solutions in the past. I think everyone was quite happy to 'make the mistake' of using a tool they didn't know because it was so popular, it couldn't possibly be worse than all of the other tools we've ever used? Could it?

Well it is.

One button to rule them all...

noreply@blogger.com (Anonymous) — Sat, 12 Oct 2013 19:06:00 +0000

Haven't seen one of these in years. Is this really something we are expected to do ever?

Never been a fan of this sort of thing... even back in the 90s when there was something resembling an excuse for programmers to be that awful at their jobs. I get the financial implications and not wanting to spend time on installers but I've always been of the opinion that they are the first exposure of the user to your product - you want to get it right because, traditionally, first impressions matter.

Other people care about this too thankfully. Relatively recently I commented on the awesomeness of the Ubuntu install process. More and more installers seem to be moving towards silent and painless installs. I quite like the Mac install process - but even that could be slicker, the drag and drop takes a veritable eternity and a colossal effort over a single, or even double click. Why on Earth do I need to press more than one button if I don't need to provide any information for the installer?

Perhaps there should be some rule 'single actions should require single triggers'...

This is a generalisation of the spirit behind one of Joel Spolsky's 'Joel Test' questions...

2. Can you make a build in one step?

I spent a little while taking this to the extreme recently, but even before discovering Joel's blog I managed to intuit my own way to a similar conclusion.

A few years back I clocked that needing to install or build dependencies is not only a massive headache (yes, Linux fanboys an enormous, colossal waste of my time) but it can be avoided if you make your project properly by checking-in dependencies in an appropriate fashion. (btw, MS, Apple, Google, can you make yours right so that users don't pick up your filthy habits? the damage done by that source/headers split in VS is colossal - for example)

So for a long time I've always been able to get latest and press build and have it run without any messing about that is avoidable. This is partly why I have such a passionate hatred for the 'bad default bug' in VS that it always runs out of $(ProjectDir) and not the only possible sensible default of $(TargetDir) which emulates the launch behaviour of every piece of commercial software I have ever touched and would allow me to check-out latest /and/ build with one click. Don't get me wrong, it makes me mad that such an obvious bug does not get fixed, or that any one who decided $(ProjectDir) was sensible is employed in a job that requires thinking... but it actually prevents me from doing something valuable, which is otherwise entirely possible. I can actually script this away by violating politeness but I refuse to on principle...

Amazingly Mac's are less rubbish - although there is a different snag there if you want a one click 'get latest then build it on this clean and unused machine' - installing xcode. Now, I'm not a great Apple user nor a Mac fanboy so I do not know how to install Xcode non-interactively - all I know is that "Xcode install non-interactive" as a Google search string gives me nothing useful. Is there a user manual for the Mac like there is for the iPhone? (...and how do Apple manage to make the only products I ever want a manual for!)

Anyway rant over. I can probably sum this up with the obvious and seemingly redundant statement: Unnecessary user interaction is not required.

I will leave blogger soon (!)

noreply@blogger.com (Anonymous) — Mon, 07 Oct 2013 06:55:00 +0000

After realising that I can't see or reply to comment threads in the layout I use, and generally things like having to delete posts because they break the page layout... I'm sick of it. Time to go.

I will set up some redirects and replicate everything that is already here so as to avoid creating a load of dead links on the web.

I hate to say it Blogger just doesn't provide a good enough service for me. There are much better free alternatives and I will be experimenting with them to select a new platform over the coming week...

I have spectacularly low standards. Blogger should feel ashamed of their ineptitude... :/

SketchUp is awesome

noreply@blogger.com (Anonymous) — Sat, 05 Oct 2013 14:51:00 +0000

Just a little reminder after working on some 3D assets recently...

Also, hint at all the other ridiculous 3d modelling software - please steal their input mechanism - its a million times better than all of yours. :P

Sure it lacks all the cool tools of 3DS or Maya, but for actually making raw geometry its infinitely better IMO.

Check out this low poly mesh for some project I am working on. Whilst I'm sure I could have made this with other tools, fiddling with the geometry around the joins to reduce the polycount is a lot easier for me when I can easily edit vertices and edges in the SketchUp style... building construction lines then cutting at midpoints or intervals etc. probably doesn't appeal to most art types though I'm sure.

... and before anyone says it, that door isn't going to open out through the sides of the octagonal tube, but rather the toothed bits will slide along the other surface to reveal a gap. My hope is that it will work without looking stupid... :)

Mini Moon Goon Matchup Mayhem

noreply@blogger.com (Anonymous) — Wed, 02 Oct 2013 10:45:00 +0000

Worked on this game recently and now its shipped (in Canada):

https://itunes.apple.com/ca/app/matchup-mayhem/id681228541?mt=8

Check it out. :)

C++ once again more popular than Objective-C

noreply@blogger.com (Anonymous) — Fri, 27 Sep 2013 11:32:00 +0000

At least according to the TIOBE programming language index, C++ is once again more popular than Objective-C...

I wonder if this is app developers optimising out Objective-C wherever its unnecessary to use it? Although its a fairly naive strategy for optimisation, it is valid in my experience.

Simple changes like removing NSDictionaries where possible and using some e.g. stl::unordered_map, can drastically improve performance simply because the 'messaging', i.e. member function calling mechanism, in Objective-C is rather heavyweight compared to a C/C++ function call, which (except in the cases of virtual member functions and virtual inheritance) is near identical with the x86 CALL instruction, which is equivalent to a move and an unconditional branch - instructions supported by every CPU.

This case of the unordered_map lookup is especially illuminating because the underlying implementation of the message call has worse runtime characteristics than doing a lookup in the unordered_map - so before it even starts a look up NSDictionary is crippled by its run-time environment. This is entirely due to the requirement of dynamic dispatch, that the function being called can be decided at run-time. C or C++ functions use static dispatch - the address of its code is known at compile-time (unless you are fool enough to turn on the utterly redundant and needlessly slow RTTI feature).

It is possible to optimise around this within the scope of Objective-C and its run-time library, but by using long winded boilerplate-y API functions to reduce the amount of lookups being done... (hint: can we not have a language feature that implements something like thiscall? I can write equivalent C code and get the same performance benefit already... syntactic sugar is all we need)

Of course in most cases apps don't do anywhere near enough stuff often enough to need to care about this, and performance critical lookups can be cached which is often a much more significant win than making the lookups themselves any faster...

No 3. search result for "reinventing the wheel" on Google is...

noreply@blogger.com (Anonymous) — Thu, 26 Sep 2013 18:30:00 +0000

... this blog. (!)

Maybe this is because Google own Blogger, but I appear to be as far up this page of search results as I would imagine is reasonable. Wikipedia and the Free Dictionary probably deserve those top two spots quite a lot... I'm not sure I should be beating the company called 'Reinventing the Wheel' though.

Maybe this is Google tailoring the search results to me though? I'd be interested to know if anybody else sees this same result...

https://www.google.co.uk#q=reinventing+the+wheel

Someone should sell SEO to the alloy wheel refurbishment company with the same name as this blog... quick!

Also when did Google stop responding to ?q=search+string ? Or is this just some weirdness in chrome that I now need to use # to get my desired result?

Nevermind, I am happy whatever the case... I think.

Plan It Out

noreply@blogger.com (Anonymous) — Wed, 25 Sep 2013 09:49:00 +0000

Sister company to my employer Aqua Moon Games has just launched their new SaaS product for beta. Its an all-in-one planning, time and project management package handling many common day-to-day tasks of running a business.

If this is your kind of thing I'd recommend checking it out...

There is a blog post about it all here: http://nxtds.com/blog/PlanItOut.com-has-arrived

You can sign up for the beta here: http://www.planitout.com/

Windows 8 Mail Fail

noreply@blogger.com (Anonymous) — Mon, 26 Aug 2013 18:29:00 +0000

Winodws 8's built-in metro style mail app was working just fine, then one day it started crashing on launch making it utterly useless.

Crashing on launch.

I just want to say that again so that it is clear I did not make a typo - because its a very special class of bug this one. Class 'A'. In fact if there were such a thing as a triple-A bug this would be it...

Microsoft deserve an extra special well done for this one... god knows if they will find time to fix it between making their sample code actually compile, fixing 'exclude file from build' in Visual Studio or finishing the sorely missing Speech API support (what did you guys need to change, really? lets be perfectly honest...). Maybe they are really busy with xbone as well... almost certainly fixing the same class of idiot bugs we see in Windows 8.

I love Windows 8 in general, but ffs, if your mail app crashes on launch then there is something seriously wrong... I for one would have been happier with Outlook Express again - its a superior product in every way except the visual style.

</rant>

Loading Unity3D asset bundles asynchronously in iOS

noreply@blogger.com (Anonymous) — Mon, 12 Aug 2013 15:28:00 +0000

I recently got snagged trying to load asset bundles asynchronously on iOS. Like every 'good' 'cross-platform' engine the same code did not actually work across platforms. After sifting through a page of useless google results to searches like "asset bundle iOS" and "asset bundle async load iOS" (https://www.google.co.uk/search?q=unity+asset+bundle+async+load+ios)

I was eventually able to solve this problem based on information I found here: http://stackoverflow.com/questions/8246917/how-to-access-unity-assets-natively-on-android-or-iphone/8298046#8298046 which suggests the existence of a special path for streaming assets out of...

Most of the easy to find solutions were terrible and I didn't follow them, but I feel I should do my part to contribute a nice solution that doesn't involve disgusting hackery like manually altering your xcode project or suffering stalls mid game for no good reason...

Once your asset bundle is in the correct Assets/StreamingAssets path you can load it with something like this:

 string path = "file://" + Application.streamingAssetsPath + "/Bundles/" + name + "_" + BundlePlatform.Current + ".unity3d";  
 WWW loader = WWW.LoadFromCacheOrDownload( path, 0 );

Note that I place my bundles in Assets/StreamingAssets/Bundles in order for this to work

Now... the magical BundlePlatform.Current I have in there is because there seems to have been little or no consideration for the platform specific build process... or I just haven't found the right bit of obscure documentation to make it work nicely yet. My solution is to name the file differently per platform on export, because trying to load a Win32 or MacOS X bundle on iOS won't work...

Anyway once you have the loader you can use your revolting yield keyword or a beautiful loading queue to manage the timing of loading assets out of the bundles once they are in memory... hope this helps. :)

Why is my formatting screwed on the 'Unappreciated' blog post?

noreply@blogger.com (Anonymous) — Wed, 26 Jun 2013 19:05:00 +0000

I made it with draft.blogger.com using only the compose feature. Nothing special. The formatting is screwed up and I can't seem to fix it. Annoying. I will have to bury it with small and pointless posts.... perhaps.

Dear Visual Studio dev team...

noreply@blogger.com (Anonymous) — Fri, 14 Jun 2013 21:54:00 +0000

$(TargetDir) is the only correct default for the working directory preference in a project, please fix this utterly stupid bug.

$(ProjectDir) is not just wrong, it encourages bad practice and is confusing.

Blinn specular hack is not faster

noreply@blogger.com (Anonymous) — Sun, 26 May 2013 14:27:00 +0000

I've heard that it looks closer to the real deal a few times, but that half-angle approximation has a serious problem - it lets reflections through to the other side. Nowadays it is not a performance improvement either because we have good dot and multiply-add instructions on hardware.

Now, this is not a problem if you have self-shadowing, but otherwise quit prematurely optimising and do it right. :)

Kerbal Space Program

noreply@blogger.com (Anonymous) — Sat, 25 May 2013 08:55:00 +0000

I was recently introduced to Kerbal Space Program - a space simulator game that is still under active development. I'd highly recommend trying it out if you are a fan of space or physics simulation games. Considering that its still in 'alpha' and the main chunk of the game is an open world with no objectives or scripted gameplay, its surprisingly good fun...

Ever since the days of MS Space Simulator I've wanted to make a game like this... but I think they have done a better job than I would have. The rendering is fairly standard, but stylised in a cartoony fashion which makes it seem that bit better than it really is. The solar system they provide is a much simplified and slightly different version of our own, but there are plenty of things to see all the same.

The vehicle construction is its own game, and the possibilities they allow you to explore are numerous. Its possible to build planes and rovers as well as rockets, so a flying rocket powered car isn't out of the question. Rockets can be built with multiple stages and various parts can be extended or explosively separated which is surprisingly fun to set-up and watch. Its even possible to dock components together in space and build your own space station...

There are also a load of community created mods available for the game adding all kinds of parts and scenarios to the game. You can provide a .dll as well as art assets for a mod, so the possibilities there are virtually unbounded.

Its not all good though - the game is still an alpha version and it really shows in places. The physics is altered by the time-warp functionality in ways that can be frustrating at times... sometimes an otherwise stable spacecraft will tear itself apart when time is sped up. There is some weirdness with the controls as well - driving the rovers around was a pain until I realised I could use docking mode to stop WASD also controlling pitch and yaw. I think this would be helped with a tutorial or two though - along with the other frustrating elements of the game - a lot of which boil down to it not being obvious what to do e.g. knowing that you must provide electricity for automated command modules or that the 'ASAS' component will make it possible to use the auto-stabilisation by pressing 'T' - vital if you don't want to have to painstakingly guide your rockets during their launches.

Performance is not great either - building large rockets reduces the framerate to a crawl, even on a high-end machine and when a planet fills your screen the framerate can plummet. The load time is appallingly long, and so is exiting the game. There is an annoying 'hitch' when first starting a mission - I think framerate is fine, it just refuses to let you interact for a second or two which is mildly infuriating. These are the kind of problems I expect will be fixed as the game is developed though - either that or are down to Unity and its general shoddiness when it comes to performance.

My main gripe is the price tag. £17 seems a little steep for something so completely unfinished - and even if it was finished... I'm of the opinion that the wannabe AAA titles who expect you to fork over £35 or so aren't even worth that much any more... this feels like £5 worth of game, although I expect that will change in the future when they add more missions and the career mode.

Although I seem to have found more negative points than bad, the game is really, really, REALLY good and I'd highly recommend it. The fun to be had with the physics model and the open environment is probably limitless - and if you are a programmer or artist there is even more fun to be had with modifications.

I did an art!

noreply@blogger.com (Anonymous) — Sat, 25 May 2013 07:19:00 +0000

So, I decided to put together a little mod for Kerbal Space Program - since I wanted a UK flag for the new flag feature in v0.20 I decided I might as well find some sources for some national flags and package them up and stick them on Kerbal Space Port.

It was pretty straightforward art work - nothing actually creative or involving mad Photoshop skills - just some clipping, resizing and minor retouching based on copyright-free source images found with Google image search. I think I've managed to preserve all of the important details, such as the text on the Brazilian flag and the detail on the coat of arms for Spain.

You can find the addon here: http://kerbalspaceport.com/international-flag-pack-2/

Boilerplate code

noreply@blogger.com (Anonymous) — Wed, 15 May 2013 12:53:00 +0000

Boilerplate code enforced by APIs is a problem... it saddens me to see that something as cool and exciting as shaders have even been reduced to it now. Why is there not a default shader that does the old fixed-function pipeline, but built in to the API?

Its not hard to provide defaults, its also not hard to group your colossal lists of function parameters into structs - because then you might realise that you are solving the problem poorly by not using objects or functions or any of the other modern facilities we have to prevent us from needing to ever deal with this kind of garbage code... My OpenGL or DirectX initialisation code - I am not by any means the best programmer in the world, but the way in which these things have been implemented is appalling. You know how to get it right? You make your function prototypes look like this and then the programmer doesn't have to worry about the implementation:

void glInit( void );

void DXInit( void );

NOT HARD!!!

With sensible defaults this serves most purposes and lowers the barrier to entry considerably. We have overloading, but we can do things the C style too... so if you want to expose those more powerful options, like choosing your depth/stencil formats or using fullscreen, or whatever else then you provide new functions.

void glInitFullscreenMaxRes( void ); // an extremely common case
void glInitEx( struct SomeStructOfParametersWhichAreMostlyOptional );

This is not even close to being 'advanced' programming or design - this is the kind of thing that most competent programmers just do without thinking...

Its even worse away from sane platforms like Windows - Apple and Google seem intent to allow us not to write good clean native code, but force us to write some boilerplate in 'alien' languages like Java and Objective-C. Huge chunks of API are dedicated purely to facilitating the piles and piles of needed boilerplate NSValue, NSString, NSRange etc. JNI is much more long winded than necessary as well - how many variables and function calls should it really take to call a static public member function on an object?

Blah!

Exceptions - they are what they say on the tin

noreply@blogger.com (Anonymous) — Fri, 10 May 2013 09:07:00 +0000

... meant for handling the most exceptional of cases when you can't handle the problem yourself.

(TL;DR: Exceptions are evil. Never use them, if you can avoid them.)

Using exceptions in place of a return code is just as bad as trying to use return codes to handle exceptional cases...

If I'm throwing an exception I would hope that some horrible dialog box like this would appear - its an emergency escape that saves me having to write a pile of code to carefully and correctly cleanup the resources used by execution. Or to escape a situation where its not even possible to know what I should cleanup (without writing dedicated code... but actually the OS already has this information)

In practice I never throw an exception - any time where I would write 'throw' I should be handling the case properly because it is expected and not exceptional. In the genuine cases where I really do want to throw an exception the OS does it for me already. Its almost as if it was designed that way... so we can get indecipherable message boxes and Windows can deflect the blame from our shoddy code with its robust error handling mechanisms.

I once took a look at the C++ FAQ for 'guidance' - its the kind of FAQ entry that justifies the FQA:

[17.1] What are some ways try / catch / throw can improve software quality?

By eliminating one of the reasons for if statements.

The commonly used alternative to try / catch / throw is to return a return code (sometimes called an error code) that the caller explicitly tests via some conditional statement such as if. For example, printf(), scanf() and malloc() work this way: the caller is supposed to test the return value to see if the function succeeded.

Although the return code technique is sometimes the most appropriate error handling technique, there are some nasty side effects to adding unnecessary if statements:

Degrade quality: It is well known that conditional statements are approximately ten times more likely to contain errors than any other kind of statement. So all other things being equal, if you can eliminate conditionals / conditional statements from your code, you will likely have more robust code.

Slow down time-to-market: Since conditional statements are branch points which are related to the number of test cases that are needed for white-box testing, unnecessary conditional statements increase the amount of time that needs to be devoted to testing. Basically if you don't exercise every branch point, there will be instructions in your code that will never have been executed under test conditions until they are seen by your users/customers. That's bad.

Increase development cost: Bug finding, bug fixing, and testing are all increased by unnecessary control flow complexity.

So compared to error reporting via return-codes and if, using try / catch / throw is likely to result in code that has fewer bugs, is less expensive to develop, and has faster time-to-market. Of course if your organization doesn't have any experiential knowledge of try / catch / throw, you might want to use it on a toy project first just to make sure you know what you're doing — you should always get used to a weapon on the firing range before you bring it to the front lines of a shooting war.

Eliminating if statements? Seriously? So instead of an if statement we use an extremely difficult to master language feature with a heavy performance penalty? Maybe the C++ FQA speaks more sense...

This is cargo cult programming. Conditional statements are error-prone because they are used to handle complicated scenarios, where an action can result in many different outcomes, which affect the next actions. In order to make errors less probable, one has to simplify the model of the desired behavior of the software. The problem is the complexity that leads to if statements, not the if keyword, and using different keywords is not going to solve the problem by itself.

Exceptions are supposed to simplify the error handling model based on the assumption that in most cases, a function that detected an error can't handle it, and has to propagate it to the caller. Finally, a "high-level" enough caller is reached and actually makes a decision (pops up an error message, tries a different action, etc.).

Despite its promises, this approach has inherent problems. There's a "social" problem - with exceptions, people are not aware of the different errors that may happen in the code because most of the code doesn't deal with errors. And when people rarely think about a particular aspect of an application, ultimately this aspect is unlikely to be handled well. There's a more "technical" problem - functions essentially doing nothing upon error except for propagating errors to the caller still can't be completely unaware of errors. That's because they may need to release the resources they acquired before returning to the caller, which may lead tomore errors, which must also be handled. Finally, in practice exception support has run-time overhead, and very significant code size overhead, even if exceptions are never raised at run time, and even if they are not mentioned in your code. C++ devotees may claim otherwise; you can check by compiling your code with and without exception support (if your compiler doesn't have such a flag, compile code as C and as C++ instead). This is unacceptable in resource-constrained systems.

Still, in many cases, the benefits of exceptions are more important than their problems. For example, if your language manages memory automatically, the problem of releasing acquired resources becomes a small one (you only have to care about files, etc., which are a tiny part of the "resources" used by a program - most of the "resources" are memory). If your language throws exceptions when you violate its rules (for example, upon out-of-bounds array access), these exceptions will help you find lots of bugs, especially if you can get the call stack from an exception. If the purpose of an application is automated testing, and/or it's used as a quick-and-dirty internal tool as opposed to a product for an end user, this kind of exceptions is all you need to handle errors of almost all kinds. In some languages, you can even resume the execution from the point where the exception was raised after fixing the problem at the point where it was caught.

C++ exceptions offer none of these features. "Exception-safe" C++ code can't handle errors which happen when it tries to release resources; "exception-unsafe" C++ code will leak resources, most frequently memory; and once you throw an exception, the call stack is lost. This means that even separating your code to several processes and executing code like *(int*)0 = 0; upon error is a better way to handle errors than C++ exceptions: at least the memory is going to be reclaimed by the operating system, and you can typically have it save a snapshot of the process, so that you can open it in a debugger and see where the error happened. A recommendation to "ban" exceptions is probably over the edge, but think a lot before using C++ exceptions, or a feature that implicitly depends on them, such as constructors and overloaded operators, which have no other way to report an error. What C++ calls "exceptions" is as unlikely to give you the benefits people get from exceptions in other languages as what C++ calls "classes" is unlikely to give you the benefits of OO.

Visual Basic 6 was one of the 'mythical' languages where you could continue from an exception after fixing the bug

I disagree that exceptions are especially useful /ever/ beyond unexpected scenarios like writing to memory you didn't allocate... there is a lot of truth in here though, I will sum up.

Exceptions destroy your call stack
Exceptions have a severe run-time penalty both in memory footprint and execution time
Exceptions introduce the chance for subtle bugs, e.g. memory leaks because they break the 'locality of code' that is otherwise present when considering program flow

I would add:

Uncaught exceptions produce scary dialogs for the end user
If you are catching a specific exception you are effectively abusing a goto like feature and producing a disgusting code structure to work with for all of the same reasons, with the added bonus that your code has to handle difficult to think of cases as well
You replace the use of a standard, simple language feature (if-else, switch - branching) with something that breaks the standard notation for flow, is platform specific and hides a very complicated implementation (try, catch( ... ), finally, throw - stack unwinding, goto style jumping, CPU and OS specific implementations, behaviour which can vary based on the day of the week [well, very many arbitrary factors, many of which change constantly]). Its more than just syntactic sugar and keyword juggling...
They are the only way to report errors from some functions - personally I think that these functions should never be failing - otherwise it probably shouldn't be a constructor, or overloaded operator - more so, you can use asserts and debug traces to report these errors in a much more useful fashion that doesn't destroy your call stack or obscure the original point of failure.

To be honest though I have used them, here is the list of reasons why, and why all of these reasons are wrong or avoidable:

Detecting support for obscure instructions on Intel CPUs by catching the unrecognised instruction exception

This was a bad idea, I know better now - CPUID instructions are plenty good

Because my workplace used them as their error handling mechanism

This was stupid but practical - I could have improved the code by replacing them. They wound up being used as for loops, do-while, switch statements and so-on.

Because MS force my hand with their terrible language extensions and runtime libraries.

Not much I can do about that... it amazes me that MS programmers can't do a better job than crap like C++/Cx, .NET or other hand tying contrivances that introduce more problems than they solve for me because I wasn't bad enough at my job to have the 'original' problems

Exceptions are evil. Never use them, if you can avoid them.

Star Chart raytracing articles

noreply@blogger.com (Anonymous) — Wed, 24 Apr 2013 15:58:00 +0000

Some articles in Intel Software Adrenaline:

http://software.intel.com/sites/billboard/article/star-chart-developer-diary-part-1

http://software.intel.com/sites/billboard/article/star-chart-developer-diary-part-2

The joy of other people's tools

noreply@blogger.com (Anonymous) — Thu, 11 Apr 2013 16:23:00 +0000

I love pre-made tools, they have been saving me pointless programming effort for almost 15 years.

I recently discovered Tiled, which I think is going to become my Radiant for 2D. It has some quirks and niggles, but look at it, its a beautiful tool - I'm not spending all the time making an inferior version so I can get a worse quality result... better to make one or two slightly distasteful, but well hidden fudges than write a whole tool.

Dear Chrome and other broswers

noreply@blogger.com (Anonymous) — Sat, 06 Apr 2013 16:56:00 +0000

If I click a link and hold down, can you please begin a selection instead of doing whatever currently happens.

This is natural behaviour - it is not only how I have observed many users frustratedly trying to copy text - its something that with the knowledge that it will never work I still naturally try and do. The ability to drag the link away onto some other app is a feature that I never use. I constantly have to copy-paste text comprising or inside of a hyperlink. If you want to maintain the link dragging behaviour as well this is perfectly possible with a little thought and some sensible thresholds.

Thank you.

Tensors and Einstein notation vs. matrices...

noreply@blogger.com (Anonymous) — Sat, 06 Apr 2013 00:14:00 +0000

I like to think that is 'common sense' that matrices are horrible things to work with. The first and last mathematical construct I have encountered where I can't derive the rules from first principles because they are fantastically 'non-obvious' and ambiguous. The thing that got me to remember matrix multiplication, how it works, and how to derive it meaningfully from scratch was learning about tensors and discovering Einstein notation.

Here is a matrix multiplication to prove my point - expanding the terms was too much of a chore for me to stomach so I use some ellipses to imply the continued expansion. The first line here is how we write this in Einstein notation. The second line is the traditional 'rows by columns' approach - or we can view it as an expansion of the first line.

Einstein notation translates well to computer programs, it is a succinct way of inserting for loops into mathematical expressions. When I write a generic n dimensional matrix multiply I use this approach in code - it reads well.

for( int i = 0; i < d; ++i )
{
    for( int j = 0; j < d; ++j )
    {
        C[ i ][ j ] = 0;
        for( int k = 0; k < d; ++k )
        {
            C[ i ][ j ] += A[ i ][ k ] * B[ k ][ j ];
        }
    }
}

Instead of remembering matrix multiplication as 'rows by columns', 'columns by rows' or whatever the rule is I could never remember (because it has an exact dual you can follow with non-obvious consequences) I can remember instead to contract across the middle... its unambiguous and also enlightening about the deeper significance of transformation matrices.

The fact that a matrix can carry out a transformation is often treated as a mathematical convenience. I've never been able to swallow this because I find matrices to be manifestly inconvenient. A little understanding about tensors, and about coordinate axes as I have described before, removes all of the magic and mystery. I discovered not only that matrices really do hide the truth of what is happening, but that what really happens is easier to understand and calculate with - to the point where it explains transformation matrices and we can also develop a much deeper understanding of geometry, transformations and vectors in the most general cases...