What should a function do when it fails? There are two schools for this - the “throw an exception” school and the “return an error value” school.

But which of these is the correct approach?

Some background

Back in ye olden times there were no exceptions. Languages like C are still being used today. In such languages the choice is quite easy to make.

However, what about languages that do support exceptions? Should you strive to use the language’s features to their fullest, and always throw an exception? Are error returns just relics?

If you listen to people talk about this, it often turns into a debate about what they like. If you grew up with languages that had no exceptions, chances are you still prefer return codes. Similarly, if you used a lot of Java or other exceptional language, you might end up flaming return codes.

However, I think both of them deserve merit and have their uses.

Basics

As you may have heard, exceptions are for exceptional conditions.

But what is an exceptional condition? What isn’t?

Let’s take an example: Your application attempts to load a resource file - for example the configuration settings for your database - and it’s missing.

Is this an exceptional condition? Maybe. It depends on one thing: Is it normal for it to be missing, or should the file always be there?

function loadConfiguration() {
  var file = open('configuration.ini')
 
  if(exists(file)) {
    read(file)
  }
  else {
    throw "Configuration file is missing"
  }
}

So this pseudo-code could be a simplified configuration loading function. In this case the configuration file has to exist - let’s say it’s some internal file.

But what if the file is something that contains settings the user has selected? In that case it might be perfectly fine for the file to not exist. The user may not have added any custom settings and as such, it’s normal for the file to be missing. In this case our function could look like this:

function tryLoadConfiguration() {
  var file = open('configuration.ini')
 
  if(exists(file)) {
    read(file)
    return true
  }
  else {
    return false
  }
}

Note that I also changed the name of the function a bit. It may be a good idea to try indicating that the function will be returning a value - It tries to do it, so the name is more expressive of the permissive nature and that it’ll return whether it succeeded or not.

Other examples

Other good examples are various string related functions. In many languages, there exists a function to determine whether a string contains another string, and this function usually return -1 on failure.

It’s normal for this function to not succeed, afterall, we are using it to test whether or not the condition is met.

There are also more “pure” arguments for either side. Exceptions are essentially objects, so they can convey more information than just the fact that things went wrong. On the other hand, an exception can be thrown deep in the code but appear on the surface unless caught early enough. This could make tracking the origin and cause of the exception more difficult.

Ned Batcheler has some good reasons for exceptions compared to error returns on his blog in addition to these. However, is this all?

Deeper considerations

It’s not all just talk about exceptional conditions or technological preferences.

An often forgotten fact is application stability. If you are writing critical code that should be as stable as possible, what should you use? Return values.

An uncaught exception can bring down a whole application. An unhandled return code might not really cause anything at all. Sometimes it’s important to consider this factor too.

There are probably other things like this too. If you know any more examples of more special things to take into account, post a comment please.

Conclusion

We can say that exceptions can be convenient. We can also say you can easily use exceptions too much, and that how to decide whether to use them or return codes is difficult. It comes with experience, but I hope this post sparked some ideas for you. Damien Katz’s blog also has a (long, long) post on exceptions, error codes and reliability which is kind of related.

When do you think it’s a good idea to use exceptions? Return values? How do you decide? Share in the comments!

Different platforms are developed by different groups, each with their own mindsets and ways of doing things. If you take the time to step outside your own world, you might be able to learn new ways of doing stuff you never would have if you stuck to the familiar toolsets of your current platform. Take PHP and ASP, for example. Although very similar in nature, much of the “nitty gritty” implementation details are considerably different.

It’s actually in a developer’s best interests to know the best of both worlds. The Internet is heavily intertwined, with many companies seeking out cloud hosting solutions while integrating more than one vendor’s product. Besides, whether you like it or not, Microsoft maintains a huge presence in the computing world, and they aren’t going anywhere anytime soon. Plus with today’s mergers and acquisitions, many companies are no longer homogeneous with their technologies even if they originally started out that way. Knowing more than one technology would put you in a good career position for interfacing and merging new in-house technologies.

