And every… single…. time… I reboot any of these machines, I see one of these:

I typically go ahead and let Flash do what it wants to do, and yet it keeps coming back, over and over and over again.  Based on this, I’m forced to conclude that either (1) Flash isn’t really updating correctly, or (2) it really does have a new update to install every single time I reboot.

Neither of these is acceptable.  Adobe, you’re not building an OS here.  Get it right and get out of my way.  If there’s  a *real* new version or a *real* security disaster, then let me know about it, but I just refuse to believe that there are really that many emergencies that you need to install something every single time I reboot.

If you’re wondering why folks like Apple have made such a big stink about getting Flash off their systems, this is exactly the sort of issue they had in mind.

As you may have noticed, I use 1&1 to host this site, and I also run a couple of club sites on them.  Although I saw some reliability problems with 1&1 a couple years ago, I have to say they’ve been pretty good since then.  I use mon.itor.us to watch uptime on all these sites, and I haven’t seen any major issues in a long time.

If you need a host, include these guys in your eval list.

Related articles by Zemanta

• Web hosting company 1&1 drops traffic caps (techradar.com)
• Web Hosting Firm Just Host hits 100,000 New Hosting Customers This Year! (prweb.com)
• Web Host Doesn’t Let You Know About Bandwidth Overages For A Week, Wants $5,700 [Servers] (consumerist.com)

The .Net Logging Framework from The Object Guy is powerful enough to handle any of your logging needs, but simple and painless to use.  Here’s a relatively complicated example — we’re going to log to three logging sources to demonstrate how easy it is to set up.  In most cases, of course, you’ll log to only one or two sources:

/* first instantiate some basic loggers */
Logger consoleLogger = TextWriterLogger.NewConsoleLogger();
Logger fileLogger = new FileLogger("unit_test_results.log");
Logger socketLogger = new SerialSocketLogger("localhost", 12345);

/* now instantiate a CompositeLogger */
logger = new CompositeLogger();

/* add the basic loggers to the CompositeLogger */
logger.AddLogger("console", consoleLogger);
logger.AddLogger("file", fileLogger);
logger.AddLogger("socket", socketLogger);

/* now all logs to logger will automatically be sent
to the contained loggers as well */

/* logging is a one-liner */
logger.LogDebug("Logging initialized.");

When you download this logger, you’ll get all the source code, including a socket reader to catch the logs thrown by the socketLogger in the example above.  Extending the logger is a piece of cake, too, so you could build yourself a WCF Logger, for instance, in no time flat.

You’ll note the lack of config file-driven settings in the example above — this is purely intentional.  You can decide if you want to make any of these settings configurable, and do so in the format you’re comfortable with, so you don’t need to try to get your config files to conform to whatever format your logger insists on using.  This small simplification can be a big time-saver for simple apps, debugging / test harness apps, and so on.

There’s no question that Visual Studio is a class-leading tool for building large applications.  The IDE is incredibly helpful to coders, and the .Net framework lends itself to managing dependencies among components and classes in large applications.  In addition, Visual Studio is designed to be extended by third-party tools that can make it even better.  NDepend is one of these tools; its purpose is to analyze large applications and expose information that’s typically hidden deep inside your code.

Installation and getting started

The NDepend web site shows some great screen shots with all manner of graphs and charts and reports, so naturally, you want to see that stuff for your code, too, right?  Good news: installation is a piece of cake.  Just unzip into a directory, add the license file, and you’re ready to start your first analysis.

When you start the NDepend Startup shows a screen reminiscent of Visual Studio (start screen).  Create a new project, point it at a Visual Studio solution file, and let NDepend do its thing.  Zero to more graphs than you can shake a stick at in about four minutes:

NDepend Reports

For my first test, I loaded up CSLA and ran NDepend’s analysis.  When you run NDepend’s analysis in the VisualNDepend GUI tool, it writes a report in HTML with all the graphs you see in the screenshot above and more.  In addition, the report will show you some metrics, dependencies, and warnings.

