Krehbiel Tech

Fed up with SyncToy

2008-11-17T03:44:11Z

I've been trying to use Microsoft's SyncToy for my directory synchronization tasks, and I'm just about fed up with it. For reasons I can't fathom, it routinely "forgets" what to synchronize. I frequently synchronize to and from a USB stick, and I find that SyncToy usually wants to copy far more files than have actually been changed. Like I'll make a couple of changes to some files on the stick, and then for some reason SyncToy thinks it needs to re-copy all kinds of files from both the stick and the computer. So I end up having to copy files manually from one side to another. It's a bit aggravating.

I guess I'm going back to TreeComp, a freeware program I first used in about 2003. It looks godawful but still works better and faster than anything I've seen. We'll see how it goes on Vista.

Disabling Pluralization in Visual Studio

2008-11-11T22:51:14Z

I noticed with some concern that the Visual Studio 2008 designer puts an "s" on the end of table names when it builds LINQ to SQL classes. If you want to disable that, open Tools/Options, go to the Database Tools O/R Designer page, and change "Pluralization of names" option to false.

Note that if you have already generated pluralized classes, you have to force the designer to regenerate the classes by actually changing the names to some temporary value, build, then change them to what you really want and rebuild again. Otherwise, if you leave the name the same, it assumes it doesn't need to regenerate the classes.

Azure and C# 4.0 at PDC

2008-11-07T02:46:53Z

Most of the buzz from Microsoft's PDC is about Azure and C# 4.0. I don't usually pay too much attention to bleeding edge Microsoft technology until it might actually be used in real-life situations, but I thought I'd break from tradition and peek at these two shiny new things.

Windows Azure Services

There isn't a lot of concrete information available on Azure yet, so there isn't much to say about it. Conceptually, it's a specialized web hosting service from Microsoft for your ASP.NET web apps. It's specialized because it's designed for the large numbers of processors and mass storage requirements needed for large-scale enterprise applications (large-scale as in, for example, Amazon or Facebook or Google).

From a programmer perspective, I gather that the main difference from a regular web app is that the details of the OS and hardware your application is running on is abstracted away from you. For example, instead of your web app reading and writing files with the System.IO namespace, you'll use SQL Services to read and write "blobs."

I personally can't think of any applications I might use Azure for. (Do we really need another Amazon?) It would have to be something mandated by a pointy-haired boss-type.

As for the "cloud computing" part of it; well, I've said before that I don't much care for cloud computing. Besides all the privacy and data loss concerns, the bottom line is that "the cloud" is meant to make life easier for developers, not users. As a user, I might store a copy of something in the cloud for convenience, but I would never use the cloud as my main work area.

C# 4.0

Recall that C# 3.0 gave us query syntax, extension methods and the "var" shortcut, and tried to change us to functional programmers with lambdas. With the possible exception of LINQ, I personally have not yet encountered a situation where I thought any of those things would make my code better.

So what can we expect from C# 4.0? Among other things, dynamic types. That's right, in the continuing effort to put back all the bad things we didn't like about VBScript and C, the variant and void* is back. For all those people who simply can't decide how to declare your variables, you can now circumvent all pre-planning and simply write, "void myfunction( dynamic myparam )". Is that parameter a string? Is it an int? Is it a custom object? Is it an array? Who knows? Guessing is half the fun!

I kid of course. You could assume it's an object of some kind.

I'm sure there are situations where it is more convenient to use "dynamic" than an interface. (Just like there were plenty of occasions to use void* types and variants.) Offhand, I can't think of any, but I'm sure they're out there somewhere.

The problem I see with dynamics is that, as with any "advanced" language feature that circumvents the "KISS" principle, it leaves the door wide open for the inexperienced to abuse it unmercifully. When you go too far down that road, you end up with Perl, a language almost entirely composed of symbols.

It looks like almost all of the new C# 4.0 features were designed to improve COM Interop, which is something I don't have much use for. I have exactly one COM component project, and if I ever need to use it again, I plan to upgrade it to managed C++.

I do like the idea of finally having optional parameters, though. That's something I'd use (sparingly!), as long as it compiles down to the .NET 2.0 CLR.

MMO Prototype Progress

2008-10-20T12:36:11Z

Here's the progress I made on my MMO engine this weekend:

I should probably figure out how to do a screencast or something; it's more impressive when it's moving. :)

Moving C++/CLI Properties Out Of Headers

2008-10-18T20:58:51Z

A while back I railed against C++/CLI for its nonsensical inability to separate property implementations from the header file. Well, it turns out you can do it -- it's just not widely reported. Almost every example of a C++/CLI property shows it implemented in the header file. But thankfully I stumbled upon an article about this very subject: Splitting Properties Between Header And Implementation Files In C++/CLI.