In today’s lackluster economy, what’s more important to you anyway: platform snobbery or job security? Let’s say you’re working in a code shop that’s totally dependent upon some open source LAMP flavor. But one day that place, like many dot coms of recent past, goes belly-up. It sure would be nice to be able to immediately jump ship to another place dependent mostly on ASP.NET, wouldn’t it?

So break out of the mold. Stop thinking whatever IDE you’re using is the best thing since pre-sliced bagels. Besides, “real” programmers don’t cling do their toolset. Real programmers don’t brag about how good they are at using “x” text editor or “y” compiler. Real programmers aren’t clueless like the recruiters who land them their jobs, mindlessly performing keyword scanning for the latest technology buzzwords. Real programmers are supposed to know how to determine/evaluate requirements, design systems, and write the code necessary for the task at hand, finding the right tools for the job instead of turning every problem into a nail for their only hammer.

Disclaimer: This is a sponsored post not written by the blogger.

Please leave your thoughts on this, and whether you found it an interesting read in the comments. I wanted to publish this one to see how it works out. Depending on your comments I may or may not run more sponsored articles.

I recently saw an article about a new computer aimed at “computer illiterate” users, the Alex PC. Elsewhere on the ‘net, people were arguing about whether or not trying to make it easy for “non-geeks” to use computers and internet was a good idea or not, which provoked some thoughts which I thought I’d share.

Why not?

If you think about it, why would it be a bad thing?

Well, I’m sure we’ve all helped <insert someone who knows very little about computers here> - some of us may even be the go-to guy for all family and cousins for computer problems (thank god I’m not) - and let’s face it, it’s not always very fun; It can be very frustrating as a matter of fact.

That’s not all though. Why do botnets grow, despite all the measures we take to protect our computers? Yep, a lot of these are most likely computers from people who don’t understand them very well. Security issues such as this and phishing can be major concerns unless you understand things correctly (and even if you do things can slip past you)

So we can safely say that uneducated users can fall prey to various things on the internet, and computer problems that fall on the shoulders of others aren’t always fun to work out.

I can’t find the discussion at the moment, but a lot of Linux people (the Alex PC uses Linux) were also saying the same - If you can’t use computers, you shouldn’t, and computer makers shouldn’t cater to them.

Apple has figured it out

This may come as a bit of a surprise from me, as I’m not exactly the first person to praise Apple’s products. I often call their stuff “fashion gadgets”, in good humor of course

Especially after they unveiled the iPad I was pretty quick to join the ranks of people who said it was a pointless, pointless device, with tons of better alternatives available.

But that’s only if you think of it as a computer’ish, tablet PC or smartphone type.

If you think of the iPad as a beginning of something everyday-like, such as a TV, but for internet use etc., it may suddenly start making some sense.

For a computer for computer illiterate to work, it must not be a computer.

Part of the problem could be that some people are indeed afraid of using computers. That’s why the device shouldn’t be marketed as one, and that’s why I say Apple may have nailed this with the iPad.

Not a computer?

When you think of everyday appliances that even children and the elderly can use, such as TV and radio, what do they share?

They are both much less complex to operate than a computer.

To watch TV, you just turn it on. It turns on usually pretty quick, and that’s it. It’s on, it’s working. You don’t need to do anything else.

What happens when you have problems with a TV? You turn it off and back on, which usually fixes it. If the image doesn’t show, you press a button to have it automatically search for channels and so on.

When you turn on a computer, it boots up. You get a few screens, which each in turn tell you to press a key if you want to do thing X (such as go to BIOS). Then it takes some more time. You wait, probably input a username and a password, wait, and now you get to the desktop.

You probably know you don’t want to go to the BIOS or the Windows Memory Diagnostic tool on bootup, but someone who doesn’t know what they are doesn’t know whether they should be pressing the keys or not.

I could go on about the things that happen after you’re in the OS, but I think you get the point - just starting a computer can be an annoying and confusing experience.

