class File 
    begin
      def self.find(dir, filename="*.*", subdirs=true) 
        Dir[ subdirs ? File.join(dir.split(/\\/), "**", filename) : File.join(dir.split(/\\/), filename)  ].select { |x| File.file?(x) } 
      end
    end
  end

Ruby is amazing that you can Monkey Patch code. Having just started with Ruby yesterday, and I’m sure I’ll find a better to do this in the future, but for now, this is the best I have. This started from a simple script. Notice the little juice at the end that only returns “real files” according to the File API, now it behaves nicely.

sqlfiles = File.find(Dir.pwd, "*.sql")

public ApplicationContext Initialize() {

        this.container.Configure(c => c.AddRegistry<SomeStructureMapRegistry>());
        this.container.Inject(this.container);

        ApplicationSettings settings = new AppSettingsParser().Parse(this.appSettings);
        this.container.Inject(settings);

        this.attachErrorHandling();

        var context = this.container.GetInstance<AppContext>();
        return context;
    }

Of course, you use it something like this:

private static void Main() {

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        Application.Run(new BootStrapper(ConfigurationManager.AppSettings, new Container()).Initialize());
    }

• would integrate with FireFox, or at least import existing passwords
• is open source (security programs that cannot demonstrate how they are safeguarding your info should not be trusted)
• is cross-platform capable (WinXP, Win7, OSX, Linux)

Fortunately, I found KeePass. It can run using Mono under OSX, but it can be a hassle to run. The default way of doing that is:

• Open Terminal and navigate to KeePass directory
• Typing: mono KeePass.exe

We can do this:

• Install Mono Framework
• Download latest version of KeePass 2.x and unpack it
• Open Terminal and navigate to unpacked KeePass folder

• Run the following command:

  macpack -o:. -m:winforms -r:/Library/Frameworks/Mono.framework/Versions/Current/lib/ libCocoaSharpGlue.dylib -r:KeePass.chm -r:KeePass.XmlSerializers.dll -r:KeePassLibC32.dll -r:KeePassLibC64.dll -r:License.txt -r:ShinstUtil.exe -r:./XSL -n:KeePass -a:KeePass.exe

This will create a KeePass.app file that you can drag into your \Applications folder, and you should be all set.

Make your [ui] section edits to point to a file (name is up to you):

[ui]
...
ignore = %userprofile%\.hgignore
...

Finally, make sure you have an .hgignore compatible file. This is what I’m using right now:

syntax: glob
*.o
*.lo
*.la
#*#
.*.rej
*.rej
.*~
*~
.#*
.DS_Store
*.suo
*.user
*.webinfo
[Bb]in
*/[Bb]in
[Oo]bj
*/[Oo]bj
*.[Bb][Aa][Kk]
*.~??
*[Tt][Mm][Pp]
_vti_txt
*/_vti_txt
_vti_script
*/_vti_script
_vti_pvt
*/_vti_pvt
_vti_cnf
*/_vti_cnf
_private
*/_private
.~*
*.~*
[Rr]elease
*/[Rr]elease
[Dd]ebug
*/[Dd]ebug
[Aa]nkh.[Ll]oad
*/_ReSharper*
_ReSharper*
*resharper*
*.Cache
*.StyleCop
*.ReSharper
obj/
bin/
*.ncb
*.suo
_ReSharper.*
*.resharper.user

Granted, this could just mean I’m a crappy OO designer, but I like to think it’s more from hammering out the design as I’m working on the problem!

So, I might have a code base that has unused interfaces lying around, and I just want to clean those up.

With NDepend, you can use Code Query Language (CQL) to search for items of interest in your code base. Very cool.

Here’s the CQL for finding Interfaces that have no implementations.

[csharp] // <Name>Find interfaces without Derivatives</Name> SELECT TYPES WHERE IsInterface AND NbChildren == 0 [/csharp]

Rather than a rehash, go check the article, another bang-up job by Scott. What is intimidating is all the analysis you can do with this tool, it makes you feel like you should be doing something smart with it.

