If you haven’t heard of Continuous
Integration yet, it’s the practice of setting up an automated system
that rebuilds projects automatically whenever someone commits a new change
to your source code repository. It ensures that whatever is in your
repository builds and runs: automated builds usually involve compiling,
running unit tests and packaging the installer.
To do continuous integration, you need a tool that monitors your source code
repository and starts the builds – a continuous integration server. My weapon
of choice is TeamCity, a free CI server
written in Java with first-class support for .NET and its toolchain
(like NAnt, NUnit,
NCover or PartCover).
TeamCity is pretty easy to deploy – the Windows package has an installer
which leaves you with a fully working server after just a few clicks and even
the Linux package is pretty simple to deploy: Download, unzip, run
runAll.sh and you’re done. To properly integrate it into a Linux
server (so it will come back up after rebooting and can be reached via HTTP
without having to run either Apache or TeamCity on a non-standard port),
you’ll need to run your own Tomcat server.
Courier not only is an excellent mail server, it also ships with a mailing
list manager that can be used to build mailing lists without relying on
a third party provider (which usually has the bad habit of adding
advertising text to the emails being forwarded).
Here’s a small tutorial that explains how to set up a new mailing list
Welcome to day 2 of the XNA Game Architecture series!
I have thought hard about whether I should just assume a certain level of object
oriented programming knowledge in this series. People picking up these articles likely
already have some knowledge about objects and design, so I settled on a quick
run-over of the principles that hopefully won’t bore the seasoned developers and
provide a good reference for people just starting out!
If you already know all this, feel free to skip ahead until it becomes interesting
again or to the next chapter ;)!
Please excuse the current flurry of Linux articles. I’m moving servers and
this is my way of writing notes to myself and possibly helping out others.
Normal service will resume shortly 😉
This article is a follow-up to my guide on Installing
Courier on Gentoo. As long as you have a working Courier installation on
your system, there should be no issues following this guide.
Running a mail server without some kind of spam filtering is just insane these
days. SpamAssassin is a nice solution, especially
if you run SpamAssassin during the SMTP transaction to reject spam while it is
being uploaded to your server.
On my previous system, I had used qmail
(netqmail actually, which is qmail with
some patches). Qmail is moderately difficult to set up and in its 3 years lifespan
on my system, it has broken down on several occasions. That’s why I decided
to use another mail server when I moved my domains to a different system.
Because the Courier IMAP server has never let
me down before, I decided to give the Courier Mail Server a chance. Lots of
people are using Courier IMAP to access their mail but Exim,
Postfix or Qmail to accept incoming emails.
Even the Gentoo Wiki contains various
HowTos for these combinations, but not a single one for a homogenous Courier
setup. After trying out Courier, I don’t see why, so this is my attempt to rectify
the situation (and to remember what needs to be done for the next time I’m moving
my domains to another system!)
If you want to download torrents on your Linux system, there are several clients
to choose from. One of the nicest and fastest clients is rTorrent.
It is full-featured, supports encryption, dynamic host table exchange and achieves
fantastic download speeds.
But its best feature probably is that it isn’t bound to any windowing toolkit. You
can install one of its GUI frontends to manage it on your fancy KDE 4 desktop machine,
but you can also run it on a headless system and manage torrent from a text-only
console. And if you happen to run it on a home server like me, there’s
wTorrent, a beaufitful AJAX-driven
web frontend that allows you to manage your torrents in your browser.
Installing wTorrent isn’t the easiest thing to do, so, as when I tried to
get the best
out of my SSD, I decided to write this small article explaining how to do it.
I’m using Gentoo Linux, but it shouldn’t be too hard to
apply this article to another Linux distribution.
Welcome to day 1 of the XNA Game Architecture series! We’re about to
create a small 3D Shoot ’em Up using the principles
of modern software architecture.
If you missed the
introduction, this series is about the architecture of games. Instead of
focusing on a single concept, we’ll be focusing at how it all comes together and
how you can keep your game’s code manageable and clean. You’ll be looking over
my shoulder as I write a small game and explain why I do things one way and
not the other 🙂
Today, I will start the project by creating a development tree that
contains the actual XNA project and some third-party libraries I’m going to use
within the game. Normally, I would add those libraries as I go, but I’ve got a
pretty clear idea for this project and it will be easier for you because I can just
package them all in a handy zip archive which you’ll find at the end of this article.
I’ve got a small home server with a software RAID-5 for storing my files. It also
runs a few virtual machines and acts as a NAT router for internet access. Nothing
expensive, just some Frankensteinian patchwork built from old hardware left over
when I upgraded my workstation. Nevertheless, I granted it a brand new
Intel X25-M SSD last week.
Did I mention that this server is running Gentoo Linux? I thought this would be
a good time to do a fresh install and get everything right that might have gone wrong
the first time. Besides, installing Linux always is an interesting (and masochistic)
experience, especially when your chosen distribution has no installer 🙂
Because getting my partitions and file systems aligned also proved to be difficult
task, I thought why not make a small article out of this!
There are a lot of XNA tutorials out there that explain the basics –
how to display a sprite, how to do collision detection and how to
render a bunch of colorful particles with additive blending. But there
aren’t many articles that explain to you how you’re supposed to put it
all together – how to structure a game so that it is easy to extend and
remains manageable when the amount of code begins to grow.
The discipline that deals with this issue is called software architecture.
Like programming, or any other creative process, it relies a lot on
tacit knowledge –
finding a good solution without first running down an alley of dead ends
(that you can identify using the Principles
of Object-Oriented Design) requires a lot of experience.
What I will do in this series is let you look over my shoulder as I design
a small game and try to explain my motivations for choosing one design
over another while I do so. This will give you a solid starting point and
an understanding of the design process that you can apply to your own
When I release components, example code or even just helper classes, I often
tout 100% test coverage as a feature. Which (as I probably also state often
enough :P), means that my unit tests execute 100% of all lines in the source code.
But what advantage does this actually bring to a developer, and, just as
interesting, what does having complete test coverage not mean?
For people practicing true TDD (test first -> red, green, refactor),
100% coverage is nothing unusual, though even they may decide to not write tests
for all invalid inputs possible: if a piece of code satisfies all the tests and
the tests cover everything the code should do, it’s enough. If you’re
building a library on the other side, the use case of a customer providing invalid
inputs will be a valid concern worthy of a test.
I, however, am currently adding unit tests to an existing code base and I decided
to go for 100% test coverage. In this short article, I will explain why I see
complete test coverage as a worthwhile goal, what effect going for that level of
test coverage has on a project and what it says about the code.