I'm not sure why this didn't occur to me before...  I read recently another brief article about the negative impact of email on productivity the other day, so I was thinking about a way to deal with it that didn't involve, e.g., closing Outlook and maybe even setting an "I'm not available by email until 3p today" out of office type message--seems a bit extreme, and it would also preclude my getting meeting reminders. 

It occurred to me that what usually happens is I get the nifty little toaster popup notification while doing something, almost always click on it for more detail, and then get drawn into a distraction over it.  Similarly, I was using one of those Gmail Vista gadgets that would highlight when I had Gmail waiting, or I'd leave it open and minimized and see the Inbox count in the taskbar.  The problem was not (for me) so much getting too much email as having the regular interruptions that were occasioned by these terribly useful notification mechanisms. 

Having isolated the problem, i.e., having framed the question correctly (which usually the most important part of solving a problem), I asked "How can I make these notifications go away?"  And the answer was immediately apparent: turn them off. :)

To that end, I went into Outlook advanced email options (Tools -> Options -> Email Options -> Advanced Email Options--who knew notifications were advanced?!) and deselect all the notification options:

I then removed the Gmail notifier gadget, and I close my Gmail when done with it.  The magic is that I still get my task and meeting reminders, but I don't get the regular interruptive notifications.  This had an immediate noticeable effect--I could work through to a good stopping point on the thing I was working on, i.e., a point I'd normally take a break, and then I'd check my email.  Wow!  Who knew something so simple could make such a difference?  I figure if it is critical, somebody will call or come knocking on my door. :)

As a complimentary technique to that, I have taken my Inbox strategy to the next level, following a bit of advice given by Mark Hurst (who wrote a book on Bit Literacy [that I haven't read]).  One of his suggestions to avoid information overload is to keep your Inbox empty.  I previously already worked to do that because I used my Inbox like a to-do list (and don't like having a long to-do list), but Mark's advice is precisely not to do that--use it as an Inbox and get stuff out of it immediately. 

Having not read the book (in which I'm sure are tons of helpful little tidbits), I take that to mean act on it immediately if possible, file it if need be, or set up a task to do something with it later.  I was already doing the first two, but I've found this additional third technique to be a nice add.  There is a distinct satisfaction (for me anyway) to having an empty inbox--maybe it's my personality type. :)

I hope this maybe helps others out there in the same boat.

I haven't done any research, so maybe it is out there.  But I had a thought the other day as I accepted yet another invite to connect from yet another social networking site from someone I have connected with numerous times. 

Wouldn't it be great if I could have one, unified set of social contacts, my social network, that I could then just share out to various social networking sites?  I mean, sure, folks would have to opt into it, someone would have to think about the privacy issues, but good grief, it seems like we need something like that...

I finally gave in and bought a graphics tablet.  My budget being as huge as it was, I opted for the Wacom Bamboo, which retails at $79, but ANTOnline (via Amazon) had it for $50 plus shipping ($58 total).  I haven't been this tickled to get a new gadget in a while.

The whole experience thus far has been grand.  I placed the order at about 10p on Tuesday night.  I got an email Wednesday night saying it had shipped, and when I opened it Thursday morning and clicked the tracking number, I was informed it was out for delivery--and I paid for standard shipping.  Awesome.

I got the box later Thursday morning, and opened it to find a sleek box wrapped in tissue paper, as if it were a gift.  After sliding it out of the tissue paper, here's what I saw:

Not bad styling.  Let's open 'er up:

"This is your Bamboo.  Use it to get more out of your computer.  Let us know how it goes..."  In many languages.  Then it is signed by, presumably, the creators.  Very nice touch, I thought.  I felt like a proud owner already.  Then you lift up that insert, and there's the tablet in all its beauty.  Grab it out--there's the cord, the pen, the pen holder.  Great.  Simple. Obvious.  Beneath that is another tissue wrapped gift, a stylish little black box that has some simple instructions on getting going and the DVD.

Just opening the thing was a pleasure.  Honestly, these folks know what UX is, and this is just for an $80 graphics tablet. 

I plugged it in, and it immediately just worked.  Having read a comment somewhere, I just went to the Web site to download the latest drivers.  That was easy.  Install.  I had to try twice; it got hung up for some reason, but then, I did have 30 apps open at the time and they did suggest closing them all. :)

I immediately opened OneNote and went to town.  I started drawing the simple stuff as Dan Roam suggests in his new book, The Back of the Napkin.  (I attended his session at Mix and liked it enough to buy the book.)  Then I really went out on a limb and drew a self-portrait:

Not bad, eh? 

Well, it was a first shot.  I tried writing and realized just how bad my penmanship has become over the years.  Trust me; it's bad.  Nice thing is that maybe I'll get some of it back and improve it now that I have this (who knows?). 

I'm now on Day 2 of using my Bamboo, and I really like it.  My wrist, which had been hurting more as of late, has been loving me.  One of the reasons I tried this was to see if it'd be better to avoid "repetitive strain injury," and I noticed an immediate difference.  The other reason was because I get so tired of being constrained by drawing programs in terms of what I want to represent visually.  SmartArt in Office really, truly (as cool as it is) only goes so far. :)

So my first real use was to start diving into my Agile UX Design Process diagram to replace a particularly painful slide (Slide 19) in my Building Good UX talk.  It (both the drawing and the process) is a work in progress; just trying to visualize some of my thinking about it right now.

If you look hard, you can see my chicken scratch compared to the nice, free Journal font I picked up.  The point of this diagram is to show how to integrate UX pros into an Agile process.  Not saying this is all fleshed out or perfect, but it's a start. :)  One important point is that even if you don't have the pros, you can start doing the UX stuff yourself.