How does a non-computer computer work?

Let’s take all the cues from the appliances that are in everyday use: Make it boot up in seconds, not tens of seconds and make it simpler.

I haven’t used an iPad, but I think it (or a similar device) could fit the bill pretty nicely here.

You start it, it boots up (hopefully very quickly) and you get the applications. In this way, the iPhone OS works perfectly for it, as it abstracts things like applications and file storage - Things just are somewhere and they are always presented in a similar fashion.

When the device or application crashes, the user just reboots it. That should fix it. It should not require understanding cryptic error messages or require changing a setting or anything. Just restart it and it’ll work again just fine (This is why it should boot very fast)

Currently there are some fast booting Linux distros available which could suit this bill. Also, in some Asus motherboards there’s a technology dubbed the ExpressGate: Power up PC, and ExpressGate is ready for internet browsing, chat or skype or whatever in a matter of seconds. It’s essentially a Linux with a custom, simplified, window manager. Features like these could make using a computer simpler as well, however I think a separate not-a-computer type device could work better.

Great benefits

I think an internet capable device as simple to use as a TV could bring great benefits. Even though the computer is almost ubiquitous nowadays, there are still plenty of people who don’t own one.

Everyone should have a device capable of accessing the internet, if only to use Wikipedia

Why would this be useful? Sometimes you might share a string between objects, and you’d want changing it in one place get reflected in elsewhere. If you had a single string object, which was referenced from multiple places, this would be simple.

But it turns out, it isn’t…

foo = ’string’ vs foo = new String(’string’)

You may be aware that you can use either of these two syntaxes to declare a string in JavaScript:

var strLiteral = 'I am a string literal';
 
var strObject = new String('I am a string object');

But what’s the difference between these two?

With string literals, assigning the string to another variable copies it, but any properties assigned to it are lost:

var literal = 'hello';
literal.prop = 'xyz';
 
var copy = literal;
 
console.log(copy.prop)
-> undefined

If you use new String, it’s again copied, but since it’s an object, it’ll copy the reference. As such, the properties of the object are still there:

var obj = new String('hello');
obj.prop = 'xyz';
 
var copy = obj;
console.log(copy.prop);
-> 'xyz'

Maybe we can use this to our advantage?

Making string objects behave funny

If you’re familiar with String functions in JavaScript, you may recall that none of them actually modify the string itself - They all return a new string with the modifications.

How could we change a string, then?

Array to the rescue!

We can use array’s functions on strings to try and hack it:

var x = new String('foo');
 
//Try appending to string
Array.prototype.push.call(x, ' ', 'b', 'a', 'r');

Turns out this doesn’t quite work as expected. If you output x, you still get 'foo'. However, if you iterate all properties in it, you will actually see the pushed characters.

Perhaps something else is affecting the output?

In JavaScript objects, the toString method is used to convert them into string representations. Perhaps if we override toString?

var x = new String('foo');
x.toString = function() { return 'foo bar'; };
 
console.log(x);
-> 'foo'
 
console.log(String(x));
-> 'foo bar'

Turns out toString isn’t used when it comes to strings. However, when casting the variable to string with the String constructor, it outputs the value from toString.

Confusing is it not?

So what can we actually do?

It does look like strings can’t really be made mutable in a sensible way, doesn’t it?

But there is one more alternative: A custom string class.

We can create a MutableString class:

var MutableString = function(value) {
  this.text = value;
};
 
MutableString.prototype = {
  toString: function() {
    return this.text;
  }
};
 
var x = new MutableString('bar');
 
console.log(x);
-> object
 
var y = 'foo ' + x;
console.log(y);
-> foo bar

In this case the variable appears as an object when logging, but the toString method gets called when it’s cast to string, such as when concatenating it with strings.

This example doesn’t show how you’d actually change a MutableString - You will need to add some methods that will allow changing the value of the text property to make any use of this as anything else than a string wrapper.

The usefulness of this exercise