Old Class.h:

    7 public ref class Effect
    8 {
    9 private:
   10    Route^ componentChain;
   11 
   12 public:
   13    property Route^ ComponentChain
   14    {
   15       Route^ get(void) { return this->componentChain; }
   16    }
   17 };

New Class.h:

    7 public ref class Effect
    8 {
    9 private:
   10    Route^ componentChain;
   11 
   12 public:
   13    property Route^ ComponentChain
   14    {
   15       Route^ get(void);
   16    }
   17 };

New Class.cpp:

   24 Route^ Effect::ComponentChain::get(void)
   25 {
   26    return this->componentChain;
   27 }

The key is the Class::Property::get and Class::Property::set syntax that I'd not seen documented anywhere before. Hopefully now that there are two articles about this, it will move up higher in Google searches.

Evaluating MMO Engines

2008-10-18T16:54:19Z

Before I embark too far on the insane idea of writing my own MMO engine, I thought it would be instructive to peek at some open source engines out there (gathered from the first few pages of a Google search).

At this point I am mainly interested in the specifics of their network implementation, because that is really the foundation on which everything else is built. For reference, my design so far is leaning toward UDP sockets with variable-length packed binary structures, conceptually similar to the Quake network protocol if I remember right. The idea is to maximize CPU efficiency (by avoiding expensive serialization and parsing routines) and minimize bandwidth requirements (by avoiding bloated serialization and parsing routines).

Black-Crystal. (C#.) No code releases that I can find, which is too bad, because I would have loved to see their .NET implementation.

Genecys. (C, CVS Repository.) The source code is not very easy to read and not very well commented, but I gather (from server/network.c and server/ninterface.c) that the design uses simple text commands over TCP streams. This is precisely what I don't want to use, because I don't think it will scale very well.

OpenMMOG. No code releases that I can find.

PlaneShift. (C++, SVN Repository.) This is an actual MMO that you can play, which makes it a compelling test case. After perusing the source repository, it looks to be using UDP sockets (see common/net/netbase.cpp) and message structures similar to my design. I am validated! (Although, honestly, it's not so much mine as it is John Carmack's idea from the 1990s.)

Ryzom (NeL). (C++, SVN Repository). I can't tell what it's doing because the repository gives me internal server errors ("Rails application failed to start properly" -- figures :). Based soley on the filenames in the source code, there appears to be UDP and TCP code. I'm very interested in seeing what it does because it purports to be able to update hundreds of entities in an area with modest bandwidth usage. I have a number of ideas of my own in that department, and I'm curious if they are similar.

Torque MMO Kit. (Python, Repository). (I am not positive, but I think this is actually descended from the original Tribes game engine.) This appears to be one of the most mature codebases around, but I'm not a Python guy, so much of this is foreign to me. I can't find any specific network layer -- I think it's probably embedded in whatever application parses the .cs files, but there's no source code for that. In any case, an entire implementation of an MMO game is there, so it's a good reference to have handy. It would be interesting to try Minions of Mirth to see how well the engine works.

vbGORE. (VB6, Downloads.) Yeah, I know, it's written in VB6, but I downloaded it anyway. It actually looks surprisingly mature. Digging into the GOREsock\GameClient\GOREsock.ctl code reveals they're using TCP byte streams. I can't make much sense of the rest of the codebase, but there might be something useful in there somewhere. I'm not going to install VB6 again to look at it in depth, though.

WorldForge. (C++, Downloads.) WorldForge appears to be well-known, but I can't find any real games based upon it. It's broken into a number of distinct libraries -- the network library is called "Atlas," and it appears to be a highly generalized API, which usually means scope creep from trying to be everything to everybody. It looks like it's using a TCP stream and serialized objects, encoded as XML or "packed" (see the Atlas::Codecs namespace). Unfortunately, the code looks like it's getting close to the "big ball of mud" stage of entropy. :)

New Collection vs. Collection.Clear

2008-10-18T17:03:22Z

Quick, which one of the following implementations is faster to use in a time-critical section of code:

Implementation 1:

   25 for( int i = 0; i < iterations; i++ )
   26 {
   27     List<int> myList = new List<int>();
   28     for( int j = 0; j < 1000; j++ ) myList.Add( j );
   29 }

Implementation 2:

   34 List<int> myList = new List<int>();
   35 for( int i = 0; i < iterations; i++ )
   36 {
   37     myList.Clear();
   38     for( int j = 0; j < 1000; j++ ) myList.Add( j );
   39 }