A Few Tips Using Bamboo (thus far)

1. Use Mouse mode.  When you install the driver, it switches to Pen mode, which tries to map your screen(s) to the tablet.  Even though Wacom recommends this mode (even provides exercises to get use to it), I found it frustrating when trying to draw on my right screen--I felt too close to the edge for comfort. 
2. Disable acceleration.  While it can be a nice feature when using it literally like a mouse, it messes you up when drawing.
3. Switch to the dreaded single-click mode in Explorer.  Back when the single click mode was added (XP?), I tried it out and was disgusted.  But double-clicking w/ the pen is just not easy, and actually, the single-click mode feels really natural with the pen.
4. Switch to scroll on touch ring. I don't feel too strongly about this, but honestly, I don't use zoom (the default) enough to have it as a top-level feature on the tablet.
5. Upgrade to Vista?  I think that you must not get ink in Office 2007 w/o Vista?  I can't figure it out, but it's not there for me in XP.  The Wacom site mentions Vista explicitly, and my searches haven't turned up anything useful.  Folks talk about "Start Inking" as if it is just always there, but it may also have something to do with Tablet PC.  I'll let you know if I figure it out.

It is taking some getting used to, of course, but so far I think it's a big improvement.  Ask me in a few weeks. :)

And now for the gratuitous signature:

Nice.

I've been getting friendly with Windows Live lately, and after getting terribly tired of having to switch to HTML view in Windows Live Writer in order to insert a note (could be a footnote or endnote depending on how you look at it), I decided to see if I could write a plug-in to make my life easier.

So was born the Blog Notes plug-in.  Unfortunately, there is no extensibility for just marking up existing text (e.g., adding a superscript button to the markup toolbar), so I had to go with the option to insert some HTML using the  interface.  I really was trying to keep it simple and lightweight (for my own sanity), so it is pretty basic.

The functionality is pretty straightforward.  Thanks to Mark James for the free icons.  Once the plug-in is installed, you should see an "Insert Blog Notes..." option in the Insert pane on the right side as shown below.

Clicking on it brings up the Blog Notes dialog:

Clicking "New Note" will insert a new superscript number (the next one in the sequence).

Clicking "Reference Note" will insert the selected number as superscript.  You can also just double-click the number to do that.

The "Notes Section" button will insert a notes section.¹

Lastly, "Write Note" simply adds the selected note plus a period and couple spaces.

As you can see, it's pretty basic, but it saves a few seconds for each note (assuming you bother to switch to HTML view, find the number, and put  tags around it like I do [did]).  You can also tweak one option/setting.  Go to Tools -> Options, and select the Plug-ins tab:

Clicking Options... on the Blog Notes plug-in brings up a tres simple dialog:

This one option will toggle whether or not the plug-in uses in-page anchor links for the notes so that the superscript numbers would link down to the corresponding note in the Notes section.  I originally added this feature without realizing the implications.  Because blog posts are often aggregated and otherwise viewed in unexpected places, using in-page anchors is iffy at best.  Community Server seems to strip them out, and dasBlog keeps them, but since it emits a <base /> tag to the site root, all of the anchor links are relative to the site homepage instead of the current post, which effectively renders them useless.  I looked at the dasBlog code where this happens, and it's in the core assembly.  I was concerned what side effects changing it to use the current URL would have, so I didn't do that.  But if you have blog software that will let you use this feature, by all means, enjoy!

Caveats

• Because of the way the plug-in framework works, I use a static/shared collection to keep track of the notes.  This means it acts a tad goofy if you close out of Live Writer or write multiple posts while it is open.  If you close and come back to a post, the notes count is reset.  To "fix" this, just re-add however many notes you had (if you want to bother).  If you write multiple posts, you just have to deal with it.  I don't know if there is post-local storage for plug-ins, but I didn't have time to dig into it.
• Your mileage may vary.  I wrote this mainly to save myself time and get familiar with the Live Writer extensibility model, so it ain't a finished product to be sure.

Get It!
Since there are numerous tutorials on the Web (that I learned from) to write Live Writer plug-ins, I won't go into those details here, but you're welcome to download my code and learn from it directly if you want.  I think I have comments and such in there.

• Download the Plug-in Only - If you just want to use this plug-in, this is what you want.  Drop the DLL into your plug-ins directory and go (typically C:\Program Files\Windows Live\Writer\Plugins).
• Download the Source Code - This is a VS 2008 solution for those who want to learn, enhance, extend, whatever.  The license is more or less the MIT license.  You'll need Live Writer installed to reference its API.

Notes
1. This is the "Notes Section."  The button adds the "Notes" header and writes out any existing note numbers.

When searching recently so as to provide further reading for "domain model" in a recent post, I was quite surprised to find that there seemed to be no good definition readily available (at least not by Googling "domain model").  Since I tend to use this term a lot, I figured I'd try to fill this gap and, at the very least, provide a reference for me to use when I talk about it.

So What is a Domain Model?
Put simply, a domain model is the software model of a particular domain of knowledge (is that a tautology?).  Usually, this means a business domain, but it could also mean a software domain (such as the UI domain, the data access and persistence domain, the logging domain, etc.).  More specifically, this means an executable representation of the objects in a domain with a particular focus on their behaviors and relationships¹.

