Being a .NET developer I really wanted to keep everything in a Windows environment; however, it turns out that some of the best tools for version control are Linux based.  Although most of these tools do have Windows ports I decided that the best approach would be to just bite the bullet and use Linux.  While running version control on Linux will next really require a full LAMP (Linux, Apache, MySQL, PHP) you might as well go ahead and get that setup.  Here is what you’ll need:

• VirtualBox – When playing with a new OS I prefer to do so on a virtual machine.  This way, if / when I completely screw things up it isn’t a big deal.
• Ubuntu – Ubuntu is currently one of the more popular Linux distributions out there.  Go with the Desktop version if asked to make a choice.  Once you’ve got a firm grasp on what you’re doing you may want to switch over to the server edition:  for now stick with the desktop edition.

Installing Ubuntu on a new virtual machine using VirtualBox is fairly straightforward:  just follow the prompts the VirtualBox wizard presents you.  If you get suck, a quick Internet search should help you move along.  My search returned this result:  How to install Ubuntu in VirtualBox.  You’ll also need to make sure you install the Guest Additions as well.  If you’re a complete Linux rookie like I am, then you’re probably wondering how to switch to the cd drive in the terminal.  In Linux you don’t do something cd E: to get to your CD-ROM drive.  Instead you just switch to the mounting point as you would switch to any other folder.  For me cd /media got me to the place I wanted to be and from there I could use sudo to run the installation scripts with the needed permissions.

With Ubuntu up and running its time to get Apache, MySQL, and PHP setup on the new virtual machine.  As I said earlier you could probably get away without setting up some of the LAMP components (e.g. MySQL), but getting these things setup on a fresh Ubuntu install is so easy you might as well just do it.  Who knows what you might want to do with the VM in the near future.

Here is an excellent tutorial that will guide you through getting your LAMP setup up and running:  Install Apache MySQL PHP phpmyadmin (LAMP) on Ubuntu.

Here are some answers to questions you may have:

• sudo – This command lets you run things as an administrator.  Without this you may get permission errors when you try to navigate to certain paths or when you try to execute certain commands.
• apt-get – This is the Advanced Packaging Tool that is part of most (if not all) Debian GNU/Linux based Linux distributions  (like Ubuntu).  This is a very handy tool that will ensure all of the necessary dependencies for a given package are installed and help with uninstalling packages in the future.  You should know that this is not the only package tool out there.
• gksu gedit – This command will open the text editor the the permissions you need to change some of the restricted files.
• gksu nautilus – This will give you a file browser with elevated permissions.

Hosting your version control on a Linux VM isn’t going to do you a whole heck of a lot of good if you can’t access it from the Windows machine you’re developing on.  Thankfully VirtualBox makes this a pretty simple task.  As with the previous sections, I’m just going to point you in the right direction (see the notes below before reading the article):  Creating a virtual development server using VirtualBox.

Some Notes:

• I skipped the entire “Configure the network” section and had no problems.  I would recommend only venturing into that section if you run into problems.
• Make sure you notice the note in the article talking about using ‘e1000’ instead of ‘pcnet’ if you have an Intel network card.  All four of the computers I’ve done this on had Intel cards.
• You will also need to do this for port 22 (SSH) for the GIT server, you might as well do that now as well.
• “GuestPort” refers to the port on your Ubuntu VM.  For Apache this should probably stay port 80
• “HostPort” refers to the Windows OS you’re running the VM on.  In all likelihood you’ve got IIS running on port 80, so use port 8080 or some other port you currently don’t have bound to anything else.

At this point you should be able to open up your favorite browser in windows, type in “http://localhost:8080” and see the o-so-exciting “It Works!” page from Apache… exciting.

Okay, so we’ve got VirtualBox running, our Ubuntu VM all setup with a basic LAMP configuration, and you can now access Apache from the outside world (well, anywhere that can access your Windows Host machine that is).  Next up we need some version control.  Generally speaking, you’ve got two options here:  Subversion (SVN) and Git.  Both have fairly strong developer support, however support for Subversion is generally baked into the other tools we’re going to use while Git is not.  Having used both Subversion and Git, I’m going to use Git in this setup.  I prefer Git’s decentralized approach to version control and it seems to be growing in popularity.