This is where the analysis starts to get interesting.  There’s a section in the report called “CQL Queries and Constraints”, where NDepend lists violations of constraints it’s found during the analysis.  “CQL” stands for Code Query Language, and this is one of the real hidden gems of NDepend.  It turns out that NDepend isn’t just boiling your code down into data so it can draw graphs — it also lets you query that data with a SQL-like language.

If you’ve ever used FxCop, you’ll be familiar with the idea behind CQL constraints.  Like FxCop warnings, the idea here is to flag code that probably needs some help.  Unlike FxCop, though, the constraints you see popping out in the report are constructed like SQL queries.  Here’s one of the simpler examples:

// <Name>Methods too big (NbLinesOfCode)</Name>

WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbLinesOfCode > 30 ORDER BY NbLinesOfCode DESC

// METHODS WHERE NbLinesOfCode > 30 are extremely complex and
// should be split in smaller methods
// (except if they are automatically generated by a tool).

// See the definition of the NbLinesOfCode metric here http://www.ndepend.com/Metrics.aspx#NbLinesOfCode

A few points of note here:

• NDepend comes with over 100 of these queries, including 20 samples showing how to construct custom queries.
• Yes, you can write your own queries!
• Note the URL in the comments above — there are quite a few new terms you’ll find yourself wading through as you dive into NDepend, so take advantage of the excellent online explainations.  For example, the page above is part of a whole page that explains the code metrics that NDepend tracks.  Be sure to check out the Metrics cheat sheet, too.
• The results of these constraints don’t indicate specific problems — they indicate conditions that could be problems.  It’s still up to you to check out the specifics.

CQL Queries

Needless to say, I had to try out the CQL queries.  The thought of creating my own CQL queries sounded pretty cool — even though I wasn’t exactly sure what I wanted to look for!  The View menu has an option to “Reset Views to work with the CQL language” which switches the IDE around and presents a treeview with queries in it.

This handling of views is somewhat different from the way we’re used to working with windows in Visual Studio — whereas Visual Studio lets you open, close, dock and pin tool windows one at a time, NDepend re-arranges the whole collection of windows at once to suit each type of activity you might want to undertake.  If the NDepend GUI were integrated into Visual Studio, this would probably be quite awkward, but in the standalone NDepend GUI, it’s pretty easy to get used to.

I decided to create a query showing namespaces with very little code in them.  Probably not the most useful method, but I figured it might be interesting to see some little-used namespaces.  Creating the query is easy – you end up with a pretty basic edit window:

I noticed a few quirks while working in this window:

• There is autocomplete in the query editor window, but it’s not as slick as the autocomplete you’re used to in Visual Studio.  It’s pretty easy to screw a query up enough, for example, that the code parser just gives up.  You should get used to this pretty soon, though – it didn’t take me too long.
• Browsing from query to query could be a little easier if there was a preview pane of some sort.  While stumbling through my first query, I wanted to browse a bunch of queries to see examples.  I found I had to “edit” each query, then “cancel” to go back to the treeview to find the next one.  It would be nice if I could click each query and see the edit view for that query in a preview window.
• The biggest feature I wished for, though, was a fast, easy way to run my query and see the results without running the whole analysis and report again.  It turns out that there’s a window that was hiding in a tabset behind the class browser, and this window actually shows results in real-time as you make changes to the query.  Way cool, but it took me a bit to realize it was there.

In any event, within a few minutes, I’d created a constraint, and it was yielding results:

// <Name>A sample constraint</Name>

WARN IF Count > 0 IN

SELECT NAMESPACES WHERE NbILInstructions < 500 ORDER BY NbLinesOfCode ASC

In case you’re wondering, I would probably use either NbILInstructions or NbLinesOfCode in both the WHERE and the ORDER BY clauses for a “real” query, but I wanted to play around with both of these as long as I was experimenting.

NDepend integrated into your process

The interactive UI is where you’ll spend your time while you’re learning NDepend, but this tool is designed to integrate into your build process, too.  Once you’ve got CQL constraints set up the way you want, you want to keep an eye on your project to make sure it stays healthy over time.  NDepend can integrate into your MSBuild, NAnt, or CruiseControl.Net build process so you’ve got up-to-date information all the time.