The point of the domain model is to accurately represent these objects and their behaviors such that there is a one-to-one mapping from the model to the domain (or at least as close as you can get to this).  The reason this is important is that it is the heart of software solutions.  If you accurately model the domain, your solution will actually solve the problems by automating the domain itself, which is the point of pretty much all business software.  It will do this with much less effort on your part than other approaches to software solutions because the objects are doing the work that they should be doing--the same that they do in the physical world.  This is part and parcel of object-oriented design².

Nothing New
By the way, this is not a new concept--OO theory and practice has been around for decades.  It's just that somewhere along the line, the essence of objects (and object-oriented design) seems to have been lost or at least distorted, and many, if not most, Microsoft developers have probably not been exposed to it, have forgotten it, or have been confused into designing software in terms of data.  I limit myself to "Microsoft developers" here because it is they of whom I have the most experience, but I'd wager, from what I've read, the same is true of Java and other business developers. 

I make this claim because everyone seems to think they're doing OO, but a concrete example of OOD using Microsoft technologies is few and far between.  Those who try seem to be more concerned with building in framework services (e.g., change tracking, data binding, serialization, localization, and data access & persistence) than actually modeling a domain.  Not that these framework services are not important, but it seems to me that this approach is fundamentally flawed because the focus is on software framework services and details instead of on the problem domain--the business domain that the solutions are being built for. 

The Data Divide
I seem to write about this a lot; it's on my mind a lot³.  Those who try to do OOD with these technologies usually end up being forced into doing it in a way that misses the point of OOD.  There is an unnatural focus on data and data access & persistence.  Okay, maybe it is natural or it seems natural because it is ingrained, and truly a large part of business software deals with accessing and storing data, but even so, as I said in Purporting the Potence of Process⁴, "data is only important in as much as it supports the process that we’re trying to automate." 