After some searching, I found that gitosis is basically your best option for managing your Git repositories in Linux.  What you’ll need:

• A tutorial – Again, a link (or two):  Setting up a git server in Ubuntu with gitosis and using gitextensions on Windows, and Install (Set Up) GIT and Gitosis on Ubuntu.
• mysisgit
• A SSH key – Git Bash from the above link can be used to generate your SSH key:  Generating SSH keys (Win/msysgit).

It took me a moment or two to fully understand how to manage gitosis so I’ll review that here.  The gitosis-admin repository contains all of the files you need in order to manage the repositories.  If you’ve successfully followed along with the above tutorials you should have that repository cloned o
nto either you Ubuntu VM somewhere or your local host machine.  Make sure you execute the following command on the Ubuntu VM:

sudo chmod u+x /var/git/repositories/gitosis-admin.git/hooks/post-update

If you do not you will most likely spend a few hours wondering why your changes to the configuration file aren’t taking effect.  If you don’t set the post-update hook to executable then your changes to the config will not actually take effect after the post back to the repository as they should.  Also ensure that you’ve properly forwarded port 22 from you host to the guest (see Step 1).  At this point you should be all set with version control.

One problem I did run into was when I went to move the virtual machine to a different computer I could not re-clone the gitosis-admin repository because the SSH key for the new machine was different than the one I originally used when setting up gitosis.  Here is how to solve that problem:

• Open a terminal and execute the following command:  sudo bash (the root user is by default locked in Ubuntu so you cannot just switch to the root user using su)
• Navigate to /home/git/.ssh/
• Open authorized_keys using gedit (gedit authorized_keys)
• Replace the existing username with the new username in your newly generated SSH public key file
• Replace the ssh-rsa key with the key found in your new .pub file.
• Navigate to /home/git/repositories/gitosis-admin.git
• Open gitosis.conf using gedit
• Add your new username to the members of the gitosis-admin group in the config file.
• Using Git GUI or Git Bash to clone the gitosis-admin repository to your new machine.

Okay, so we’ve installed VirtualBox, created an Ubuntu virtual machine, configured the VM with a basic LAMP setup, made Apache and SSH accessible from the Windows host machine, and setup GIT for version control.  Next up:  installing Trac for basic project / ticket management.  The good news is that installing Trac is trivial if done correctly.  The bad news is that Trac does not have out of the box support for GIT.

It is very important that you do NOT use sudo apt-get install trac.  This will install Trac 0.11.7 and we want Trac 0.12 (the latest version).  This is where easy_install comes into play.  Here is a list of resources I used to get Trac 0.12 installed and configured:

• Install Trac 0.12 with Bazaar, MySQL and Mod_WSGI on Ubuntu 10.04 – The only part of this article you should care about is where it shows you how to use easy_install to get Trac 0.12 installed
• How to install Trac on Ubuntu – The important parts here are step 2 (setting ownership of the Trac folder) and step 6 (creating the Trac environments).

NOTE:  If prompted, do not configure your version control at this time.  We’ll tackle that issue in the next step.

If you want you can run Trac using its stand alone server (tracd), one of the CGI methods, or using mod_python.  I’ve chosen to go the mod_python route so that I have the full power of Apache at my disposal without the performance hit the CGI and FastCGI methods bring to the table.  Here is an excellent resource for running Trac with mod_python:  Trac and mod_python.  Here is what my default site virtual host file looks like after adding the necessary elements for Trac:

[xml] <VirtualHost *:80> ServerAdmin webmaster@localhost DocumentRoot /var/www <Directory /> Options FollowSymLinks AllowOverride None </Directory> <Directory /var/www/> Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all </Directory> ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ <Directory "/usr/lib/cgi-bin"> AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all </Directory> ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined Alias /doc/ "/usr/share/doc/" <Directory "/usr/share/doc/"> Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 </Directory> <Location /trac> SetHandler mod_python PythonInterpreter main_interpreter PythonHandler trac.web.modpython_frontend PythonOption TracEnvParentDir /home/trac/projects PythonOption TracUriRoot /trac </Location> </VirtualHost> [/xml]