Another obvious use of NDepend is to support refactoring.  While the CQL constraints show you places where you probably should consider refactoring, the dependency matrices and graphs help you understand the relationships that exist in your code so that you can refactor effectively.  Given that NDepend has access to your .Net code only, dependency analysis won’t help track dependencies into other systems, stored procedures, and so on.

Is NDepend right for you?

NDepend can do some things that no other product can touch.  These capabilities are seriously amazing, and are a testament not only to this tool, but also to the extensibility of the .Net framework.

But how is it going to make you a better developer?

If your organization values code quality, you’re hopefully already familiar with the principles behind the default CQL constraints.  Most of these measurements are understood by most developers in an abstract way, but it’s usually really difficult to make these judgements objectively.  Not anymore.  Now you can use NDepend to help keep your code architecturally clean.

There are a few places where NDepend makes a lot of sense:

• Big code bases.  These systems can be very complex and brittle, so improvements in stability help a lot.  It’s also nice to have some extra tool support when working with big code bases.
• Commercial code or public APIs.  If you sell your software, your code needs to be top-notch, and NDepend can help with that.
• As a code review or teaching tool.  Like code reviews, NDepend can help teach new developers how to build more reliable, more maintainable systems.

If you need every advantage to keep your code base healthy, you should check out this tool.  If you’re good, this tool will make you better.

Image by Zemanta via CrunchBase

Shortly before I switched this blog to WordPress, I learned about a new tool called Zemanta.  It was supposed to provide context-sensitive links and images, chosen dynamically to be relevant to the work in progress.  It sounded pretty cool, and I tried to set it up under Drupal, but couldn’t quite get it done.  After switching to WordPress, I was happy to see that Zemanta setup was a breeze.

I’ve been using Zemanta for a few weeks now, and I’m really, really happy with it.  My initial impressions were a bit iffy – images were inserted in a way that made it difficult to move the image without leaving the citation caption behind, for instance.  Zemanta keeps improving the plugin and the service, though, and my early problems have lessened considerably.

Image by Kyle Kesselring via Flickr

Zemanta gives you a little sidebar as you’re editing your blog entry – there’s a plugin that works right in WordPress’ editor, and you can also install it as an add-on for Windows Live Writer.  The two main areas you’ll see in the sidebar are a set of images and a set of related links.  When you want to use one of the images or links, you click on it, and it drops into your post – it’s just that easy.

There’s nothing that Zemanta does that you couldn’t do yourself, but what I’ve found is that Zemanta makes the process of creating a nice-looking post so much easier, that I’m more likely to sit down and pop out a quick post now, because I can click in an image or two and some related links, and I’ve got a post that doesn’t look like I mailed it in from my smartphone.

This post, for instance, took about fifteen minutes end-to-end – considerably less than I’d have spent if I’d had to go find images, resize them, upload them and insert them, and then go find links to add as well.  More likely, I probably would have skipped the “related links” altogether.  Zemanta makes my blog better, and easier too.

Related articles by Zemanta

• Zemanta Plugin for Windows Live Writer
• Zemanta – semantic image suggestion for your blog
• Zemanta – more trouble than it’s worth.
• Need Pics and Links? – There’s Always Zemanta!

Before I go messing with boot sectors, though, I plan to take a backup of my system.  The last experience I had with Windows Backup wasn’t stellar, and as luck would have it, I just read a blog post announcing a free personal backup program from Paragon Software Group called Drive Backup Express.  It’s supposed to be really simple, and really foolproof.  Perfect, I thought – I’m in!

So I went to download this dandy little app last night, and wouldn’t you know, it was downloading really slowly.  No big deal – I let the download run and went to bed.  I sat down tonight to install, and the install started giving me “can’t read archive” errors.  Oh, oh.  Not the sort of message you want to see from your backup program.

