A bit about coding

For the last couple of weeks, I have been starting working on the implementation of The Five Orbs. My first goal is to provide a basic adaptation of the current rules in an online, web version. There will be no fancy sprites, no elaborate UI... only the bare minimum to play a game.

The goals of this first, barely-playable version is first to discover the technologies I will be working with (more on that later), understand how to build an application and find out about the more risky parts of the implementation as soon as possible. It will also allow me to play with remote testers and get their feedback. And finally, when it will be implemented, it will allow me to build first statistics on how the game is played, which moves are most played or win most, etc. This will be a very important step towards achieving good balance.

Technologies

This post is tagged "code", so obviously I'll go a bit more technical here.

My job is that of a Java developer, so that would obviously be my choice for the server. Concerning the UI, I had done several mini projects with various technologies. Namely:

• An implementation of the board game Agricola using Adobe Flex. I loved developing in Flex; the IDE is great, the language is intuitive (especially for someone with a Java background like me) and documented, and it offers some really convenient features (like data binding). However I had troubles keeping the size of the application and its performance in check (mainly concerning the memory consumed).
  
• A mini sandbox game using JSF. At first I found the technology great, but I soon found that I missed many things that I loved when I was using Flex. This is a JSP framework, so no Object Oriented Programming. You were in charge of making sure that what you built was compatible with all modern browser (while Flex runs on a Flash virtual machine, which takes care of cross-browser compatibilty). And it being a JSP / javascript framework, it was harder to debut than Flex.
  
• At my job, I have worked a bit with plain JSPs, and with a combination of JSP / YUI (or at least a derivation of it). Everything I said about JSF applies here too.
  

None of these struck me with an obvious choice (although if I had to choose, I'd go with Flex). I looked a bit elsewhere, and I decided to go with Google Web Toolkit. It allows me to code both the server and the UI in Java, offers great debugging tools (when developing, you actually run your UI code as Java code), and all the browser-compatibility issues are handled by GWT (the Java code is compiled into javascript before being deployed in production). The community around it is very active, it is properly documented, and for now it meets all my needs. The one thing I regret is that the graphical editor is less easy to use than the one from Flash Builder.

Deployment

I looked then at where I could host my application. Unfortunately, it is not easy to find cheap hosts for Java apps, so I was a bit stuck. I then read about Google App Engine, and found out it met my needs. It alleviated me from the burden of managing server loads, database replication and back-up, scalability, and so on. While there is some controversy concerning GAE (especially since they decided to change their pricing policy), so I must be careful to build my application in the way that makes it as independent from GAE as possible.

Development environment

I'm a big fan of Eclipse (I have worked a bit with NetBeans), so this was a no-brainer. I also decided to use Maven as a build and dependency management paradigm. The good point with using GWT and Eclipse is that they go very well together. The Google Plugin for Eclipse offers everything you need. GAE is very well integrated too, and I never have any need to go outside of Eclpse for anything. To the point that I'm questioning my choice to use Maven, instead of a full Eclipse-based environment. Indeed, Maven adds some overhead to the compilation process and makes integration of some features (or other libraries) not so easy within the Eclipse / GWT / GAE world. However, Maven makes my project standardized. If I decide to go out of GAE, I won't need to change anything to my process to keep my efficiency. I can integrate with Continuous Integration frameworks. And the community is active and provides a great support, so it mitigates some of the integration risks.


This post has already been going for some time, so I'll leave all the discussing about real code and design to the next one :)