For that problem, I can’t say I have a good solution for you. Perhaps if I was in charge of more than a handful of developers as a architect, and coded less frequently, this tool would feel more comforting to me. In my current capacity as a dev lead, working daily in .NET with a team of other senior dev’s, I haven’t quite entered that “Zone of Pain”.

One thing I give kudo’s to the NDepend team for is their Videos and Tutorials and comprehensive help. Clearly I’m not the only one some confusion on how to make the most of this tool and it’s great to know that the product team has put serious work into making the tool discoverable and useful.

Check out this Welcome Screen:

Notice the real estate devoted to “Getting Started”, a very nice touch.

Another nice feature, is an ability to call out NDepend from Visual Studio and Reflector, which is my normal code exploratory/analysis tool.

[sql] SELECT t.name, LTRIM (STR ( SUM ( CASE WHEN (index_id < 2) THEN (in_row_data_page_count + lob_used_page_count + row_overflow_used_page_count) ELSE lob_used_page_count + row_overflow_used_page_count END ) * 8, 15, 0) + ‘ KB’) AS DataSize FROM sys.dm_db_partition_stats s INNER JOIN sys.tables t ON t.object_id = s.object_id GROUP BY t.name [/sql]

When doing IMPORT or COMMIT operations using Subversion, we can receive a message like “Inconsistent line ending style”.

Particularly when IMPORTING, this can be a frustrating occurrence, with a host of hints provided online, but I couldn’t find anything but “brute force” approaches of converting EOL symbols by touching each file.

I use [auto-props] in my svn config file, and this is both part of the problem and the ultimate solution.

The latest occurrence happened when IMPORTING several XML files into a Repository. The confusing part is many of the XML files reported success, and then SVN hit an XML file with a different EOL style than all the others.

My auto-props entry used to be: [plain] *.xml = svn:mime-type=text/xml;svn:eol-style=native;svn:keywords=Date Revision[/plain]

Here’s my solution (svn config file): [plain] [auto-props] *.xml = svn:mime-type=text/xml;svn:eol-style=CRLF;svn:keywords=Date Revision [/plain]

[plain] [miscellany] enable-auto-props = yes [/plain]

Hopefully this helps you out as well.

throw new NotImplementedException();

or

// TODO:

Did you know that Resharper provides support to find those elements quickly?

When using the Visual Studio keyboard mappings, you can bring up the To-do Explorer with [Ctrl+Alt+D] or click on the Resharper > Windows > To-do Explorer.

For futher tweaking, check out the “To-do Items” in the Resharper Options window. It provides full RegEx capability for creating your own patterns!

• Having certificates that are older than most of my children
• Seeing the following Roadmap on my cube wall
• Not moving forward on any of this

You may ask why of course, but I’ll leave that justification for another post.

So, the ultimate goal is MCPD: Enterprise Developer and MCITP: Database Developer 2008.

First, I must attain MCAD.NET status by passing:

• Exam 70-316: Developing and Implementing Windows-Based Applications with Microsoft Visual C# .NET and Microsoft Visual Studio .NET
• Exam 70-320: Developing XML Web Services and Server Components with Microsoft Visual C# .NET and the Microsoft .NET Framework

Then, a “simple” All-In-One upgrade exam to attain MCPD: Enterprise Developer:

• Exam 70-552: MCAD Skills to MCPD Windows Developer by Using the Microsoft .NET Framework

Then, I need two more exams:

• Exam 70-433: Microsoft SQL Server 2008, Database Development
• Exam 70-451: Designing Database Solutions and Data Access Using Microsoft SQL Server 2008

If I have any energy left in the year, I’ll try to get my MCPD up to v2008 level by taking:

• Exam 70-568: Upgrade: Transition your MCPD Enterprise Application Developer Skills to MCPD Enterprise Applications Developer 3.5, Part 1
• Exam 70-569: Upgrade: Transition your MCPD Enterprise Application Developer Skills to MCPD Enterprise Applications Developer 3.5, Part 2