In other words, it is indeed indispensable but, all the same, it should not be the end or focus of software development (unless you're writing, say, a database or ORM).  It may sound like I am anti-data or being unrealistic, but I'm not--I just feel the need to correct for what seems to be an improper focus on data.  When designing an application, think and speak in terms of the domain (and continue to think in terms of the domain throughout the software creation process), and when designing objects, think and speak in terms of behaviors, not data. 

The data is there; the data will come, but your initial object models should not involve data as a first class citizen.  You'll have to think about the data at some point, which will inevitably lead to specifying properties on your objects so you can take advantage of the many framework services that depend on strongly-typed properties, but resist the temptation to focus on properties.  Force yourself to not add any properties except for those that create a relationship between objects; use the VS class designer and choose to show those properties as relationships (right-click on the properties and choose the right relationship type).  Create inheritance not based on shared properties but on shared behaviors (this in itself is huge).  If you do this, you're taking one step in the right direction, and I think in time you will find this a better way to design software solutions.

My intent here is certainly not to make anyone feel dumb, stupid, or like they've wasted their lives in building software using other approaches.  My intent is to push us towards what seems to be a better way of designing software.  Having been there myself, I know how easy it is to fall into that way of thinking and to imagine that simply by using these things called classes, inheritance, and properties that we're doing OOD the right way when we're really not.  It's a tough habit to break, but the first step is acknowledging that there is (or at least might be) a problem; the second step is to give object thinking a chance.  It seems to me that it is (still) the best way to do software and will continue to be in perpetuity (because the philosophical underpinnings are solid and not subject to change).

Notes
1. An object relationship, as I see it, is a special kind of behavior--that of using or being used.  This is also sometimes represented as a having, e.g., this object has one or more of these objects.  It is different from data because a datum is just a simple attribute (property) of an object; the attribute is not an object per se, at least not in the domain model because it has no behaviors of its own apart from the object it is attached to.  It is just information about a domain object.

2. I go into this in some depth in the Story paper in the Infragistics Tangerine exemplar (see the "To OOD or Not to OOD" section).  I use the exemplar itself to show one way of approaching domain modeling, and the Story paper describes the approach.

3. Most recently, I wrote about this in the Tangerine Story (see Note 2 above).  I also wrote publicly about it back in late 2005, early 2006 in "I Object," published by CoDe Magazine.  My thought has developed since writing that.  Interestingly, in almost two years, we seem to have only gotten marginally better ways to deal with OOD in .NET. 

4. In that article, I put a lot of focus on "process."  I still think the emphasis is valid, but I'd temper it with the caveat that however business rules are implemented (such as in the proposed workflow-driven validation service), you still think of that as part of your domain model.  The reason for separating them into a separate workflowed service is a compromise between pragmatism and idealism given the .NET platform as the implementation platform.  I've also since learned that the WF rules engine can be used apart from an actual .NET workflow, so depending on your application needs, just embedding the rules engine into your domain model may be a better way to go than using the full WF engine.  If your workflow is simple, this may be a better way to approach doing validation.

As I sit here on my deck, enjoying the cool autumn breeze¹, I thought, what better thing to write about than Web services!  Well, no, actually I am just recalling some stuff that's happened lately.  On the MSDN Architecture forums and in some coding and design discussions we had this week, both of which involve the question of best practices for Web services.

Before we talk about Web services best practices, it seems to me that we need to distinguish between two kinds of application services.  First, there are the services that everyone has been talking about for the last several years--those that pertain to service-oriented architecture (SOA).  These are the services that fall into the application integration camp, so I like to call them inter-application services. 

Second, there are services that are in place to make a complete application, such as logging, exception handling, data access and persistence, etc.--pretty much anything that makes an application go and is not a behavior of a particular domain object.  Maybe thinking of them as domain object services would work, but I fear I may already be losing some, so let's get back to it.  The main concern within this post are those services using within an application, so I call them intra-application services.

It seems like these latter services, the intra-application ones, are being often confused with the former--the inter-application services.  It's certainly understandable because there has been so much hype around SOA in recent years that the term "service" has been taken over and has lost its more generic meaning.  What's worse is that there has been a lot of confusion around the interaction of the terms Web service and just plain service (in the context of SOA).  The result is that you have folks thinking that all Web services are SO services and sometimes that SO services are always Web services.

My hope here is to make some clarification as to the way I think we should be thinking about all this.  First off, Web services are, in my book at least, simply a way of saying HTTP-protocol-based services, usually involving XML as the message format.  There is no, nor should there be, any implicit connection between the term Web service and service-oriented service.  So when you think Web service, don't assume anything more than that you're dealing with a software service that uses HTTP and XML. 

The more important distinction comes in the intent of the service--the purpose the service is designed for.  Before you even start worrying about whether a service is a Web service or not, you need to figure out what the purpose of the service is.  This is where I get pragmatic (and those who know me know that I tend to be an idealist at heart).  You simply need to determine if the service in question will be consumed by a client that you do not control. 

The reason this question is important is that it dramatically affects how you design the service.  If the answer is yes, you automatically take on the burden of treating the service as an integration (inter-application) service, and you must concern yourself with following best practices for those kinds of services.  The core guideline is that you cannot assume anything about the way your service will be used.  These services are the SO-type services that are much harder to design correctly, and there is tons of guidance available on how to do them².  I won't go in further depth on those here.

I do think, though, that the other kind of services--intra-application services--have been broadly overlooked or just lost amidst all the discussion of the other kind.  Intra-application services do not have the external burdens that inter-application services have.  They can and should be designed to serve the needs of your application or, in the case of cross-cutting services (concerns) to serve the needs of the applications within your enterprise.  The wonderful thing about this is that you do have influence over your consumers, so you can safely make assumptions about them to enable you to make compromises in favor of other architectural concerns like performance, ease of use, maintainability, etc.

Now let's bring this back to the concrete question of best practices for intra-application Web services.  For those who are using object-oriented design, designing a strong domain model, you may run into quite a bit of trouble when you need to distribute your application across physical (or at least process) tiers.  Often this is the case for smart client applications--you have a rich front end client that uses Web services to communicate (usually for data access and persistence).  The problem is that when you cross process boundaries, you end up needing to serialize, and with Web services, you usually serialize to XML.  That in itself can pose some challenges, mainly around identity of objects, but with .NET, you also have to deal with the quirks of the serialization mechanisms.

For example, the default XML serialization is such that you have to have properties be public and  read-write, and you must have a default constructor.  These can break encapsulation and make it harder to design an object model that you can count on to act the way you expect it to.  WCF makes this better by letting you use attributes to have better control over serialization.  The other commonly faced challenge is on the client.  By default, if you use the VS Add Web Reference, it takes care of the trouble of generating your service proxies, but it introduces a separate set of proxy objects that are of different types than your domain objects.

So you're left with the option of either using the proxy as-is and doing a conversion routine to convert the proxy objects to your domain objects, or you can modify the proxy to use your actual domain objects.  The first solution introduces both a performance (creating more objects and transferring more data) and a complexity (having conversion routines to maintain) hit; the second solution introduces just a complexity hit (you have to modify the generated proxy a bit).  Neither solution is perfectly elegant--we'd need the framework to change to support this scenario elegantly; as it is now, the Web services stuff is designed more with inter-application services in mind (hence the dumb proxies that encourage an anemic domain model) than the intra-application scenario we have where we intend to use the domain model itself on the client side.

If you take nothing else away from this discussion, I'd suggest the key take away is that when designing Web services, it is perfectly valid to do so within the scope of your application (or enterprise framework).  There is a class of services for which it is safe to make assumptions about the clients, and you shouldn't let all of the high-falutin talk about SOA, WS-*, interoperability, etc. concern you if your scenario does not involve integration with other systems that are out of your control.  If you find the need for such integration at a later point, you can design services (in a service layer) then to meet those needs, and you won't be shooting yourself in the foot trying to design one-size-fits-all services now that make so many compromises so as to make the app either impossible to use or very poorly performing.

My own preference that I'd recommend is to use the command-line tools that will generate proxies for you (you can even include a batch file in your project to do this) but then modify them to work with your domain model--you don't even need your clients to use the service proxies directly.  If you use a provider model (plugin pattern) for these services, you can design a set of providers that use the Web services and a set that talk directly to your database.  This enables you to use your domain model easily in both scenarios (both in a Web application that talks directly to the db as well as a smart client that uses Web services). 

It requires a little extra effort, but it means you can design and use a real domain model and make it easier easier to use by hiding the complexity of dealing with these framework deficiencies for consumers of the domain model.  This is especially helpful in situations where you have different sets of developers working on different layers of the application, but it is also ideal for use and reuse by future developers as well.

One of these days, I'll write some sample code to exemplify this approach, maybe as part of a future exemplar.

Notes
1. The weatherthing says it's 65 degrees Fahrenheit right now--at 1pm!
2. My observation is that it is safe to assume that when other people talk about services and Web services, these are the kind they're thinking of, even if they don't make the distinction I do in this post. 

I wasn't going to post about it, but after reading Don's post, I realized that I should so that I can thank those involved in presenting me with this honor.  I was surprised when I was contacted about being nominated to be an INETA speaker, and I was even more surprised when I heard that I'd been voted in.  Looking over the folks on the list, I feel hardly qualified to be named among them.

So without further ado, let me thank David Walker (who's an all around great guy and VP of the Speakers Bureau), Nancy Mesquita (who I've not had the pleasure to meet personally but has been very helpful in her role as Administrative Director), as well as everyone else involved on the Speaker Committee and others (whom I know not of specifically) in welcoming me into the INETA speaker fold.  It's a great honor--thank you. 

Now, I have to get back to work!  My group, UXG, just released Tangerine, the first of our exemplars, and now we're on to the next great thing!

Thanks to a sharp co-worker of mine, I was recently introduced to "Magic Ink: Information Software and the Graphical Interface," by Bret Victor.  It was quite an interesting read; Victor makes a lot of good points.  For instance, he suggests that we should view information software as graphic design, i.e., taking the concerns of traditional graphic design as paramount and then taking it to the next level by availing ourselves of context-sensitivity, which he defines as inferring the context from the environment, history, and, as a last resort, interaction.

Minimizing Interaction

The thrust of the argument is around reducing interaction and making software smarter, i.e., more context aware and, eventually, able to learn through abstractions over learning algorithms.  I think we can all agree with this emphasis, but I do think he unnecessarily latches onto the term "interaction" as a bad thing, or rather, I think he presents "interaction design" in an overly-negative light. 

True, the smarter we can make computers (and consequently require less interaction from users) the better, but that doesn't negate the usefulness of interaction design, human factors, information architecture, and usability.  There are many, valuable things to be learned and used in all of these interaction-oriented fields, and we shouldn't deride or dismiss them because they focus on interaction.  I felt that Victor's negative emphasis on this and his speculating that why software sucks in relation to this took away from the value of his overall message.

The Problem of Privacy

There is one problem that I don't think he addressed in terms of increasing environmental context awareness, and that is security, specifically, privacy.  It is tempting to think about how wonderful it would be for a computer to know more about our environment than us and thus be able to anticipate our needs and desires, but in order to do this, we, as humans, will have to sacrifice some level of privacy.  Do we really want a totally connected computer to know precisely where we are all the time?  Do we really want it to be "reporting" this all the time by querying location aware services?  Do we really want a computer to remember everything that we've done--where we've been, who we've interacted with, when we did things?

I think the trickier issues with context awareness have to do with questions like these.  How do we enable applications to interact with each other on our behalf, requiring minimal interaction from us, while maintaining our privacy?  How does an application know when it is okay to share X data about us with another application?  Do we risk actually increasing the level of interaction (or at least just changing what we're interacting about) in order to enable this context sensitivity? 

If we're not careful, we could end up with a Minority Report world.  People complain about cookies and wire taps, the world of computer context-sensitivity will increase privacy concerns by orders of magnitudes.  This is not to negate the importance of striving towards greater context sensitivity.  It is a good goal; we just need to be careful how we get there.

Towards Graphic Design

One of the most effective points he made was in illustrating the difference between search results as an index and search results as a tool for evaluation itself, i.e., thinking about lists of information in terms of providing sufficient information for a comparative level of decision making.    It is a shift in how developers can (and should) think about search results (and lists in general).

Similarly, his example of the subway schedule and comparing it to other scheduling applications is a critical point.  It illustrates the value of thinking in terms of what the user wants and needs instead of in terms of what the application needs, and it ties in the value of creating contextually meaningful visualizations.  He references and recommends Edward Tufte, and you can see a lot of Tufte in his message (both in the importance of good visualizations and the bemoaning of the current state of software).  I agree that too often we developers are so focused on "reuse" that we fail miserably in truly understanding the problems we are trying to solve, particularly in the UI.

That's one interesting observation I've had the chance to make in working a lot with graphic/visual designers.  They want to design each screen in an application as if it were a static canvas so that they can make everything look and feel just right.  It makes sense from a design and visual perspective, but developers are basically the opposite--they want to find the one solution that fits all of their UI problems.  If you give a developer a nicely styled screen, he'll reuse that same style in the entire application.  In doing so, developers accidentally stumble on an important design and usability concept (that of consistency), but developers do it because they are reusing the design for maximum efficiency, not because they're consciously concerned about UI consistency!  It is a kind of impedance mismatch between the way a designer views an application UI and the way a developer does.

The Timeless Way

I'm currently reading Christopher Alexander's The Timeless Way of Building, which I hope to comment on in more depth when done.  But this discussion brings me back to it.  In fact, it brings me back to Notes on the Synthesis of Form as well, which is an earlier work by him.  One of the underlying currents in both is designing a form (solution, if you will) that best fits the problem and environment (context).  The timeless way (and patterns and pattern language, especially) is all about building things that are alive, that flow and thrive and fit their context, and the way you do that is not by slapping together one-size-fits-all solutions (i.e., reusing implementations) but in discovering the patterns in the problem space and applying patterns from the solution space that fit the problem space just so.  The reuse is in the patterns, at the conceptual level, but the implementation of the pattern must always be customized to fit snugly the problem. 

This applies in the UI as well as other areas of design, and that's the underlying current behind both Tufte's and Victor's arguments for the intelligent use of graphic design and visualization to convey information.  You must start by considering each problem in its context, learn as much as you can about the problem and context, then find patterns that fit and implement them for the problem in the way that makes the most sense for the problem.  But more on the timeless way later.

A Good Read

Overall, the paper is a good, thought-provoking read.  I'd recommend it to pretty much any software artisan as a starting point for thinking about these issues.  It's more valuable knowledge that you can put in your hat and use when designing your next software project.

Are you passionate about software development?  Do you love to share your knowledge with others?  Do you like working in a vibrant, fun culture working on the latest and greatest technologies with other smart and passionate people?  If so, I think I may have your dream job right here.

We're looking for another guidisan to help craft guidance using best practices for .NET development.  The word guidisan ('gId-&-z&n) comes from a blending of "guidance" and "artisan," which really speaks to the heart of the matter.  We're looking for software artisans who have the experience, know-how, and gumption to explore strange new technologies, to seek out new applications and new user scenarios, to boldly go where other developers only dream of going in order to provide deep, technical guidance for their colleagues and peers.

What do guidisans do? 

• Help gather, specify, and document application vision, scope, and requirements.
• Take application requirements and create an application design that meets the requirements and follows best known practices for both Microsoft .NET and Infragistics products.
• Implement applications following requirements, best practices, and design specifications.
• Create supplemental content such as articles, white papers, screencasts, podcasts, etc. that help elucidate example code and applications.
• Research emerging technologies and create prototypes based on emerging technologies.
• Contribute to joint design sessions as well as coding and design discussions.

What do I need to qualify?

• Bachelor’s Degree.
• 4+ years of full-time, professional experience designing and developing business applications.
• 2+ years designing and developing.NET applications (UI development in particular).
• Be able to create vision, scope, and requirements documents based on usage scenarios.
• Demonstrated experience with object-oriented design; familiarity with behavior-driven design, domain-driven design, and test-driven development a plus.
• Demonstrated knowledge of best practices for .NET application development.
• Accept and provide constructive criticism in group situations.
• Follow design and coding guidelines.
• Clearly communicate technical concepts in writing and speaking.

If you think this is your dream job, contact me.  Tell me why it's your dream job and why you think you'd be the next great guidisan.

It's that time again.  Time for the SYS-CON Readers' Choice Awards voting.  Actually, it's been that time for a little while now; I'm just slow.

Infragistics has been nominated for several categories in several publications, so if you like Infragistics or even if you're looking for a way to kill a few minutes at the airport, go vote for us.

Here's your friendly voter's guide to make your life easier (note that if you don't know or prefer any choice in a particular category, you can just click Continue to move on):

http://java.sys-con.com/general/readerschoice.htm

#11 - NetAdvantage for JSF

#12 - NetAdvantage for JSF

#20 - JSuite

#24 - NetAdvantage for JSF

#28 - NetAdvantage for JSF

http://soa.sys-con.com/general/readerschoice.htm

#4 – NetAdvantage for .NET

#14 – NetAdvantage for .NET

http://webddj.sys-con.com/general/readerschoice.htm

#3 – NetAdvantage for ASP.NET

#6 – Infragistics Training and Consulting

#7 – Infragistics Training and Consulting

#8 – NetAdvantage for ASP.NET

http://dotnet.sys-con.com/general/readerschoice.htm

#3 – NetAdvantage AppStylist

#4 – Infragistics Training and Consulting

#5 – Infragistics NetAdvantage for .NET

#10 – TestAdvantage for Windows Forms

I was just reminded by our local Dev Evangelist, Peter Laudati, that we've got our third NJ CodeCamp coming up this weekend.  Code camps are a fun way to get to know other local devs, learn some cool stuff, and generally get at least a free lunch!  So you should go!

Today we launched our new web site.  It was not just a simple update; we revamped the whole deal and made it Web 2.0 compliant <grin>.  If you remember our old site, I trust you'll immediately see the improvement.  Please take a minute to check it out and let me know what you think.  Also, if you run into any problems with it, please feel free to let us know.

Well, I've finally settled on the software I'm going to use to write my blogs as well as read them.  I'm pretty picky about UI these days, and most of the software out there is just not that great when it comes to that.  But of course, I also need it to integrate and minimize the time it takes to set things up and the time I have to spend jacking with it on a regular basis. 

Authoring
For authoring, I've decided to go with WB Editor 2.5.1 by Yiyi Sun.  I like the UI.  It currently uses the webby L&F, which when done right has a pleasant, light feel to it.  One thing that immediately strikes me as nice is that when I save a post for the second time, unlike BlogJet, it just saves to the same file I saved before and doesn't prompt me to pick a new file and then, when I select the same file, ask me if it's okay to overwrite it.  That really bugged me about BlogJet.  With WB Editor 2.5.1, CTRL-S works just like you'd hope, although it does pop up a notification saying it was saved, which is a bit annoying but can be dismissed with a spacebar slap.  I'd prefer the notification be in the status bar, but it's still much better than BlogJet in terms of saving drafts.

 
Post Authoring with WB Editor 2.5.1

Note that the color is green; it comes with three theme (skin) options: Blue (default), Green, and Pink.  I've always had a penchant for green.  Note also that the coloring of the post itself is like my dotNetTemplar blog; you can set this up using the options by specifying styles.  It's kind of nice so that you get a better feel for what it looks like, but it would be helpful to 1) allow for a stylesheet per blog and 2) encapsulate the entire post in a div to better capture the L&F of a single entry on a blog site (not sure how this would work in the editor, though).