I figured I’d better download again, so I kicked off a fresh download, and the darned thing said it was going to take something like 2 hours to download 70-some Meg.  I haven’t seen speeds like that since dial-up.  So once again, I left for a while, came back, and the download said it completed, but it only showed a file size of 23 Meg.  Sure enough, when I went to run it, I had the same corrupt archive problems again.

A few years ago, I remember jumping on fresh downloads of development tools, browsers, Linux distros, and so on, and fighting for a day or two at a time to get downloads to complete.  I hadn’t realized how far we’d come since then until just now.

If you offer a product or service, no matter how good the end result, please remember that you never get a second chance to make a first impression.  I’m not sure I’ll ever find out whether Drive Backup Express is worth the time of day, because I still haven’t managed to get the damned thing to download.

We’re past download capacity being an acceptable reason for a lousy experience, and I’m done waiting.  I’m going to go start my backup with Windows Backup now.

If you haven’t heard of it, LogMeIn is a remote access / remote control product – in fact, a suite of products, really.  When I initially set up my account, there were basically just “Free” and “Premium” options, but they’ve added new products at a dizzying pace.  They’re up to something like ten products now, including one I didn’t even know about until I looked today.  Most of these products seem to be specialized derivatives of their core technology, which is a really nice approach to see – sort of the opposite of the “throw everything in one basket” approach that many products take.  Despite the breadth of products, all of my experience has been with the basic free product.

First, the bad news.  You have to run an installer on each PC you wish to control, and you need to install an ActiveX control in the browser of any PC you wish to use as a “viewer”.  I’d love to see the viewer work without an install (some administrators won’t permit this, of course), but this notwithstanding, I’ve never had the need to install these pieces hinder me.

There’s a lot more good news than bad news, though.  Here are just a few of the things I’ve noticed (and liked) so far:

• The “host” component prompts you when there’s an update available, but it doesn’t stop running until you upgrade.  This can really save you when you’re logging in to a “headless” PC remotely, so the first chance you have to see that the host wants to run an update is when you’ve remoted into the host.  It would be a real drag to discover that a whole bunch of PC’s just became unreachable because they were waiting to be upgraded.
• I’ve never had any problems traversing firewalls, proxies, etc.  File this under “it just works”, and I’m grateful for it.
• It works on my Windows Mobile phone!  I’m using Win Mobile 6 on a T-Mobile Wing, and it works like a charm.  I certainly wouldn’t want to work for any extended time this way, but it’s really, really great to be able to get to the one stupid little button on your desktop that I desperately need to press when I’m sitting in a coffee shop on the other side of town.
• Screen scaling.  This is one of those little usability features that escapes attention at first glance.  Many remote control apps will let you view the host’s screen at exactly the resolution of the host, meaning that if you’re looking at a screen larger than your client’s window, you’re doing a lot of scrolling to see the whole screen.  LogMeIn, though, scales your host’s screen to fit in your client’s window – no matter how large the window is.  That means that if you’re watching a remote PC to see if a job’s done, or something like that, you can do so in a small window.  The resolution suffers a little, of course, when you scrunch the screen down, but it’s really pretty remarkable how readable the screen stays as you resize it.  This is a really nice touch.
• Did I mention that it just works?

I’ve tried quite a number of other remote-access products over the years, including VNC and Windows Remote Desktop (running over various tunnels and VPNs), and LogMeIn beats them all when it comes to reliability, and when it comes right down to it, that’s the #1 feature for remote access, isn’t it?  If you haven’t tried LogMeIn yet, go give them a shot.  You won’t be disappointed.

Bear in mind that this material is offered at a high level – if you’re interested in really learning the framework, I’d encourage you to buy the book, download the framework, and dive in – the water’s fine.

Benefits

