My rediscovery of C# got me thinking about function modifiers, mainly because C# and Java have countering approaches to handling virtual functions.  In Java your a virtual function unless declared otherwise by using the final modifier (private methods are probably not considered virtual either).  But in C# it’s the exact opposite.  Your virtualality (is that a word?) needs to be explicitly declared by using…wait for it…the virtual modifier.

Another difference is in the subclasses.  Again, C# seems to be much more explicit about this kind of stuff.  You must use the override modifier to declare that your overriding a virtual function.  In Java you really don’t have to do anything, just make sure you have the same name and parameters.  Sure, that @Override thing’s been tacked on to newer versions of Java.  This helps the compiler make sure that the virtual method actually exists in the superclass, but you don’t have to use it if you don’t want to.  C# makes you use it, which in turn ensures of your intentions.

Are these differences a big deal?  Not really.  My preference would probably be with the way C# accomplishes it, as it allows you to be more explicit in your intentions without being anymore verbose about it, which results in clear, easier to maintain code.

But the purpose of this post is where my mind went when considering the way virtual functions are handled in both languages.  There happens to be a big hole in the amount of control that the superclass can take over its virtuals.  In both languages, actually any language I’ve worked with for that matter, the superclass has little to no control on whether or not the subclass inherits the functionality provided by a virtual function.  If the subclass feels it needs the superclass’s implementation as well as some additional stuff, then it can easily call upon the provided code by doing super.FuncName() in Java or base.FuncName() in C# within the overridden function.  But, what if the superclass wants to force the subclass to use the code its virtual function has provided?  What if it just wants to provide the subclass with the ability to extend a method and not completely override it?  Both languages need what I’m calling, the partial function modifier.

For those that haven’t stop reading, a partial function would be a function declared and defined by the superclass that provides some functionality that needs to be apart of every subclass’s implementation of that function.  The subclass would only be able to extend, using the extend modifier of course, the function and provide further logic that is specific to the subclass’s needs.  Similar to an abstract class, the partial function would be required to be extended, or have its class marked abstract, as by marking a function as partial the superclass is basically saying, “Hey, this method, the code it implements…it’s required but the function is still unusable unless you provide the functionality needed to complete it.”

Here’s a usage example to show…what else, it’s usefullness.  Let’s say you have an abstract GameState class.  This class should be inherited by every different game state that your game has.  You’d probably have a subclass for the main menu, gameplay, submitting highscores, and so forth and blah.