Answer: The second one, by about 33%.

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Diagnostics;
    4 using System.Text;
    5 
    6 namespace CollectionSpeedTest
    7 {
    8     class Program
    9     {
   10         static void Main( string[] args )
   11         {
   12             long time1 = Stopwatch.GetTimestamp();
   13             Method1( 1000000 );
   14             long time2 = Stopwatch.GetTimestamp();
   15             Method2( 1000000 );
   16             long time3 = Stopwatch.GetTimestamp();
   17 
   18             Console.WriteLine( "Method1: {0}", time2 - time1 );
   19             Console.WriteLine( "Method2: {0}", time3 - time2 );
   20             Console.ReadLine();
   21         }
   22 
   23         public static void Method1( int iterations )
   24         {
   25             for( int i = 0; i < iterations; i++ )
   26             {
   27                 List<int> myList = new List<int>();
   28                 for( int j = 0; j < 1000; j++ ) myList.Add( j );
   29             }
   30         }
   31 
   32         public static void Method2( int iterations )
   33         {
   34             List<int> myList = new List<int>();
   35             for( int i = 0; i < iterations; i++ )
   36             {
   37                 myList.Clear();
   38                 for( int j = 0; j < 1000; j++ ) myList.Add( j );
   39             }
   40         }
   41     }
   42 }

Results:

Method1: 20962096146
Method2: 13987606779

Me vs. the MMO Engine

2008-10-16T22:59:15Z

So I decided to write an MMO game engine*.

No, really.

Okay, I know, I know, this is the fifth or sixth time I've started a game engine project like this, and it will probably end up the same as all the others: Nifty ideas, but without considerably more time and structure and funding -- and, you know, an actual game idea -- it will end up in source code purgatory, picked over for an occasional gem of an idea but otherwise left to rot.

Why an MMO and not something simple like, say, Space Invaders? Well for one thing I've already written a couple of different 2D game engines (now residing in purgatory) so there isn't a lot to explore there. Beyond that, MMOs are more interesting to me because they have a much broader variety of technologies to explore.

As usual, I'm going to build most of the framework with .NET since that's the quickest way for me to get a prototype up and running. I'm not planning to use any third-party game engines (Not Invented Here!), but I do want to use a 3D rendering engine for the client (which just by itself represents a whole set of challenges). And by the way, no, I still don't have a game idea (well, that's not entirely true, but certainly nothing more than a vague idea) -- I'm only interested in the underlying technology at this point. And if anyone is reading this that does have a game idea -- no, I'm not interested in developing your game (unless there's a decent salary attached, of course). This is purely an intellectual exercise.

This should keep me busy until... well, until the next shiny bauble comes along to grab my attention.

* If you don't understand the ramifications of that statement, it's roughly equivalent to me saying, "so I decided to memorize the encyclopedia" or "so I decided to perform a heart transplant."

Sitemap.xml and Google Webmaster Tools

2008-10-14T22:05:18Z

I just read about Sitemap.xml on Coding Horror. I'd never heard of it before (yeah, I'm not exactly wired into the whole SEO thing). Anyway, I just implemented a site map for my page, for what it's worth.

This also led me to Google's nifty Webmaster Tools page which, again, I'd never seen before. I've made a few small tweaks to my page titles to be a little more Google-friendly.

Sorry IE7 Users

2008-09-26T23:02:29Z

By the way I'd like to apologize to anyone who has viewed my site recently with Internet Explorer 7. Sometimes it rendered very badly, randomly writing text all over the place, shifting boxes around and generally looking ugly (see below). It had something to do with an overflow:hidden CSS attribute in the rounded boxes, which apparently is not well liked by Internet Explorer. I had to implement one of those "conditional comment" hacks to use an alternate style sheet for Internet Explorer browsers.

Finally != Inevitable

2008-09-19T12:49:28Z

For future reference: I had always heard that there were cases where finally blocks were not run. The other day I actually witnessed one of those situations: In a .NET console app, if you hit CTRL-C to exit the application, finally blocks are not executed. Fortunately garbage collection will still handle standard cleanup of objects for you (at least I assume so). But if you need to do something special you have to use the System.Console.CancelKeyPress event, like so:

System.Console.CancelKeyPress += delegate { Cleanup(); };

Be careful because it runs in a separate thread -- the main thread is not interrupted and won't actually stop until the CancelKeyPress handler returns.

Unfortunately, I found no way to handle the situation where the user clicks the close button (the red X) on the console window. It skips both CancelKeyPress and all the finally blocks.

Agile Wall

2008-08-29T20:52:50Z

I learned a new software development term the other day: "Agile Wall." For those of you who aren't into renaming things that already have names just to sound more important, it is: "A bulletin board with project notes all over it." Okay, okay, the notes are supposed to be arranged into three columns for "todo," "in progress," and "done." Yeah, I can see how it's a totally different concept now.

Opera Road Test

2008-08-27T03:45:41Z

Previously I wrote about Opera 9.5. Since then, I've been using it for almost all of my browsing at home (at work we still have to use IE6 *rolls eyes*). So far I've only encountered two real problems with it.