If you’re having trouble finding the file to modify, it should be located at /etc/apache2/sites-available/default.

At this point you should be able to open a browser on your host machine and navigate to http://localhost:8080/trac and see a list of the Trac environments you’ve got setup.  The next step is to get the Git plugin configured and working…

Getting this figured out and configured for the first time was no walk in the part.  Originally I had installed Trac using apt-get which lead to me having to uninstall Trac and then re-installing it using the easy_install method outlined above so that I would have version 0.12.  The plugin is available for Trac 0.11, but why use outdated software on a fresh install?  Once all of the versions were properly matched, getting the plugin up and running was pretty smooth sailing.  Here is what you’ll need:

Instruction for Installing the plugin and configuring your project

That one link should do it for you.  Keep in mind that using easy_install will install the plugin globally so you’ll need to specifically enable the plugin in each project’s trac.ini file.  Make sure you install for Trac 0.12.  If you visit your Trac site (e.g. http://localhost:8080/trac/myProject) and get errors one of the following issues could be your problem (live and learn…):

• You need to make sure Trac has the necessary permissions.  using chown or cmod on the appropriate directories should solve that problem.
• You have mismatch version of Trac and the plugin.  This resulted in error message about a type not being parse-able or something like that.  To remove the old version just use the find command (find / –iname ‘tracegit*’) and remove all references of it.  I found myself in this trouble after using sudo apt-get install TracGit.
• You did not add tracext.git.* = enabled to the [components] section of the trac.ini file for your project (located in the /home/trac/projects/myProject/conf folder).

Okay, so that tackles using Trac with Git.

The last piece to this rather long puzzle is getting the automated build up and running.  As is the case with just about everything I’ve touched on so far:  I’m no expert when it comes to TeamCity.  Some intuitive guess work was all it took to get TeamCity up and running.  First you’ll need to download TeamCity.  With the obvious step out of the way go ahead and install using whatever port works for you.  This process is pretty straight forward.

Once you’ve created your admin account you’ll need to configure your first project.  Configuration is a 7 step process.  Step 1 (General Settings) shouldn’t require any help.  When you get to Step 2 you’ll need to configure the VCS root.  Here is the summary of the settings that worked for me:

• Type of VCS:  Git (JetBrains)
• Fetch URL:  git@localhost:yourProject.git (whatever you were using with either the Git Bash or Git GUI in Step 4 above)
• Clone Repository To:  Whatever name works for you
• User Name Style:  Email
• Authentication Methods:  Private Key
• User name:  git
• Private Key Path:  c:\Users\username\.ssh\id_rsa
• Passphrase:  yourpassphrase (again, from Step 4)

Leave the rest of the fields alone and test your connection.  The above settings worked for me and may not be exactly what you need:  hopefully it works for you.

The next step is the runner.  For this tutorial we’ll use a Visual Studio (sln) runner.  FYI, when the field label says “something path:” it really means the full file name and not just the path, so be sure that you actually include the file name (e.g. c:\CI Builds\Cms\Cms.sln).  Originally I was just putting that path which lead to problems.

One of the big benefits of this setup is automated test runs.  Although Visual Studio 2010 now features integrated unit testing I still find myself using NUnit.  Properly configuring NUnit for the runner is again pretty straight forward.  As with the solution path, be sure to include the actual file name in the “Run tests from:” field using a wild card as necessary (e.g. c:\CI Builds\Cms\Cms.Library.Tests\bin\Release\*.tests.dll).

The last step I needed was Step 4, Build Triggering.  I simply set TeamCity to trigger a build whenever new code is pushed to the Git repository.  Once you’ve saved your configuration you should be able to click the run button and watch it pull down the latest source and run the tests.  That, or see an error.  Thankfully TeamCity’s error messages are pretty helpful and they should help you resolve any problems in fairly short order.

At this point you should have VirtualBox running your Ubuntu VM with a basic LAMP setup, GIT, and Trac, and TeamCity running your automated builds / unit tests.  There are however a few lingering issues:

• The VM needs to be running as a service so that we don’t have to leave the server logged in.
• TeamCity needs to be configured to use a remote build agent (for various reasons).
• I have not put any security into place:  clearly this is important.

These last few problems shouldn’t be to hard to tackle.  An article about configuring VirtualBox to run a VM as a service using VirtualBox’s Remove View feature and some other tools can be found here:  How to run VirtaulBox as a service in Windows.  Configuring the remote build agent for TeamCity should also be pretty cut and dry.  Look for a future blog post outlining these final steps sometime in the near future… maybe…

It turns out that this problem is caused by the Eclipse IDE not knowing where Java is installed.  To resolve this problem you just need to edit the Eclipse.ini file (which is found in the same folder as your eclipse.exe file).  Open the Eclipse.ini file in your favorite text editor and add the following two lines:

-VM
C:\Program Files\Java\jre6\bin

Of course this is assuming that you do indeed have Java installed in the above location.  If you’ve installed it somewhere else, just alter the path as needed.

I’m using Eclipse Helios (3.6) on Windows 7 Ultimate 64 bit.  I can’t promise this will work on any other configuration; however, I don’t see why it wouldn’t.

It wasn’t long before I turned to the magic machine known as Google looking for something to help me tame the wild beast of a database. The search results directed me to an extremely helpful blog entry by Pinal Dave.  In it he outlines the following SQL Query which will search all of the tables in a given database for a column with a given name:

[sql]
USE SomeDb;

SELECT
t.name AS table_name,
SCHEMA_NAME(schema_id) AS schema_name,
c.name AS column_name

FROM
sys.tables AS t INNER JOIN sys.columns c
ON t.OBJECT_ID = c.OBJECT_ID

WHERE
c.name LIKE ‘%FieldName%’

ORDER BY
schema_name,
table_name;
[/sql]

This query has been extremely helpful in helping me track down data.  Without this tidbit of information I’d probably still be looking for data the boss asked for months ago.

[csharp] var url = View.PopulateFullLink(Navigator.ResetLink(Model)); [/csharp]

Can anyone tell me what data type url is?  Is it a Uri?  Is it a string?  I don’t know:  you cannot tell from just looking at that code.  I understand that in Visual Studio I can figure out the data type fairly easily by hovering over the variable or by using any of the other contextual support tools the IDE offers.  Unfortunately this code was posted on the Internet which does not offer that sort of functionality.  Has the development world forgotten that not all code is viewed inside of an IDE?  In the end it turns out that url is a string.  Would it really have been that much more typing to explicitly declare the data type instead of using var?

var has its place and that place is with anonymous types (which, frankly, I don’t use much outside of Linq).  The var keyword is very well suited for that purpose:  by definition anonymous types don’t have a type name that you could use to declare the variable.  I accept that I’ve lost the Hungarian notation battle; however, I’m not willing to completely let go of any mention of a variable’s data type anywhere in the code.  Give me something I can look at to determine a given object’s data type without having to depend on an IDE.  Some of us still look at code in Notepad (Notepad++ actually), code comparison tools, on the web, and applications not name Visual Studio.  Stop being so damn lazy… please.

The developers at Microsoft thought it would be a great idea to automatically enable JavaScript debugging for you when you launch your site from Visual Studio regardless of what settings you have in Internet Explorer.  While this may be handy for some, it’s a real pain in the ass for those of use that have a lot of scripting in our projects.  Unfortunately there is no simple setting in Visual Studio to get around this; however, there are at least two workarounds that I have found.

The first method is to enable Silverlight debugging for your project.  The script debugger and Silverlight debugger are mutually exclusive and only one debugger can attach to a process at a time.  This means that in order for the Silverlight debugger to attach to the IE process, the script debugger must be enabled.  You can turn on Silverlight debugger as follows:

• For Web Applications:  Project –> Properties –> Web – scroll to the bottom and check the Silverlight box
• For Websites:  Web Site –> Properties –> Start Options – again, scroll to the bottom and check the Silverlight box

The second method (which was actually the first method I found) is to actually modify the Visual Studio settings in the registry.  I’ve found that this seems to work for both Visual Studio 2008 and Visual Studio 2010.  You can find the original source of this information on MSDN website.  Given that this problem has existed since IE8 and Visual Studio 2008, I don’t know why they haven’t implemented a more elegant solution in Visual Studio 2010 and IE9 (i.e. go back to the way it was in IE7 where the setting in the browser was actually honored).

To disable all script debugging via the registry use a 32-bit command prompt (if you’re running a 64 bit flavor of Windows:  start –> run, c:\windows\syswow64\cmd.exe) to execute the following command:

reg add HKLM\SOFTWARE\Microsoft\VisualStudio\9.0\AD7Metrics\Engine\{F200A7E7-DEA5-11D0-B854-00A0244A1DE2} /v ProgramProvider /d {4FF9DEF4-8922-4D02-9379-3FFA64D1D639} /f

If you’re using Visual Studio 2010 instead of 2008, replace the “9.0” with “10.0”.  If you’re using Visual Web Developer Express then you’ll need to replace “Visual Studio” with “VWDExpress”.  To undo what you’ve just done, use the following command:

reg add HKLM\SOFTWARE\Microsoft\VisualStudio\9.0\AD7Metrics\Engine\{F200A7E7-DEA5-11D0-B854-00A0244A1DE2} /v ProgramProvider /d {170EC3FC-4E80-40AB-A85A-55900C7C70DE} /f

The last time I did socket programming it was in C using the Win32 API.  Learning to do the same thing with the .Net framework has presented some unexpected challenges.  Given the number of users the system I developing might have I decided to take the Asynchronous approach using the BeginXXX and EndXXX methods with callbacks.  As long as you’re familiar with how .Net handles asynchronous callbacks, using the event driven approach really isn’t that hard to get going.

However, I was surprised to find that your reads and writes won’t always match up 1 to 1.  If your system sends several messages quickly, then those multiple calls to BeginWrite might result in just a single ReadDataComplete event on the other side with your single buffer containing several messages.  Although this is pretty obvious now, I didn’t see anything mentioning that this would happen in the examples I reviewed.  For the longest time I was wondering what on Earth was happening to my missing messages:  they were sitting in the buffer waiting to be read, I just didn’t know they were there.

Another lesson learned here was that MemoryStream grows in 256 byte increments (or at least it does on my machine).  If you write 24 bytes to a MemoryStream and then use MemoryStream.Length or MemoryStream.GetBuffer().Length you’ll most likely end up with something that is a multiple of 256 which is not the actual number of bytes you’ve written to the buffer.  To get the actual number of bytes you’ve written to the buffer I’ve found you can use MemoryStream.Position.  This method will give you the cursor position in the stream in bytes which should give you the number you’re most likely after.

[html]
<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
<param name="source" value="ClientBin/DeepZoomViewer.xap" />
<param name="background" value="white" />
<param name="minRuntimeVersion" value="3.0.40818.0" />
<param name="autoUpgrade" value="true" />
<param name="initParams" value="DeepZoomImageUri=/GeneratedImages/dzc_output.xml,value2=some-value" />
<a href="http://go.microsoft.com/fwlink/?LinkID=149156&amp;v=3.0.40818.0" style="text-decoration:none">
<img src="http://go.microsoft.com/fwlink/?LinkId=161376" alt="Get Microsoft Silverlight" style="border-style:none" />
</a>
</object>
[/html]

As you can see, the initParams parameter is used to pass values into Silverlight.  Multiple values are separated by camas.  You can then access these values from within your Silverlight application as follows (note: The values will come in as strings. You will need to convert the data type according to your needs):

[csharp]
private void Application_Startup(object sender, StartupEventArgs e)
{
this.RootVisual = new DeepZoomViewer();

if (e.InitParams != null)
{
string param_1 = e.InitParams["DeepZoomImageUri"];
string param_2 = e.InitParams["value2"];
}
}
[/csharp]

If you are using the asp:Silverlight control you can just use the InitParams attribute of that control as follows:

[xml] <asp:Silverlight ID="slControl1" InitParameters="param1=value1,param2=value2" runat="server" /> [/xml]

However, if you poke around the Silverlight 3.0 and 4.0 SDKs you’ll notice that the System.Web.Silverlight assembly is missing.  According to Pete Brown (and other resources), this control is no longer part of the core SDK and you should switch from using the server side control to using the object tag approach or a JavaScript based approach.

It turns out there are at least two ways to accomplish this goal: one is to name your root element and the other is to set the data context of your control.  I’ll show you both ways…

[xml]
<UserControl
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
x:Name="myControl">
[/xml]

You then access the property in your code behind like so:

[xml]
<TextBox Text="{Binding MyLocalProperty, ElementName=myRoot }" />
[/xml]

While this method is pretty easy to implement it isn’t without it’s shortcomings.  I believe that if you name your root element in your UserControl and then attempt to next multiple instances of your control in another control you’ll start to run into naming conflicts that will either keep your project from building or result in some odd runtime issues.  While this method works, I prefer the next method.

[xml]
<UserControl
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
xmlns:ic="clr-namespace:Microsoft.Expression.Interactivity.Core;assembly=Microsoft.Expression.Interactions"
xmlns:local="clr-namespace:DeepZoomProject"
x:Class="DeepZoomViewer.Silverlight.DeepZoomViewer"

DataContext="{Binding RelativeSource={RelativeSource Self}}"

d:DesignHeight="433"
d:DesignWidth="579">
[/xml]

You then access the property in your code behind like so:

[xml]
<TextBox x:Name="txtExample1" Text="{Binding MyLocalProperty}" >
[/xml]

The initial line of code to setup the DataContext property in your root element may look a bit daunting at first, but it makes binding to the actual property even easier than the previous method.  This approach has the benefit of not requiring you to explicitly name your control.

Binding to properties in your code behind is a pretty important functionality to have if you’re using an architecture that implements a controller or presenter pattern and yet it isn’t as clear how to properly do this as it should be.  I hope this helps you move on to more important challenges.

With the current job marked focused on web development, its been a little while since I last dabbled in game programming (I did some 3D engine development in OpenGL while in college).  With the growing interest in mobile applications I again have the opportunity to learn a new platform through game development.

Over the next few months I’ll be bringing the game I first made in C / C++ 12 years ago to the Android platform.  Although the game will be 2D, I’m still planning to use OpenGL (orthogonal projection).  While not using OpenGL would probably allow me to learn more skills that would be more applicable in the business world… screw it… I want to make a game.

I first learned C / C++ using noting but tutorials I found on the web and support from forums such as GameDev.Net (it was actually called something else at the time but I can’t recall what exactly).  I’m planning to tackle this project much the same way.  I haven’t visited GameDev.Net much since I registered back in ‘99; however, I suspect that’ll change soon.

As I learn more about developing games on the Android platform you can be sure that I’ll share bits and pieces of what I learn along the way (I’m considering release the game to the Android Market so I won’t be releasing full code).  It’s my turn to help other developers just as others helped me.

With all that said, the first useful thing I learned:  setting your window to be full screen can be done two ways.  You can set it in code or you can set it in the AndroidManifest.xml file.  According to Google, setting up your window in the manifest file is actually the preferred method.  Here is an example of setting up the manifest to get a full screen window that will hide the notification bar (notice the addition / modification of the android:theme attribute in the application element):

[java]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="ph.testgame1"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
<activity android:name=".defaultActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
[/java]

If you really want to set it in code instead of the manifest you can use the following code in the onCreate method of your start up activity:

[java]
this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN );
[/java]

Expect the next Android game programming article to be more how-to and a lot less story.

Throughout school (all the way through college) I continued to fold various models I had memorized from books barrowed from the Kent Free Library (primarily Origami for the Enthusiast and Animal Origami for the Enthusiast both by Montroll).  If it weren’t for those trips to the library with my grandmother I’m not sure my interest in Origami would have ever gone beyond what Rouhollah had shown me.  For some reason I can’t remember where I put my wallet but I have no trouble memorizing the 50 or so steps required to fold an origami spider:  I’d prefer to be able to remember where I put my wallet.

For me origami is a hobby and a way to work through difficult problems or to pass the time.  For others origami is an art form and when you see their work there is no denying that origami is indeed an art.  I’m sure that as time goes there will be more posts featuring both models I fold and the work of others that are sure to amaze (or at least inspire).