I also like how ridiculously easy it is to insert images and screen shots.  When you click the insert/upload image icon, it has a friendly dialog that lets you pick the image or even paste from the clipboard.  It offers the option to automatically create a thumbnail and upload them both either via FTP or to Flickr.  I haven't tried the Flickr option, but it works great with FTP.

Adding Images with WB Editor 2.5.1

The HTML itself is clean, too, and it has a nifty little snippet insert drop-down for common stuff.  This is important to me because I don't want my editor using any markup--I want to leave it to my style sheets.  And it seems to play well with that.  It also highlights nicely, and the highlighting colors are personalizable.

HTML Editing with WB Editor 2.5.1

Being a sucker for good UI, I enjoy the main screen that shows your registered blogs.  Yiyi has gone to the trouble to get images for the major blog engines (needs to update .Text to CS), so you get that along with a screen shot of your blog, the URL, and the categories.  And yes, you can of course cross post to multiple blogs, which is one reason to use an editor like this.

 
WB Editor 2.5.1 Home

One of the really nice things about WB Editor from a .NET developer's perspective is that it has a plug-in architecture (currently running on .NET 1.1). 

WB Editor 2.5.1 Plugins

An important plug-in for devs is a code highlighter.  It may not be the nicest formatting, but it works.  If you don't like it, you could easily write a plug-in to use a formatter that you do like.