Of course, every now and then, you still run across some sites that refuse to work with anything but Internet Explorer or Firefox. Most of the time it's a bank or some other kind of financial institution. (I find it somewhat ironic that banks usually have the worst, most incompatible, most insecure web sites around.) It's not really a problem, but it is sort of annoying to have to load up another browser. It'd be nice if Opera had an "Open Link in Internet Explorer" option. Oh, hey, a quick Google reveals there is a way to do just that. Sweet.

More annoying is the way that Opera handles RSS feeds and XML. As a programmer, I look at XML all the time. And as a programmer who has written software to read RSS feeds, I look at RSS feeds all the time, too. Opera does an admirable job of recognizing RSS and offering to add feeds to its internal RSS reader like other browsers, but that's not what I want it to do. When I click on an RSS feed link, I almost always want to look at formatted content or at the underlying XML. Unfortunately Opera does a miserable job of displaying XML in the browser. It crams everything together into a big page of unreadable mush. So for this I'll also have to use the aforementioned Open in Internet Explorer menu.

GhostDoc Redux

2008-08-27T03:35:50Z

I had previously written that I tried GhostDoc but removed it because it didn't write very useful comments. Well I re-loaded it today because it does have one very handy feature: Adding comments to classes that implement interfaces. It's incredibly tedious to copy comments from the interface code to the class code, but with GhostDoc you just have to right-click on the class member and hit "Document This" and it will automatically bring the comment from the interface to the class. Pretty cool.

LINQ query syntax

2008-08-26T01:47:36Z

I'm starting to learn a little bit about LINQ. I am only doing this because I was starting to learn a little bit about the forthcoming ASP.NET MVC Framework by watching some handy screencasts, and the authors of the framework seem to think that we should all be using LINQ, too, so amidst the discussion of the MVC Framework they throw in quite a lot of tutorials about LINQ.

Based on all the hype built up around it over the years, you'd think that LINQ was the second coming. It's nice, but it's not quite all that. To understand what it really is, first let me show you a simple SQL query:

SELECT * FROM customers WHERE state='VA'

This query will return every customer record where the customer's address is 'VA.' It can't get any simpler than that.

Now you might be wondering why invent LINQ when SQL works just fine? Well, the problem for us application programmers (as opposed to people writing stored procedures or typing queries into Management Studio) is that we have to do some extra work to send that query to the database and get back results in a manageable format (namely, in a collection of objects instead of a flat stream of bytes). We have to write code that looks something like this (super-simplified for illustration):

SqlCommand command = CreateCommand( "SELECT * FROM customers WHERE state='VA'" );
SqlDataReader data = command.ExecuteReader();
List<Customer> results = new List<Customer>();
while( data.Read() ) {
Customer customer = new Customer( data );
customers.Add( customer );
}

That will get us a collection of Customer objects that we can work with. It's not particularly difficult, but it's kind of ugly and awkward. Normally we try to hide those awkward details behind a data access layer so it doesn't distract us from our application logic. With the details hidden, we might end up writing application code that looks like this:

IEnumerable<Customer> customers = datalayer.GetCustomersFrom( "VA" );

That worked fine, but now we have a whole new paradigm in LINQ. Now we don't have to wrap our queries with extraneous code. Here is the same concept as the above SQL query, written as a LINQ query:

var customers = from c in db.Customers where c.State=="VA" select c;

The cool thing is you can put that right inline with your source code, and what you get back from it is "customers" -- an enumerable collection of Customer objects.

How's it work? Well, when you get right down to it, it's basically just another data access framework that hides the messy details of querying the database, just like all the other data access frameworks out there. The only things that are different about this one are, 1) it's built by Microsoft, and, 2) it's integrated right into the language. (Those are two powerful incentives to use it, by the way.) But there's nothing really magical about it -- behind the scenes, LINQ to SQL queries are transmogrified into method calls that eventually build SQL statements, send them to the database, instantiate Customer objects, and populate them with results from the query.

But enough of that. Let's talk about the LINQ query syntax itself. I find it puzzling. For example, in LINQ query syntax, we have to specify where to look before we specify what we're looking for. In SQL, it was a pretty straightforward "select stuff from here." But in LINQ, it's backwards -- it's "from here, select stuff."

We also have to specify the search criteria in the middle. In SQL, it was "select stuff from here with this criteria." In LINQ, it's "from here, with this criteria, select stuff."

Furthermore, we have to reference the name of each row entity, as in "from each row named x in here, select stuff." I can only speculate that that becomes more of an asset in complex queries, but in my experience, simple queries are much more common than complex queries, so it seems like needless redundancy to me.

In short, LINQ is a handy shortcut if you're working with Microsoft .NET 3.5 technology and nothing else. (It's almost entirely worthless if you aren't.) For myself, I can see the benefit in understanding the basics, and I'm sure I'll enjoy working with it where possible, but I can't see myself expending much effort in becoming an "expert" on LINQ.