In the end, this isn’t a very useful concept - Most of the time you don’t really need strings to be modifiable like this.

What we can learn from this is that JavaScript’s built-in functions are surprisngly versatile - We called a function from the Array object on a String, and it actually worked (but due to how string works it did not provide the expected results)

If you know something that I don’t, and are actually aware of how this could be done without silly hacks like the MutableString class, feel free to point it out in the comments!

No version control

This is a pretty bad one! I’m glad I learned to use SVN at an early age…

Always use version control in your projects. Be it Git, SVN or even CVS, as long as you use something. It’ll help you avoid a thousand problems!

Here’s some of my posts about Git.

No plan

It may feel like just having a general idea (eg. “Hey, let’s make a forum!”) is alright, but it isn’t.

With no plan or roadmap, your project may easily derail into more and more new features, never actually getting anything finished.

Always try to create some kind of a plan that includes the features you want. Make it a Word document, or even better, put it in a tool like Trac or JIRA where you can easily track what you are working on. Not only will this give you a clearer image of what needs to be done, it can be useful to see what you have already accomplished so far.

No schedule

You may have a plan, but do you have a schedule?

Scheduling is as important as having a plan in the first place. Without a schedule, the project may easily keep going endlessly, with very little progress as nobody cares as there are no deadlines.

I have to admit that even now there’s a project I’m working on, without a proper schedule, which has been going on way longer than it should. I plan to fix that, though!

No release strategy

What’s a release strategy? This may not be the correct term, as I just made this up, but I think it’s quite descriptive: It includes how often you want to do releases and the steps involved in making a release.

The most basic requirement is to have a build/deployment script. A single command you, or anyone in your team, can run to completely build and deploy your application. This is important because a minor mistake can cause problems.

How often have you forgot to upload a file to the server when deploying? I bet the number is bigger than zero. Now think how many steps there is even in a simple deployment.. Sending files, setting up the database, maybe installing a default user…

How often you do releases can be important too. For example, in Scrum you develop in sprints and in the end of each sprint is a natural point to make a release with the features chosen for the sprint.

Tools such as Ant can be used to create build and deployment scripts.

Developmestruction

Not having a separate development and production environment is a recipe for disaster, especially if your application is being used in the real world at the same time as development is happening.

I’m a guilty of doing this, but luckily the applications weren’t being used by more than a handful of internal users.

Always perform development on separate machine(s) than the actual production deployment. This ensures the production system should stay relatively intact (unless your deployment screws up or you introduce more bugs).

Additionally, having a staging environment can be a good idea. This should usually be on similar hardware and software as production, as this will allow you to test-drive your code on a realistic setup before pushing it to production.

Not using Test Driven Development

This may not be the most critical problem, but I think it’s important nevertheless.

By having a good test-suite, you can ensure you don’t introduce regressions and that your code works at least as well as your tests were written.

For some reading on testing, check out unit testing essentials and How to make your code testable in this blog.

Post your tips/mistakes in the comments

If you have any tips/mistakes of your own, please share them in the comments. I’m still learning too, so they would be great additions to this list.

I’m sure many of us have often thought about getting headphones - and I’m sure many of us already have a pair - but how much is a reasonable amount to spend? And what will a higher-grade (read: more expensive) pair do that’s worth the money?

I recently decided to invest on some new headphones. The AKG K 701’s to be precise. They aren’t exactly very cheap and you’d probably want a headphone amplifier to go with them, one which I incidentally also bought. I’ve also had some more reasonably priced headphones in the past: Sennheiser HD-555’s and going down in the price range, some Koss and Philips ones.

My opinion is that great headphones can make listening to music much more enjoyable. However, should you go all out and buy expensive ones like the AKG, or is it smarter to purchase something else?

No

Don’t get me wrong here - The AKG’s are great, and I’m happy with my decision to buy them.

However, I would not recommend them for everyone, because cheaper headphones are better value for most people.