[Serializable]
[XmlRoot("links")]
public class NavigationRoot
{
    NavigationLinkCollection items = 
        new NavigationLinkCollection();
    [XmlElement("link")]
    public NavigationLinkCollection Items 
    { 
        get 
        { 
            return items; 
        } 
        set 
        { 
            items = value; 
        } 
    }
}

Another feature that I like about WB Editor is its roadmap, which promises to stay on top of the latest technologies from Microsoft, such as 2.0 and ClickOnce (coming in the next version) and ultimately .NET Framework 3.  It's a project that I could get excited about working on, and as you can see from the blog, it is actually being worked on.  Of course, it has other features that you can read about in its features list; I'm just highlighting the ones I think are cool.

So in short, it has everything that I'm looking for in a rich-client blog editor, and I'd recommend it over the much lauded BlogJet.  It is also competitive in pricing, currently at $19.99, which for a great piece of software like this is outstanding.

Reading
Now, I did mention at the beginning that I'd also settled on an RSS Reader.  I looked at a few, RSS Bandit, FeedDemon, Windows Live, Awasu, and probably a few others that don't readily come to mind.  My issue with all of these is the amount of work involved in setting them up.  It's not that they're particularly troublesome if you can live with a straight list of blogs from your OPML file, but if you like to categorize like I do, then it becomes troublesome, especially when you use multiple machines with multiple OSes on them.  Having to repeatedly setup my subscriptions kills me, and it's one reason I have always avoided using newsgroups.