One of the obvious benefits of this framework is that Rocky’s written a book to document the framework (multiple, if you count C# and VB variants, plus updates for new releases).  The book does a pretty good job of walking you through the construction of the framework, explaining “why” as well as “how”.  You can certainly learn the framework without reading the book, but if you like to do your tech learning out of a book, this one is a great read.

The CSLA framework takes a very OO approach to design.  Where a lot of code-gen or “factory” approaches lay the entire model open and trust developers to do the right thing, CSLA enables and, in fact, encourages defensive programming with respect to the object model.  You get to actually start using scoping modifiers to protect the inner workings of your classes, which is really nice.  In my opinion, this encourages a much more robust object model because you can lock down ctors and setters where it makes sense.

This is feasible because you’re using the same objects everywhere you need them, regardless of physical tier, and this is actually one of the places where peoples’ eyes start to glaze over.  Rocky actually does a great job of explaining this in his book, but a lot of people see examples with code from multiple logical layers in the same class file, and conclude that CSLA precludes the use of multiple physical tiers.

In fact, the framework actually makes n-tier development much easier and more flexible becuase it abstracts the protocol across layers.  I can take the same code, in fact, and configure it to run all on one server (without incurring network traffic across tiers), or as a BL and DL connected via HTTP WS, WCF, or remoting.  It really is just a config change to switch among these modes, which is pretty nice.

Some of this flexibility comes from the use of reflection in some spots, and that can put people off, but IMO, the benefits far outweigh the costs unless you’re trying to trade stocks or land the space shuttle.  Comparing two applications developed for the same client and deployed into the same environment, the second app (using CSLA) is noticeable snappier, mainly because we’ve got fewer layers of junk to sift everything through, and because we’ve got a lot more control over how we optimize data access.

Data Binding is usually listed as one of the benefits of CSLA, but I’d broaden this to include support for all the MS interfaces that you’d want to support if you were starting from scratch.  It does authentication and authorization, for instance, using the same MS interfaces you’d expect to find in use elsewhere.  It does validation using the standard interface, and so on.  The effect of all this is that stuff just *works*, instead of being a constant struggle to go build something whenever you want to interface with something new.

The CSLA objects have excellent support for “state”, including IsDirty-type infrastructure so the objects know when they need to be saved and what sort of CRUD operation that might be.  They’re also capable of supporting n-level undo, though I haven’t needed that.

Finally, the object have good support for validation, including the ability to declaratively write business rules that drive “IsValid” and the ability to save your object.  These rules can be reasonably sophisticated, since you’re writing them in code.

Drawbacks

I’ve seen a few.  First, it seems like I was constantly fighting FUD from people who didn’t know anything about the framework.  As I mentioned earlier, there are a lot of misconceptions about this framework – maybe because of its “legacy” roots.  I saw very little real merit in these arguments, however – they just don’t hold water when measured against facts.

Second, I saw a couple of places where I got caught building an object based on one base class, and it turned out later that I probably should have been using a different base.  At that point, you don’t get any additional help with refactoring that doesn’t already come in the box.  There are modeling or code-generation tools that can spew out CLSA code, and my experience here might have been different had I been using one of these.  In any event, I was still way ahead using the framework.

Finally, I saw some places where validation didn’t cascade very elegantly down to complex children of parent objects.  This isn’t the end of the world, since you can override anything by hand, but it would have been nice to get just a little more help from the framework on this one.  At moments like these, it’s hard to resist the urge to just grab the CSLA source code and fix it.  That’s an absolute last resort, of course, since it would make upgrades much more difficult.

In case you’re looking for more info on CSLA, I’ve pasted a few representative “community” opinions below – feel free to take a look at any or all of them.  FWIW, Rocky tends to do a great job of explaining himself in forum posts, but I’ve yet to see him put together an effective “elevator speech” for CSLA, which is unfortunate.

CSLA Framework benefits:
http://www.primos.com.au/primos/Portals/0/Tech%20articles/CSLA%20WIIFM/What%20could%20CSLA%20do%20for%20me.html
Blog comments:
http://www.primos.com.au/primos/Portals/0/Tech%20articles/CSLA%20WIIFM/What%20could%20CSLA%20do%20for%20me.html
Blogger’s pros and cons:
http://claytonj.wordpress.com/2006/10/17/using-csla-as-an-application-framework/
InformIt article:
http://www.informit.com/articles/article.aspx?p=770361