I am by no means an audiophile or a hi-fi aficionado - in fact, if you ask me about ohms, impedance or such, you may be met with a blank stare - but I do enjoy the beeps and boops coming from the cans on my ears sounding nice.

So what do I base on my recommendation that everyone shouldn’t get the AKGs?

The sound quality difference in high-end headphones is less obvious

The Koss and Philips headphones I have previously owned were quite reasonably priced - probably around 50 USD or so.

What did they sound like?

• Koss: Okay but the bass was totally overbearing. Most likely because they were a closed headphone.
• Philips: Okay, less bass than Koss so overall I liked these more. Open type headphones.

The Philips headphones eventually broke. They had this auto-adjusting strap thing, which eventually just snapped and applying overly generous amounts of duct-tape did not help much.

Next, I got the Sennheiser HD-555’s. They are on the level many people may consider “too much”: I paid about 150 USD for mine.

What do they know? I loved the HD-555’s - they were so much better than the cheaper ones I had had before!

Actually, the difference between them and the cheaper ones was rather large. Clean sound, good bass but not too much… and very comfortable to wear for hours.

The really hi-fi stuff

After years of use I wanted to get something even better than the HD-555’s.

I decide to buy the AKG K 701’s after listening to them in a local hifi shop. I paid 340 USD for mine, which is quite a lot. Add to that a specialized headphone amplified at 160 USD.

The AKG’s have much cleaner sound than the Sennheiser’s. They have a wider soundstage, which is apparently a term meaning they can make the sound seem like it’s coming from farther away than it actually does (or something like that), and in general they have much more accurate response. For example, guitars and cymbals often have reverb or echo that wasn’t there with the cheaper phones.

When going from Philips to Sennheiser, I paid about 100 USD more for the whole deal.

When going from Sennheiser to AKG, I paid about 400 USD more.

You would expect the difference to be something like 4 times better, right?

The truth and the bottom line

The truth is that the difference is not 4x.

The difference is there, but it’s much less noticeable than when I just added 100.

In my experience, paying around 100 - 150 USD will get you a pair of headphones that are very good. They aren’t as great as paying even more, but I think at this point the differences between price start to be larger, and the differences between sound start to be smaller.

If you have been wondering how much is enough for headphones, I say go for the range of 100 to 150 USD. Of course, go and test listen the headphones before you buy. If you already have something at that range, I suggest caution unless you don’t mind spending more money on smaller enhancements.

Share your thoughts on this in the comments!

• DHTML - In other words, using divs with images and moving them around
• Canvas
• A hybrid: Canvas with DHTML

I’ve considered each of these, and they all have some pros and cons which we’ll look at next.

DHTML

This is the most compatible of the three: Even Internet Explorer supports creating divs and moving them around on the fly.

This approach is quite simple too. The APIs used are well-known and usually quite problem-free when used correctly.

Moving divs etc. around tends to be pretty fast too, so even if you have a big huge animated explosion or something, the performance should still be relatively good. Compared to canvas this is DHTML’s biggest win.

One of the downsides with DHTML is sometimes jerky movements: You always need to draw and move things pixel-precise, as you can’t tell a div to be exactly 15.5 pixels from something. Canvas can draw “between” pixels, as it automatically aliases the graphics to look more like it.

With DHTML you also can’t draw shapes like you can with canvas, so you’ll need to come up with the graphics in an image editor beforehand.

With CSS transitions and other tricks, you can bend DHTML surprisingly far. However if using transitions or other advanced features, you sacrifice compatibility with more browsers than you would if you were just using canvas.

Canvas

Canvas is great. I wish I could leave it at that.

However, in addition to being generally easy to use after getting familiar with the basic API, there is one significant downside: Canvas is slow. Slow slow slow slow slow.

Unless you apply considerable amount of thought into the code, getting stuff drawn at reasonable speeds with canvas is difficult. It’s like going back to the times when computers had 66 mhz CPUs.

Canvas does have a lot of good things though: You can draw on it directly, with direct pixel manipulation, a vector-like API, or images.. or compose a new image using another canvas.. It is certainly very flexible, and it makes it very simple to do complex and dynamic shapes that would be much trickier otherwise.