The GameState class will need to define methods for loading, drawing and updating.  Each method will need to be implemented by every subclass.  You start off by making all three of the methods abstract.  But then you start creating some subclasses and realize that each and every call to Update should query for actions by the user.  Did they press a key, did they select something…stuff like that.  So you turn the Update method into a virtual method (lets think in C# on this one) and implement the querying functionality for the user’s actions.  Now each subclass just needs to override Update and call base.Update() within it in order to take advantage of the functionality provided by the superclass.

That seems like a perfectly acceptable way of implementing the Update function.  But what ends up happening from then on is that every time you create a new game state and go about setting up your Update method, you forget that you need to make the base.Update call.  So you start testing the new state, no user input works and you smack yourself in the head for forgetting that same stupid call once again.  Now if you had a partial function, the burden is on the superclass to make sure that that part of the code is implemented every time.  And the superclass has no problem with that…mainly because, well, it’s SUPER.  Sorry, that’s lame but I’m leaving in it.

Anyways, would a partial method modifier really save you oodles of time…probably not.  But the point is more that the superclass should be able to control this kind of circumstance, not the subclass.  And right now the subclass is piloting the ship.  Partial methods ensure that the vital code of a method, and we can assume that it is vital because otherwise there wouldn’t be a reason to force the subclass into using it, is being run before anything else the subclass might tack on to execute.  A little more complexity can be hidden and a little less burden can be put on the subclasses, neither of which are ever bad things.

I’d love to hear what I’m missing on this idea or why it wouldn’t work or how stupid I am, or even if there is a language out there that already implements such a feature.  Any conversation on this would be good.  Let me know what you think.

Can’t Find javac…

The first post of the BlackBerry Gotchas category starts where you might start off if you venture into BlackBerry development.  It has to do with getting the JDE properly installed. 

The overall process for installing the JDE is straight forward, just download and follow the installation instructions that follow.  However, after you create the de facto “Hello, World!” application and you attempt to compile, you may run into the following error:

I/O Error: Cannot run program "javac": CreateProcess error=2, The system cannot find the file specified
Error while building project

Not a great way to start, but not a huge problem to fix.  Most modern day IDEs now ask for the installation location of your Java Development Kit (JDK) during the installation process.  However, the JDE relies on the system to inform it of where the JDK is located.  This means that you need to make sure that you specify your JDK’s bin directory in your PATH variable.  You can do this permanently by opening up the “Systems Properties” dialog and under the “Advanced” tab clicking on the “Environment Variables…” button.  Now find the PATH variable in the “Systems Variables” list and add <PATH TO JDK HOME>/bin to is.

Once your done with that, reload your JDE and compiling should commence with only issue that are of your own doing.

Basically, from my perspective…Google’s still king!

As I stated in my previous post to set up my intentions for this comparison, I made Bing my default search provider in Chrome for what I consider a “significant” length of time.  That turned out to be a couple of months.  If Bing gave me search results that were useful relative to my needs, then it got a tick mark.  If it didn’t, I jumped over to Google to see what its take on the same search would be.  If Google came up with something useful, it got the tick mark.

It should be noted that I realize this isn’t a very scientific process.  Trust me, I’ve had it pointed out to me several times by those that noticed the accumulation of tick marks on my whiteboard.  I get it, it’s a bit hack.  But at the same time, determining which search engine provides better results is a completely subjective process that could never truly be scientifically analyzed anyways.  So, I deem my process good enough for my needs and good enough to blog about.

As you might have guessed from me giving away the punch-line at the start of this post, Bing was a bit of a disappointment.  It turns out that about 30% of the time Bing gave me an answer that I didn’t find useful and Google was able to provide something better.  That’s a fairly significant amount of the time, certainly not good enough to be named my default going forward…or to even give it a chance at a one to one comparison with Google.  It just didn’t cut it.

Beyond the 30% fail rate though, what really started to bother me about Bing was its rigidity and inability to cope with my mistakes.  Mistakes like me making a typo.  Where Google seamlessly adapts to such a mistype by its users, Bing responds with something like so:

Not being able to adapt and push forward through such a typo is just not acceptable anymore.  Google handled it perfectly without any further effort out of me.  It recognized that there was a 99% chance that I was talking about checkstyle, a software development tool for adding code convention checking to your build process, and gave me the results for its assumption.  While on the other hand, Bing just stood there with a dumb look on its face like it had no freaking idea what the hell I was talking about.

So Google’s officially back as my default browser.  Though this comparison was enough to convince me  of its superiority, you shouldn’t let it convince you.  As I said, I had this test on my whiteboard for two months.  Anyone that saw it had an opinion on this and some of those opinions were that Bing definitely supplied more natural, useful results than Google.  You basically just need to figure out what works best for you and go with it.  Bing has a lot of functionality and is far superior than all past challengers of Google’s space.  But for me, it still falls short.

Also, I hope to have some new useful content up here in the near future.   My wife gave birth to our daughter four weeks ago today.   On top of that we just bought a house as well.   So, it would be an understatement to say that I’ve been preoccupied.

But, I do want to get back to it.   I have the conclusion to my Bing vs. Google comparison and I plan to add a new subcategory to the BlackBerry category called, BlackBerry Gotchas.  These will be shorter posts that allow me to document quirks and other nuisances of BlackBerry development that are not always so obvious and may cause developer some undesired grief (and possibly already have for myself).

With the latest Dark Corners downloadable content, tied with a great deal to bundle it with the rest of the released map packs, I jumped back in for some more Gears this week.  I was done, I put it a way to spend some more time with my other neglected games.  But, now I’m back…damn you Epic.

Horde mode has been my focus.  And, because I’m hugely driven by achievement earning, my decision on which map to play is completely driven by Gamerscore Greed.  And, it’s not just me.  It seems like the whole community is thinking the same thing. 

Getting a complete 5 man team of randoms is now officially impossible.  Players don’t get the map they need, they drop.  You usually end up with 2 or 3 guys trying to take on the horde, which becomes nearly impossible around level 9 or 10 (yes, playing with friends that you communicate with makes it less impossible, but with a bunch of silent randoms…no way).

Since most achievements revolve around reaching level 10, this turns into a pretty frustrating experience.  Quite a waste of time.  I’m sure this wasn’t the intended behavior, but it surely has created an annoying monster. 

Anyways, it worth checking out.  Hopefully I’ll make it to the mob next time, but even if I don’t it’s still fun to answer some trivia questions, yell at The One to take the money and get your avatar dancing (hint: pound the shit out of Y).

Supposedly 70 to 80 characters per line is optimal.  I don’t think you have to go that narrow, but have some kind of max boundary.

The fact that these are part of the convention says to me that someone at least considered these items possible problem areas.  Were they banished to the convention in order to avoid building any barriers that might deter C/C++ programmers from adopting Java in the early years?  Maybe the convention just came later.  Or maybe it has been edited several time since the language was originally developed and these items were just oversights that can’t be fixed at this point.  This is certainly a possibility considering how easily a convention can be changed compared to the language itself.

/* falls through */

I think switch case statement fall-through is a bad thing in its only supported form, as I mentioned in my simple rules post from a while back.  It shouldn’t be allowed without the compiler being able to have some kind of control over it, and I think Sun knows this.  The switch statement below is directly from the coding convention.

    switch (condition) {
    case ABC:
        statements;
        /* falls through */
 
    case DEF:
        statements;
        break;
 
    case XYZ:
        statements;
        break;
 
    default:
        statements;
        break;
    }

In my opinion the /* falls through */ comment is just hack.  Imagine you have a wall in your house where a 2×4 is missing.  So, at one position on the wall there is a span of 32 inches without a beam and the wall is a little less stable in that vertical strip, a little less likely to support weight.  So, to avoid a drunken idiot, or just a normal idiot, from breaking through the wall, you write in big red letters, “Weak Spot” in the problem area.  Problem solved, unless the drunken idiot didn’t notice it as he was too busy crashing through your new lamp that you just picked up at IKEA over the weekend.

An open manhole cover is another, possibly more realistic analogy.  It’s likely that an open manhole cover will have some kind of visual warning similar to the /* falls through */ comment.  Possibly orange cones.  The only difference is the manhole is only open temporarily, it’s not a permanent situation.  Also, they use bright orange cones, an object out of the ordinary.  Comments are usually all over the place in code and quickly are filtered by your SEP field.

There might be nothing they can do about it now considering that there are way too many applications out there developed with Java that might just stop working if they made such changes to the language, but it is still a pretty hack solution to the issue.  They would serve new developers better by just telling them not to use case fall-through.

In the most hindsite, snooty, Monday morning quarterback way, they should have done something like this.

    switch (condition) {
    case ABC:
        statements;
        continue;
    case DEF:
        statements;
        break;
 
    case XYZ:
        statements;
        break;
 
    default:
        statements;
        break;
    }

Use the continue keyword to allow case fall-through.  Or they could’ve created a fall keyword; maybe even, gasp, a goto <case> type of implementation.  Anything that gives the compiler control over case fall-through is better than nothing…er, having a /* falls through */ comment.

Statements Always Use Braces

I always use braces…always.  I can’t stand the look of of the following in my code:

    if(condition)
        doSomething();

It just comes off as messy to me, not uniform with the rest of the code. I think it’s perfectly acceptable in a language like Python as code blocks are defined by indentation, not opening and closing curly brackets.  But, in languages that rely on braces, you shouldn’t be allowed to define a code block any other way.  And again, it seems the developers of Java agree with this.  Section 7.2 of the coding convention states:

Braces are used around all statements, even single statements, when they are part of a control structure, such as a if-else or for statement. This makes it easier to add statements without accidentally introducing bugs due to forgetting to add braces.

I’m going to chalk the decision to not put this in the language up to staying inline with the supported syntax of C/C++.  Programmers are fussy prima donnas.  You don’t mess with their preferences, even if there preferences are completely wrong.

The fact that this isn’t a part of the language isn’t a big deal, but if I see an if statement missing curly brackets in code I’m working on,  I’m compelled to add them.  And you should be too.

Public, Private, Protected…why not Package?

Recently I’ve been seeing this a lot in code I’ve been working on.

/*package*/ class SomeClass {
    public String someVariable;
    /*package*/ Object someVariable2;
}

It irritates the shit out of me.  If you spend ten freaking minutes working in Java it’s likely that you will learn, or figure out that the absence of an access modifier makes the member/class public to the package, but private to the world.  But, it does make me wonder why they didn’t just go the extra step and make a package access modifier.  It neatly falls in line with the length and first letters of the other access modifiers; it seems like it would have been a natural part of the language.  Also, it would keep my code looking slightly more uniformed.  The variable name for private, protected and public variables all start in nearly the same location.  Then you have the package variables that start way before anything else…or at least a couple of characters.

I know, this one’s a bit nitpicky.  Unlike the other two, having a package modifier doesn’t help fend against introducing defects.  It’s completely a visual preference of mine.  It doesn’t matter.  However, putting the /*package*/ is way worst than just having nothing at all, so just don’t do it.  All that says to me is that the programmer was too stupid to remember that the member would only be able to be accessed by other members of the package.  You don’t want me thinking you’re stupid, do you?

Anyways…

I understand that creating a flawless language is hard, if not impossible.  I also understand that this stuff is subjective and you may not agree with it.  And I also realize that even if Sun now believes this stuff should be enforced by Java’s compiler that it will never happen due to the fact that many companies and developers rely on their shit being consistent with what is already available.  But, that doesn’t mean I can’t point out their flaws from atop my safe little mountain of hindsight.

What I wanted to mention was that even in its pre-release developer state, Google Chrome Linux is still the best internet browser I’ve fired up.  Firefox is solid but feels a bit sluggish, and Opera’s page rendering is embarrassingly slow.  I was starting to think it was my connection, or something with Linux…not true.  Chrome friggin’ rips, just as you may have come to expect from it on other platforms.  Being pre-release you run the risk of it being a bit buggy, but I haven’t had any issues to this point and I certainly wouldn’t let that stop you from giving it a try.

With that said, it has no place in the implementation process.  Instead of a tool for writing better code, it has the ability to manifest itself into a big waste of time and a destroyer of the elusive “flow”.

Recently I’ve been working on a feature that requires communication between a couple of different layers.  In one layer I’ve set up an event listener/dispatcher to listen for events from the other layer.  The dispatcher then calls upon an event processor that does what is needed for each event and passes the results back to the other layer through a callback function.  I created an interface to wrap the callbacks so I can set up a test environment that points to some fake callback functions until the other layer’s actual callbacks are in place.  I then created a variable for the callbacks within the event processor with the intent on using it later, but before that it was to define my class design a little more clearly within the code.

Before getting the callback stuff working, I needed to get the event communication between the two layers working properly.  I spent about an hour working out the details before I attempted to build and see how well I had progressed.  All my syntax seemed fine, thanks to the power of the modern IDE.  So I was pretty sure it would at least compile.  Running properly was a completely different story, but I thought I would at least have a build that I can get on the device and start debugging. I fired off the build and about five to six minutes later…

“You dumb shit. The variable _callback is never used. I could just keep building and let you off with a warning…screw you, bitch. Error!”

Okay, so my compiler isn’t that big of a douche, but it might as well be as it just puked on a warning during a build process that takes around 10 to 15 minutes to complete, depending on what you changed, all because of a variable being unused.  A variable that I expected to be unused at this point as it is just there as a place-holder for me to visually see the design of my future implementation.  Any flow I had going is completely shot at this point, as you might have expected.  There’s nothing else for me to do but let out a sigh, comment out the variable, start the build again and go get some coffee.

When I returned the build had aborted…again!  This time it’s due to a package being imported that isn’t being used; the same package needed for the callback variable that I just commented out.

“Hey idiot, you don’t use this package. Error bitch!”

Now that’s twice the compiler has called me bitch.  Twice!  All I can do is go the rout of Jim Carrey in Liar Liar; piss, moan, bend over, take in tailpipe.  Comment out the import statement, start the build process and make some notes in my notebook to write a post complaining about warning as errors.

So, you can see my point about it being a bad thing.  Anything that decreases your productivity needs to be considered a bad thing.  The question that I’ve been pondering though is, is it worth turning warnings being treated as errors off in my local environment during the implementation stage of a new feature?  Do I dare risk becoming the ass hole that broke the nightly build because I didn’t turn warnings as errors back on before submitting my changes to the depot?  Yeah, that’s all I want is it to be the jerk that thinks he’s better than treating warnings as errors.  I don’t think so.

So, I’m dealing with it.  I’ve made some adjustments in my IDE to make it more obvious that I have potential warnings that will break a build process.  Mainly, I’ve adjusted the color of the squiggly line color from a barely visible whiteish yellow to the blazing red of the error messages.  I’m thinking this might need to change to a different color to avoid me having to decipher whether the marked code is actually an error or a warning, but “you’re freaking screwed” red is fine for now.

I also use a lot of //TODO comments now to layout the skeleton of classes.  It’s not as pretty, but at least the IDE generates a nice task list based on them for me to reference.  All and all I’m still not for treating warnings as errors so early in the development process, but sometimes a slightly less productive setting for yourself can be much better than possibly slamming your whole development team’s productivity against a brick wall.