Ideally, I'd like to just set them up once, and be able to read them either online or in a rich client, and have both of those stay in sync.  The only such RSS reader I ran across that met the bill was NewsGator, and in particular, their Inbox product that integrates with Outlook.  I might have gone with their FeedDemon product, except I am in fact one of those users that almost always has Outlook open, and I figure why have another app that is always running.  Also, I bought Newsgator way back in '04 when it first came out, so having an already-purchased license (with a free upgrade to the latest version) helped me decide.  Naturally, I had long since lost my license info, but they have a nifty license retrieval mechanism, so it was painless to get it going. 

The feature I most like, in case I wasn't already clear, is that they integrate and synchronize with their online reader, so I can have the best of both worlds, and when I want to set the rich client up, I can just grab the stuff from my already setup online source.  I can make new subscriptions and reorganize them on either the rich client or web, and it will keep them in sync.  It's the best of Plaxo for RSS.  Ah, now this is software for the connected world.

So that's about it.  I just thought I'd pass along my findings to you in case you've found yourself in a similar predicament.  I'm not trying to convince you to change if you're already happy with your setup, but if you aren't happy, consider these two products for the total blog/RSS reading and authoring solution.  I hope it helps!

I recently got an email about a new service to add my blog RSS feed to Live.com (note the new icon on my blog, if you visit it).  For some time, I've been wanting to look into an AJAX-based web client for reading my blogs because I've found, like newsgroups, I just don't like having to set up everything I'm subscribed to on every computer I use.  At the same time, I do want a good UI.

Well, I've been putting off doing the research for it (and my blog reading has suffered for it).  Today I thought I'd check out what Live.com is like as an RSS reader, so I first tested using my new link to add to Windows Live.  It works and basically adds a little RSS reader gadget for my blog.  So then I thought I'd check out how it'd work with all my blogs, so I got the latest OPML (based on my blog roll here) and used Live.com's import feature to import them all.

At first, I was a bit disoriented because it said it imported but it wasn't showing them anywhere (I expected them to be put on the page I was looking at when I imported them).  But then I found them in the My Stuff section.  So I started building out my layout.

I started with the default two-column, but I quickly realized that wouldn't work, so I switched to four column, which seems to be just right at 1280x1024.  I knew I wouldn't want them all on one page, but I did want some categorization, so I came up with non-technical blogs, architecture blogs, and other technical blogs, one Live page for each.  Then, if it made sense, I categorized by column.  The results follow.

This is the "Other Technical Blogs" page.

This is the "Architecture Blogs" page.