If you’ve been following the TankWar 2.0 development, you may have noticed it does draw some okay looking graphics but it still is somewhat reasonable quick. It only uses canvas for rendering, so yes, it is indeed doable, but it requires tricks.

I’ll be discussing the finer details of how to make canvas rendering faster in another post.

Hybrid

A hybrid graphics engine is exactly what it sounds like: It combines both DHTML and canvas to overcome the downsides of both approaches.

While this may sound like the stone to drop two birds with, it may not be.

One of the good things about this approach is easily seen when you need to display large graphics that move. Canvas can be very slow in cases where you update larger areas of it, so in a case like this using a div for the big graphic is good. Then, you can use canvas for the rest, to create different shapes etc. which would be tricky with divs.

The main downside of this approach is complexity. Since you need to deal with both canvas and DOM, it’ll become twice as complex as using either of the approaches alone.

In closing

The approach I’ve chosen for TankWar 2.0 is pure canvas. I may need to resort to a hybrid approach if the performance drops too low, but right now it’s still tolerable at least on a moderately quick PC.

In the past, I’ve used canvas on most of my games: TankWar, Opera Command, WidgetRacer, Asteroids… but I’ve also used a DHTML-like approach in a Tetris game and in WidgetCity. In these cases the DHTML-based approach was simpler or had other reasons, such as being much faster in case of WidgetCity (My post about the table/CSS rendering in WidgetCity).

I’ll be discussing the details of how the new TankWar 2.0 canvas engine works in a later post. I’ve had to do a significant amount of performance trickery for it too.

Next week we will return to our regular programming.

Most popular posts

The top 5 most popular posts for this year are:

1. Zend_Acl part 1: Misconceptions and Simple ACLs
2. Zend_Acl part 3: Creating and storing dynamic ACLs
3. Doctrine vs Propel
4. Handling errors in Zend Framework
5. Zend_Form decorator tips

Doctrine vs Propel seems very popular, even though it’s getting slightly out-dated. It was in 2008’s top 5 as well.

Miscelaneous

According to Google Analytics, this blog had 232,805 visits and 335,823 pageviews this year. That’s more than twice as much as last year (81,027 visits, 119,024 pageviews), so I’m quite happy about the figure!

I might go as far as claim that my blog is one of the most popular IT-related blogs written by a finnish person. Too bad there’s very little reliable data available on that, but from my empiric research I’d say it may not be completely untrue (feel free to provide statistics if you know of any) - however I have very few visitors from Finland, a mere 1% of the total.

This trick can be applied with any other application too, like <insert your favorite editor>

Step 1: Create copy of the standard menu configuration

First, you need to create a copy of the standard menu configuration so you can go back if something goes wrong.

This can be achieved by going to preferences (Ctrl+F12), Advanced, Toolbars. Now choose “Opera Standard” from under “Menu Setup”, hit Duplicate and then click on the newly duplicated setup. Hit OK and you’re done with this step

Step 2: Edit menu configuration

Now, you need to find the menu configuration file. It’s located in the directory where Opera stores your profile - typically in Documents and Settings, but the easiest way to find it is by going to opera:about.

The path to your profile is displayed under “Paths”, as shown below:

In my case the profile directory is the one highlighted in the image. Find yours, and you should see a directory called Menu under it.

In the menu dir, you should have a file called standard_menu (1).ini. Open it and find the line which says Hotclick Popup Menu

Under it, you should see lines such as “Item, M_COPY_TO_NOTE=Copy to note”

To add a new Copy to Vim item, insert the following line:

Item, Copy to Vim = Go to page, “data:text/open-in-vim,%t”

Here we are essentially adding a new command to go to a specific URL. In this case, it’s a Data URI, using mime-type text/open-in-vim, which is something we made up, and then including the text highlighted with the identifier %t

Step 3: Add new mime-type handler