The problem

When running NAnt script on my local machine “in developer mode”, everything runs fine. However, once it goes to TeamCity, it puts up a general error:

Could not include build file ‘X:\teamcity-BuildAgent\work\684ab6ff82f1a29a\build\foo.core.build’. Object reference not set to an instance of an object.

In the end, my offending entry was:

<fileset id="cube.load.files">
  
</fileset>

Here’s my NAnt file pattern. I use a set of local.properties.xml for a development machine. I also create a buildserver.properties.xml for the TeamCity run. Then I create a “wrapper” NAnt file that includes both the CORE build script as well as the *.properties.xml file for the given environment.

This has worked very smoothly in the past so this morning it was rather frustrating to receive the error. The inspiration for this methodology was inspired by Jean-Paul’s excellent NAnt series. I highly encourage you to check it out.

Back to the problem… When running under TeamCity, I get a failure to include a build file, but everything works when running on a development machine.

The Solution

Remove EMPTY elements from the XML-formatted NAnt file (or close them using shorthand). For some reason, it looks as if TeamCity’s NAnt runner is parsing those files before sending them over to NAnt (guessing here).

And once I cleaned up this empty element, it worked! Interesting how this yet another reason why XML is the bane of developers.

[xml] <fileset id="cube.load.files" /> [/xml]