Now great, you may be thinking, I can use this as well.  Let me warn you, there were a couple MSDN blogs that repeatedly and totally hosed IE7 (I'm running Vista B2 x64 on this box).  I figured out which blogs they were and removed them from my stuff.  But even doing that, IE was still having problems, and as you can see from the image below, there's a reason for that.

Note the top entry.  IE is running at 50%, but this is a dual-core Athlon CPU, which means on some machines it'd be trying to use 100%, and the memory usage is out of this world (350MB), even bigger than Visual Studio!

From the people I've talked to, having Live.com eat up CPU and RAM is not unusual.  Not being a Javascript and AJAX guru, I'll withhold any harsh judgments as I can readily imagine how it could be problematic.  But all I'm sayin' is that it ain't ready for primetime blog reading at a very basic level.

Beyond the performance issues, it also has no tracking of read/unread and no notification of new posts, both of which I think are indispensible for any kind of RSS reader.  Now, I understand that maybe I'm abusing what they intend for the usage scenarios to be, but why else make it possible to subscribe to RSS feeds than to be an RSS reader?  As it is, the gadget is only good for limited use for maybe news services or the like where you don't care about having your read/unread tracked.

I will say that it has a neat little image capture feature where it'll grab any images in the feed and thumbnail them for you, even do a fade in/out if there is more than one.  It also has neat little mouseover previews, which I like.  It's not totally unusuable in terms of features to be sure, but it would be nice to see a better blog reader gadget that maybe would offer some basic categorization, read tracking, and possibly some sort of notification, though I'm not sure how that'd fly given it is web based.  I'm going to keep trying out Live.com like this to see if they improve it.

On the positive side, this motivated me to blog about it and, in the process, try out a new blog authoring tool, WB Editor 2, based on the recommendations of John Forsythe.  It has a pretty friendly interface, is easy to set up (as these things go), and it is cheap.  This post  is being authored with it, so if there are any issues, well, there you go, but it was easy to add the images, and it created the thumbnails for me and uploaded them along with the main images.  I also like that it has a plug-in architecture that is .NET based, even if it is 1.1.  So far, I like it even better than BlogJet.

Is anyone else as frustrated as I am with the multifarious password policies you run into across systems?  It seems like everyone and his brother has "the best" idea of what a strong password should be, which translates into having to keep up with N passwords and which systems they map to. 

That's bad enough, but then you have these people who think that making you change your password every N days is a good idea and that you can't use the last N passwords you've already used.  To make it worse, some brilliant minds out there think that forcing us to have "strong" usernames is a good idea too, so you end up with something like N^N permutations of usernames and passwords that you have to track. 

"So what?" you say.  "We've got a nifty 'Forgot Password' option on our site/app/etc.." 

But I have to ask, is that really ideal?  Perhaps if we didn't have to keep track of N^N passwords mapped in matrices to the N! systems we use, we wouldn't forget them so often! 

I'm not saying that having strong passwords is a bad idea, not at all.  I'm suggesting that we all work toward agreeing on what a strong password is and come up with, dare I suggest, standards based on data sensitivity.  So for instance, here are some ideas:

1. If all you've got for a particular system is generic profile data, that would require a very low strength password, say minimum six characters, no special chars or numbers required. 
2. Then you might have a next level for systems that keep your order history (but no financial data per se).  These kinds of systems might require eight characters with at least one number.
3. You might then have systems that store financial data, such as credit cards, but are still a commerce system; these could require eight characters with at least one number and one special character.
4. Then there are the actual banking, trading, etc. systems, and these might require ten characters with at least one number and special character.
5. For systems above this level (e.g., company VPN), you would want to have some kind of dual authentication with a strong password and RSA tag, smart card, bio, etc.

Anyways, the point is not necessarily that these are the best specific guidelines; I don't consider myself a security expert, but I know enough to understand that what we have going on is not likely adding to our general security because in order to keep track of all these authentication tokens, we have to write them down somewhere, store them in some vault, file, sticky pad, etc., which in the end likely makes our security less, and it certainly adds to both individual and organizational administration overhead to manage password resets, fetches, etc.

If we had standards like I'm suggesting that were well published, then every Joe that goes to write a new system would easily be able to put in place a policy that is both secure, appropriate for the data being protected, and manageable for everyone involved.  If we only had maybe four passwords to remember, even if they're odd and funky (with special characters and numbers) or if they were pass phrases, we would have to write them down or forget them or manage getting them reset all the time.  In other words, we'd be more secure and happier.  And if we do have such standards, they need to be far more publicized and talked about when the subject comes up because I've not heard of them, and I don't think I live in the proverbial cave.

I just finally got Windows Vista up and running on my DFI LANPARTY SLI-DR board (has nVidia's nForce4 chipset).  Plugged into that are an AMD Athlon Dual Core X2 3800+ chip, 2 GB RAM, 2 Western Digital 36.7 GB 10K SATA (setup as RAID 0), and an nVidia GeForce 6600 GT (not running SLI yet), among other less important peripherals. 

It wasn't easy getting this going.  nVidia has 64 bit Vista drivers for its chipset, but they're incomplete and the instructions they post on their site don't work for me (and others).  Thankfully, someone else has put together an install guide, but even with that, it took me two tries to get it going (it didn't like my USB drive the first time apparently). 

The silly thing is that Vista B2 won't ask me for my drivers before it summarily decides that it can't find any information about my disks, so you have to start from an existing XP installation and run the installer from there and install on a secondary partition.  I hope they get this resolved by release because I'd really like to repartition my drives and install it on my C drive.  Maybe my blogging this with my specs will help others who are in a similar situation.

Anyways, it's up and running and it is pretty nifty so far.  I'm one to go in for eye candy, and I love the new Flip3D and Glass (about all I've really had a chance to play with thus far).  I can say it is a bit annoying that when it prompts you to run something as admin that the whole screen blanks out; don't know what that's all about.  Maybe it's intentional just to ensure they have your attention...

One thing I can't seem to get working now is the gadgets.  I show the sidebar and it is just blank.  When I try to add gadgets, nothing happens.  Will google more for the answer...

As most of you know who follow my blog at all, I recently joined Infragistics.  Well, I finally got around to getting my company blog set up, so if you're curious or interested, feel free to check it out and maybe subscribe.  While you're there, if you are a customer or potential customer, you might want to look around at the other blogs and maybe subscribe to some of them to stay on top of Infragistics stuff.