Now that we have modified the menu configuration, the last thing we need to do is add a handler for our own text/open-in-vim mime-type.

Go back to Opera’s preferences, but this time choose Advanced, Downloads.

Click on Add… and fill in the dialog:

Mime-Type: text/open-in-vim
Extension: openinvim (this can be anything you want actually)
Action: Open in Other Application, fill in path to vim’s executable.

Done!

If you didn’t restart Opera yet, do that now. You should now get a new Copy to Vim menu option whenever you highlight text and right click.

This is the first one: Assessing the damage. In other words, take a look at the old code and see what can be salvaged. I’ll also list some issues with the current implementation, and how I plan on solving them in the new version.

Issues in the current implementation

I wrote the most of the code in the current version of TankWar somewhere in 2006. Let’s be frank: The codebase sucks.

It’s a mess.

I’m surprised some of it ever worked. At all.

My coworker Artem tells me recognizing your old code is crap is a good sign: It means you have improved - and I agree with him.

In addition to being pretty poor code, the current version does have some bugs too:

1. If your bullet moves very fast, it can go through the ground.
2. The graphics system is poorly implemented which can be seen especially when using the bomber weapon - it can get pretty glitchy
3. The bullet trajectories deviate wildly depending on the computer’s speed

While some of these issues could be patched into the current code, it would just make the code even more fragile.

Damage control

In most cases there’s some useful code even if most of the code is messy.

In the case of TankWar, the main implementation of the game engine, menus, etc. will be thrown away. They make most of the code, but they are also the worst parts of it.

The good parts of TankWar include the terrain generator, some vector math classes and some utility classes.

It seems we can apply the statistic that simpler code contain less problems here too.

Solutions to the current problems

First and foremost, the codebase will need to be organized better. Now it’s just a jumble of code and HTML, CSS and whatnot mixed together like magic hobo gravy.

The game engine itself will need to be more robust and be able to handle fast moving bullets properly, and the trajectories need to be correct.

Bullet collision solution

The solution to fast moving bullets going through stuff is improving the collision detection mechanism. Currently the implementation is quite simple: It simply moves the bullet each cycle and checks if the bullet intersects the ground or other objects. This is very easy to implement, as the canvas element has a function for it, but it’s not very accurate with fast moving objects.

A better approach with fast moving objects is using ray intersection detection. Put simply, this means we will check all the points in the trajectory, including the points between the positions the bullet actually is in. In the old implementation, depending on the speed, there could be tens of pixels of space which was never checked for hits.

Glitchy graphics

The solution to the issues with the graphics system is to make it separate from the other stuff. The current graphics engine was just quickly slapped on top of the physics engine to make it display pretty pictures. This is more of an architectural problem than an algorithmic issue as the collision detection.

Additionally, the graphics system may be a little problematic in general. While it works with the current simplistic graphics, I’m not sure whether it would function very well if I wanted to include more complex graphics.

Bullet trajectory problems

For the third problem - framerate dependent trajectories - the solution may be more problematic. The current version already attempts to fix this by using time-based movement. However, it does not quite work, meaning I’ve either implemented it wrong or the timer is not accurate enough.

If the timer turns out to be inaccurate, the solution may be to precalculate the trajectory using a predefined framerate. This means we would have to first calculate the trajectory, and only after it’s been calculated, we could render what happened. This might be difficult, because calculating the trajectory may take so long that the user would notice a significant delay between “shooting” and the game actually performing the shot.

Then again, the frame rate calculator was (as far as I can remember) also slapped on top of the existing stuff and never really properly planned. The timer itself works quite similar to the timer in my JavaScript bitmap sprite animations post.

In closing

The rewrite will probably take a while, depending on how much time I’ll have to work on it. I will probably put together some more posts on the topic as I have some progress. Let me know if there’s anything specific about it you’d like to hear.

Naturally the new version will generally be more awesome than the old version - it would be rather pointless to just rewrite it and add nothing else than better code.

Further reading:
Rendering graphics in JavaScript games