There are many benefits to a Javascript framework, particularly JQuery. Take this example that I put inside my <head\> element: [xml] <script type="text/javascript"> $(document).ready(function(){ $(‘#deliciouslogin’).submit(function(){ alert("This to authenticate with Delicious and start retrieving Bookmarks into Google Gears database"); }) }); </script> [/xml]

This is the “Document Ready” function. This solves the problem of running your Javascript code before your page is done rendering on the browser. Also note how easy it is to hookup an “onsubmit” event handler. You use CSS-selectors to identify what HTML element(s) to apply to, and JQuery does the rest, figuring out the best way to accomplish that regardless of your browser. Great fun.

My elation quickly disappeared when I fired this sample up in FireFox 3, nothing happened when my <form>’s submit button was triggered. Frustrated, I quickly tried it in Safari (Mac), it worked fine. I switched to the PC and grumpy IE6, and again, no luck. So what’s going on?

It turns out that the inline JavaScript will be ignored if you close the element just prior in your <head\> section with the shorthand closetag />.

This doesn’t work: [xml] <script type="text/javascript" src="lib/jquery/jquery.js" /> <script type="text/javascript"> $(document).ready(function(){ // blah }) }); </script> [/xml]

This does work: [xml] <script type="text/javascript" src="lib/jquery/jquery.js"></script> <script type="text/javascript"> $(document).ready(function(){ // blah }) }); </script> [/xml]

Hopefully I will remember this in the future, as this is now the second time in two days I’ve wasted an hour or more wondering why my Javascript wasn’t activated.

JP writes: [csharp] Run.the<wire_up_global_error_handling>() .then<initialize_the_container_for_the_user_interface>() .then<initialize_the_user_interface_registry>() .then<initialize_the_ui_images_registry>() .then<initialize_the_main_menus>() .execute(); [/csharp]

Here are my humble comments:

• “Run” & “execute” seems redundant
• The underscores are nice to look at but CamelCasing is also easy to read (for me), and easier to type … I suppose if you’re using your AutoHotKey ninja tricks like JP does, this would be minimum overhead.

So, for the full comparison in code:

[csharp] Start.by<wireUpGlobalErrorHandling>() .and<initializeTheContainerForTheUserInterface>() .and<initializeTheUserInterfaceRegistry>() .and<initializeTheUiImagesRegistry>() .finally<initializeTheMainMenus>(); [/csharp]

Hopefully JP gets this via a trackback.

I’m excited to see this and already have my C# tax ($99) lined up for it’s official release!

I’m officially a convert from the CodeRush/Refactor Pro camp… I just found Resharper more discoverable than CodeRush.  CodeRush definitely has a slicker UI, but Resharper lets me work more like myself (renames/namespaces/interface-based architecture) in Visual Studio.

As I was looking at this again, it just started looking “smelly”. First thought, can we do this cleaner with Generics?

public IEnumerable AnimalsList() where AnimalType:class
{
  foreach (IAnimal animal in _animals)
  {
    AnimalType testAnimal = animal as AnimalType;
    if (testAnimal != null)
      yield return testAnimal;
  }
}

Oh yeah… generics are just the coolest thing.

But, this still smelled to me (I didn’t like all the filter code inside the function). Sprinkling some functional programming goodness (thank you Dustin), it turned into this.

public delegate bool FilterAnimalPredicate(System.Type type);

/// snip

public IEnumerable AnimalList(FilterAnimalPredicate filter)
{
  foreach (IAnimal animal in _animals)
  {
    if (filter(animal.GetType()))
    {
      yield return animal;
    }
  }
}

Admittedly, I have cheated … we are no longer using a Property, and hence the unit tests had to change. But I’d take this approach as it feels much cleaner.

Thanks again to Jeremy for sparking this post.

Here’s the final Test Code:

using System;
using System.Collections;
using System.Collections.Generic;
using MbUnit.Framework;

namespace MultipleIterators.Test
{
    [TestFixture]
    public class ZooTest
    {

        private static bool IsElephant(System.Type type)
        {
            return (type is Elephant);
        }

        private static bool IsZebra(System.Type type)
        {
            return (type is Zebra);
        }

        [Test]
        public void Can_add_elephants_to_the_zoo()
        {
            Zoo zoo = new Zoo();
            zoo.AddAnimal(new Elephant());
            int animalCounter = 0;

            foreach (IAnimal animal in zoo.Animals){
                animalCounter++;
            }
            Assert.AreEqual(1, animalCounter);
        }

        [Test]
        public void Can_add_zebras_to_the_zoo()
        {
            Zoo zoo = new Zoo();
            zoo.AddAnimal(new Zebra());
            int animalCounter = 0;

            foreach (IAnimal animal in zoo.Animals){
                animalCounter++;
            }
            Assert.AreEqual(1, animalCounter);
        }

        [Test]
        public void Can_get_just_the_zebras_out_of_the_zoo()
        {
            Zoo zoo = new Zoo();
            zoo.AddAnimal(new Zebra());
            zoo.AddAnimal(new Elephant());

            foreach (Zebra zebra in zoo.AnimalsList<Zebra>()){
                Assert.IsTrue(zebra is Zebra);
            }
        }

        [Test]
        public void Can_get_just_the_elephants_out_of_the_zoo()
        {
            Zoo zoo = new Zoo();
            zoo.AddAnimal(new Zebra());
            zoo.AddAnimal(new Elephant());

            foreach (Elephant elephant in zoo.AnimalsList<Elephant>()){
                Assert.IsTrue(elephant is Elephant);
            }
        }

        [Test]
        public void Can_get_just_the_elephants_out_of_the_zoo_using_predicate()
        {
            Zoo zoo = new Zoo();
            zoo.AddAnimal(new Zebra());
            zoo.AddAnimal(new Elephant());

            foreach (Elephant elephant in zoo.AnimalList(IsElephant)){
                Assert.IsTrue(elephant is Elephant);
            }
        }
    }
}

Why?  There are so many reasons, but maybe one of the biggies might be coming to an end…

Ed Bott of ZD Net is reporting that Service Pack 1 (SP1) of VISTA next year will not include the “kill switch”. You knew this one right?  If you do not activate VISTA in time, some functionality stops working… this gets more interesting if you’re not connected to the ‘net or experience a glitch.

I don’t know how much more evidence one might need to conclude that Microsoft’s latest operating system is not really hitting it’s mark, regardless of the hype otherwise.

Never heard of S3? Neither had I until visiting the Day of .NET in Arbor this past October. I happened to catch the tail end of Joe Klunk’s “Storage (and more) in the Cloud” session. He built a quick .NET application to push files up to Amazon’s Simple Storage Service (S3). Now that wasn’t mind blowing as I had done WebDAV operations back in the heady days of ASP, “classic”. What was mind blowing was the price for storage: $0.15 USD, per month, per GIG-a-byte.

Now the folks at JungleDisk has just made a program that even our mother’s can use to properly backup their systems. It’s a great connected world!

I’m not talking about using Visual Studio Team Edition for Professionals, like Jeff recommends… but I’ll try to provide a general approach to testing your SQL code, particularly stored procedures (sprocs).

In SQL processing, we have our classic CRUD operations, and those operations are impacted by combinations of existing data elsewhere in other columns, tables, databases, or servers. This is the single biggest challenge in the test as I see it.

Admittedly, I’m making the most of my current database architecture in this solution, and yet, I am having trouble imaging this not being a universal approach.

In my application to test, we are essentially a high-calculation, low-user interface SQL business engine. The calculations are all done in sprocs and they have been broken down into “blocks” of results. That is, Calculation B, will possibly take data results of Calculation A.

So here’s a basic diagram of this setup:

This approach allows a myriad of unit testing possibilities, but here’s my general approach. Using NUnit, each Calculation would have it’s own TestFixture and the TestFixtureSetup would execute the sproc. The TestFixtureSetup would also retrieve any external data that the calculation would need into member variables for the fixture. Then, each of the Test’s would look into any external data, WIP table(s) and final Calc table(s) to determine if it passed or not. This is my first toe in the TDD pond for SQL applications.

I promise to figure out how to do TDD against my main T-SQL based application.  It is getting too scary to consider changes and that needs to change, now.

Tomorrow I’ll post the results after Day 1.

Now, if I can only convince somebody in corporate that DirectX 9 is required for Excel 2003… but, until then, no Cover Flow.

Cheers.

As I was reading this, I started remembering how intimidating Joel’s words can be:

You’ll never hear anyone say “the team was just not smart enough or talented enough to pull this off.” Why hurt their feelings? The simple fact is that if the people on a given project team aren’t very good at what they do, they’re going to come into work every day and yet–behold!–the software won’t get created.

I’m certainly NOT a Master (hence this blog), but just because you don’t have unicode decyphering, PDP-7 microprocessor-based C running through your veins does not make you a crappy dev. Nor, can a single person be both an expert in C, OOP, RDBMS, HTTP, Ruby, and .NET.

I did like the article though and here’s why: Joel’s message was really to business owners and managers, not us technical folks. He laid out very clearly that having good people do the work they are qualified to do, following a plan, with reasonable deliver-ables, and focused on quality can give you a successful project. He throws a few punches at Agile methodologies as well, but I would disagree with Greg that Joel doesn’t actually like Agile, in fact the new scheduling features of FogBugz 6.0 should allow any Agile team to easily maintain their own burndown chart.

And just another example of Scott Adams’ timeliness, here is today’s Dilbert:check out the Dilbert of the day.

The only trouble is that when I use SQL Prompt inside Visual Studio to manage my SQL code, CodeRush tries to hijack the “ESC” key that SQL Prompt uses to cancel it’s own “intellisense” lists.

While attending the Day of .Net Fall 2007 event on Saturday, I had a chance to bug lead developer on CodeRush Dustin Campbell in the middle of his presentation. Dustin handled me graciously, especially since it was just another “tech support” question… but he didn’t “fix me”.

With Dustin’s suggestion, I was able to get to the correct place though, thanks Dustin!

Here’s the solution.

1. Choose DevExpress > Options
2. IDE \ Shortcuts
3. DXCore \ Support
4. Esc (MarkerCollect command)
5. Choose only the Languages that ESC should collect the markers on (my case: C#, VB, XML/HTML, C++)

Here’s what it looks like when you’re done.

How many times have you busted your head open trying to estimate a requirement of something completely unknown? How about spending that extra time (late night/weekend) building in some “cushion” on a function that you could imagine being requested in the next month? How many times have you seen the same good estimate track perfectly until it meets the reality of dependencies inside the product or is the next episode of “The Customer Tweak of the Week”?!

Well, wake up, you’re in waterfall land and hardly anyone actually works by that discipline. We may say we do waterfall, but have you ever told your customer NO for each and every request once the project was underway? Probably not…

If you were merciful like the rest of us, you were being adaptive.

James Short wrote up an article on some of his mentoring of XP, but the part I really enjoyed was the realistic approach Agile takes: put off a decision until the “last responsible moment” so that you have as much of the information and as little assumption going into your decision. The decision in this case means to write up a specification.

In the same vein, you need to also remember to only spec for the present, instead of trying to build up a super infrastructure for all possible scenarios of the feature you’re implementing at the moment. We need to trust, no rely, on a metholody (TDD + Refactoring) that will flush out design inefficiencies and let us go back and put those in when they are finally needed. Again, do not built today something that isn’t needed today.

I totally disagree, Venn diagrams fit perfectly. The biggest problem is that people creating the diagram assume that the Table is one of the sets. This is apparently the problem again with Jeff’s and Ligaya’s diagrams.

Here’s one of Jeff’s awesome images:

We’ve seen this as the classical starting point to explain joins in relational databases. Once you get over the mechanics of what the JOIN operations do, you need to abandon this thinking quickly and focus on just what are those sets, otherwise you keep thinking about tables, not conditions.

For instance, how are these SQL statements different?

SELECT *
FROM customer
INNER JOIN order ON order.id = customer.id
WHERE
    order.total > 100

SELECT *
FROM customer
INNER JOIN order ON order.id = customer.id
    AND order.total > 100

They aren’t. In a Venn Diagram, this could be represented as:

Next time you’re working up some SQL code, start first with what you are trying to get, and then focus on how to they relate with a JOIN.

What about the CROSS JOIN you say? Instead of this (from Ligaya):

Draw a large circle with the product of the areas of your original sets…

I’m running a VS2005 project with 8 projects and my compile only takes 3 minutes. I know people have claimed orders of magnitude of build time improvement, but it still seems strange to go through the hassle of creating and maintaining XML when I decide I need to breakout the project into another assembly… if this were going the way of Continuous Integration, I could see the benefits there, but would the .build file have to be different on the CI server (e.g. SVN Update, clean, test targets).

What am I missing for the small development project?

Update: My apologies to JPB on the assumption he suggested all projects run NAnt. I’m still curious, is it overkill to use NAnt, Rake, etc for compiling a solution with less than 20 projects / 10,000 lines of code?

In the continuum of craftsmanship (and to keep fully immersed in “pure” product development skills), I need to create a new software project.

Ideas so far:

• Worship Software – cool graphics, rock-solid stability, simplified use, connected, multiple outputs, multiple inputs, cross-platform (QuickTime?/SilverLight?)
• Web-Based Church Management Software – centered around connectedness
• “Zero Config” Grid Rendering
• Web-Based File Manager – organizer, ratings, tags, duplicate checker, compression/de-compression built in

Methodologies:

• Test Driven Development
• Objects drive the data layer (if exists)
• Continuous Integration

Preferences:

• Web over WinForms
• .NET over Ruby/PHP
• Quality over Timeliness

VMWare offers free Virtualization. You may have used VMWare Workstation in the past, but what is special is VMWare Server.

This blew my mind over the weekend:

1. Install VMWare Server running on Windows 2000 Server (a Linux version also is free).
2. Download one of the many pre-made VMWare Images (Virtual Appliances) and save it on the on the local drive (I choose UltimateLAMP to have something up and running easy)
3. Install VMWare Client Tools on any PC on my network.
4. CONNECT and/or START the VMWare Image over the network.

Did you catch the difference? VMWare Workstation starts the Virtual machine, VMWare Server lets you control Virtual machines over the wire!

Yeah, this has been around awhile, but that’s both the fun and fear of technology – you just can’t get exposure to it all!

Also what comes to a screaming head is the fact that in VB.NET you can get away with a lot under “normal” circumstances. You know, the one where you don’t declare “Option Strict On”. So porting to C#, the compiler conditionally complains of things like: Cannot implicitly convert type ‘int’ to ‘string’

Currently, I’m telling it what to do:

foo.ToString();

Specifically telling computers what to do is an inherently good thing for programmers. Especially if you’re a control freak like me. Another “good thing” – touch-typing.

Have a windows box that you want to do NTLM against in Firefox? Try this out!

1. Type “about:config” in your FireFox Address Bar
2. Edit the value for “network.automatic-ntlm-auth.trusted-uris”
3. Add a comma separated list of values for the servers you want to NTLM against. For example (“localhost, us.mycompany.com”)

Just plain nuts. My last reason for using IE just vanished.

1. Init – page class is instantiated in ASP.NET worker process. Advisable to instantiate private members of your class here but hold off on much else as the web UI controls can get modified in later events
2. Load – ControlTree is created, all PostBack data has already been posted to the controls, all ViewState has been processed, this is the place to rearrange controls, visibility and dynamically create controls
3. PreRender – last chance to alter web controls – you cannot OVERRIDE this event
4. Unload – output has been written, and you’re just doing cleanup now

For a detailed discussion into all ten, check out 4GuysFromRolla.com

Yeah, I’m a techno-elistist type… but when Firefox rips through pages without crashing, flickers and other IE “normalities”, it is SO OVER. I hope I can write software someday that flies like this thing!

While I’ve built a handful of solutions, both webform and winform since 2001, they have all been in VB.NET. I’m going to try and push cold turkey and just switch to C#. Why?

Here’s what I can come up with:

1. C# is “closer” to the .NET Framework – much of .NET framework was in C# and the whole experience is cleaner. I’m a control freak is the bottom line.
2. C# is closer to Javascript – I’m planning on web programming, and jumping in and out of brackets and the like is just something I’m feeling too lazy for
3. C# has huge momentum in the Software Engineering community – having MORE resources by industry experts, not just in the Microsoft camp is how I’d like to build software. Also, it seems that more open source projects run in the C# space than VB.NET (purely subjective).
4. C# in Visual Studio 2k3 has better architect tools (i.e. code comments). Yes I know about the VB.NET add-in.
5. Easier to share, debate – VB.NET still has a hobbyist aura. I’m anything but a hobbyist, but I grow tired of spending time on qualifications when discussing ideas.
6. C# to VB.NET conversion is actually easier to me. Sure, I could read C# and convert to VB.NET. VB.NET does some things during compile time anyway that is more declarative (see #1) and I just don’t want any more tools that hide that stuff.
7. Intellisense wins every time. Since I’m in Visual Studio .NET, it’s not like I’ll have “extra” typing to do.

Here we go!

I promise not to become a C# biggot.

• Essential ASP.NET with Examples in C# (Onion)
• Framework Design Guidelines (Cwalina, Abrams)
• .NET Gotchas (Subramaniam)
• Programming .NET Components (Lowy)

On the bookshelf

• Must Read
• Short-lived
• Kindling

On the Wish List

• Business Objects in C#
• Business Objects in C# 2005

Get ‘em now:

• Web Development Helper – Parse ViewState, TraceViewer, nice… this was built by one of the guys on the ASP.NET / ATLAS team at Microsoft [get]
• ieHTTPHeaders - view HTTP Headers within the browser [get]
• Internet Explorer Developer Toolbar – official un-supported tool from the big guys themselves

Watch for these:

• JavaScript Utilities Project - this is probably the initial cut of ATLAS work