The Hawthorne Effect

Dealing with Envy In the Workplace

2010-09-13T08:04:00.001-07:00

I came across this article when thinking about the role of envy and competition in the workplace: Envy in the workplace: Jealous guise. The Harvard Business Review article that it is cited in this article is also worth finding and reading. It’s noteworthy that IT firms were some of the companies cited in the articles. One of the problems that managers do need to watch out for is the situation when one worker tries to sabotage and hold back another person because of the green eyed monster. This can have tremendous negative impact on an organization and sink or delay critical projects if one person tries to keep another from receiving due credit.

Technorati Tags: Workplace bullying,Envy in the workplace

Troubleshooting the Generic Error Message

2010-08-18T11:23:00.001-07:00

A few years ago some Visual Basic 6 code that I had written returned the following error code: Microsoft Oracle Driver: ODBC/OLE DB error –2147217900. I was adding an update to some legacy code at the time; prior to that time and since then I’ve written code primarily in C# and VB.NET. Yet sometimes the errors that can come up in .NET can easily be as difficult to troubleshoot as this one. The result when the solution is found can be not only that the application is made properly functional and robust, but that as a professional developer one can learn more about the code, the application as a whole and the application’s underlying environment and architecture than otherwise, So, taking the troubleshooting to its conclusion can actually be a valuable learning experience and step forward in one’s own professional development.

The first step that I took was to find out as much as I could about what the error message means. Researching the meaning of the error is the step that many inexperienced programmers do not take or do not pursue as thoroughly as they could. It’s sometimes been painfully difficult for me to get them to look up the error code and message in the MSDN documentation, Google or Bing. Yet that’s often the quickest way to understand what the error is and why it occurred. A developer who does this will often find a quick and immediate solution as well, such as a missing configuration file entry. But in my case, all I could come up with was this meaning for the message: “Syntax error or access violation.”

The code compiled and ran correctly until it tried to execute a SQL statement to access the database. The SQL statement was actually calling a stored procedure with parameters. It ran correctly on the development machine when it accessed the development database. So, my troubleshooting steps went along the lines of investigating whether there were problems with the syntax of the SQL statement when it was being executed or the access rights of the identities which the application used to access the database.

My steps included:

Checking the access level on database tables and the Oracle stored procedure.
Double-checking the execution of the stored procedure under the actual client ID that the application was using to access the database.
Upgrading MDAC when MSDN documentation suggested that a later version would be beneficial.
Adding debugging code to print out to a local file the values assigned to the parameters of the stored procedure before the procedure was executed to make sure that they were being assigned correctly.
Double-checked the call to the stored procedure that was in the ODBC syntax: “{ call <procedure> ( {?, ?, ?} ) }”.
Double-checked the parameter names even though it was clear that ODBC was using the ordinals for database table column access.
Used the debugger and immediate window inside Visual Studio to research the successfully executing syntax as much as possible.

As it turned out, there was an obscure permissions problem with the generic user id that the application normally ran under on the application server. When this was corrected, the error message disappeared.

The reason that I’m able to reproduce the steps that I took to troubleshoot and resolve this error is because I started a troubleshooting log when it became clear to me that this error had no immediate and obvious solution. This is also a troubleshooting method which many inexperienced programmers do not take. This involves writing down each possible cause and solution that is researched, attempted and the result. This includes such things as code modifications, environmental modifications and configuration modifications. This helps not only to find the cause of the problem, but also to be able to roll back attempted solutions which do not resolve the problem – something which is as important as solving the problem itself.

Technorati Tags: Error Handling,Troubleshooting,Troubleshooting log,Generic Error Messages,Troubleshooting procedures

.NET Refactoring Opportunities: Synchronization Locks

2010-08-18T08:13:00.001-07:00

This post will begin a series of posts on common coding problems that I’ve seen in .NET applications over the years. Most of these are documented problems or best practices, yet many times these can be found in source code. Understanding and correcting these can often provide dramatic differences in existing applications in performance, maintenance and robustness.The first one deals with a problem that I’ve seen even in sample code included in corporate standards documents.

What’s wrong with this C# code?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace DaleWare.BlogDemo.CSharpDemoLibrary
{
    public class BadLock1
    {
        public static void DoSomethingMethod()
        {
            lock (typeof(BadLock1))
            { 
                // something I want to synchronize goes here
            }
        }
    }
}

Or the equivalent Visual Basic code?

Public Class BadLock1
    Public Shared Sub DoSomething()
        SyncLock (GetType(BadLock1))
            ' Something that I want to synchronize goes here
        End SyncLock
    End Sub
End Class

Or this C# code?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace DaleWare.BlogDemo.CSharpDemoLibrary
{
    public class BadLock2
    {
        public void DoSomethingMethod()
        {
            lock (this)
            {
                // something I want to synchronize goes here
            }
        }
 
    }
}

Or this equivalent Visual Basic code?

Public Class BadLock2
    Public Sub DoSomething()
        SyncLock (Me)
            ' Something that I want to synchronize goes here
        End SyncLock
    End Sub
End Class

All of these examples do something that appears in Microsoft documentation as a worst practice: locking on a type (C# typeof(class) or Visual Basic GetType(class)) or on an object (Visual Basic Me or C# this) itself. This is a known problem that can cause deadlocks or unnecessary delays in execution. Searching on Google or Bing can produce a number of developers who’ve run into these problems and Microsoft documentation warning not to lock on the type or the object instance.The recommendation is now, and has been for some time, to lock rather on a private object variable on each class.

Here is an example in C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace DaleWare.BlogDemo.CSharpDemoLibrary
{
    public class CorrectLock
    {
        private object _syncObject = new object();
 
        public void DoSomethingMethod()
        {
            lock (_syncObject)
            {
                // something I want to synchronize goes here
            }
        }
    }
}

And here is an example in Visual Basic:

Public Class CorrectLock
    Private Shared _syncObject As New Object
 
    Public Shared Sub DoSomething()
        SyncLock (_syncObject)
            ' Something that I want to synchronize goes here
        End SyncLock
    End Sub
End Class

This is a simple change that can be made during refactoring source code, code inspections and standards documentation and revision. And it is worth it to avoid possible deadlocks and other synchronization problems in a corporate .NET application.

Technorati Tags: Refactoring,.NET synchronization,lock(this),SyncLock(Me),lock(typeof(,SyncLock(GetType(Me))

PeopleWare Issues: Professional Culture and Party Culture

2010-08-17T09:30:00.001-07:00

In a previous post, I mentioned departmental ‘happy hour’ get togethers in IT organizations. I’m not out to eliminate them totally, but I think that managers and team leaders do need to be more aware of the issues that can happen.

The first issue is that some IT organizations may have some ‘party animals’ who may pressure others to drink, to drink heavily and to get drunk. I’m not sure that managers and HR people are cognizant of the issues that this could cause with the lives of coworkers and the possible issues of harassment, litigation and liability that might happen. I myself simply refuse to go along and don’t want even to be seen as implying or threatening any kind of lawsuits on my own behalf, but I’m simply sharing information that may be overlooked and seeking to make some constructive suggestions.

There are a number of people in IT who do not drink because of moral and religious convictions, and I’m not unique in that regard. For instance, many Christians, and Muslims and Mormons in general, do not drink because of religious convictions. Moreover, a person going through an addiction recovery program such as Alcoholics Anonymous will not drink because that person has the conviction that, for that person, “One drink is too many.” Those of us who do not drink because of our convictions simply should not come under undue pressure to do so at a get together under the auspices of our place of employment. To allow this to happen could cause issues of corporate liability and litigation for anti-religious harassment and failure to accommodate an employee’s strongly held religious beliefs.

There is a possible issue of corporate litigation and liability as well if there is pressure to drink heavily and to get drunk at a corporate social gathering if someone ends up driving home under the influence of alcohol. This could result in that person being charged with a civil crime, and if there is an accident or death involved, the corporation has been named in civil lawsuits in these cases in the past. I’ve worked with corporations who did provide taxi rides home for anyone who felt the need of one, and that is a policy which I also support.

Here are several suggestions that I would make:

Seek to provide other social activities besides ‘happy hour’ get togethers. Lunch get togethers usually work well, and these often provide the opportunity for coworkers to attend who could not attend an after hours ‘happy hour’ get together because of family priorities. Single parents who need to pick up their children from day care and parents who need to be home when their children come home from school are also often left out for after hours ‘happy hour’ activities.
Managers and supervisors need to be aware of and correct anyone that is trying to put undue pressure on someone else to drink and get drunk. A simple, “Knock it off” or “Drop it” would usually be sufficient.
Managers and supervisors should consider whether someone who is getting consistently drunk and pressuring others to drink at these gatherings is in fact an alcoholic. Many corporations offer employee assistance programs to deal with this issue, and this may be something that a manager needs to speak to an employee about with the assistance of HR.
Managers and supervisors need to understand how embarrassing and difficult it could be for someone to bring up the issue of being pressured to drink against one’s convictions can be. It’s something that a person may simply want to go away and not make an issue about, and not appear to be trying to play a victim. If someone does approach with this concern, be prepared to deal with the issue sensitively with all concerned parties and to prevent any kind of retaliation.

Technorati Tags: IT Management,Professional Culture,Party Culture

PeopleWare Issues: New Employee Orientation and Cross Training in IT

2010-08-16T14:07:00.001-07:00

Over the years I’ve done a great deal of bringing new employees up to speed and cross training others as a part of my responsibilities; I’ve also served as a team lead on jobs and trained others even before I entered IT. I’ve been seeing some common tendencies that happen when others in IT try to train new hires and colleagues. I think that understanding and dealing with these tendencies will help our IT organizations to bring new hires to consistency and productivity much more quickly and help to make sure that orientation and cross training really does deliver IT employees the information that that they need to perform their responsibilities.

Here are the tendencies I’ve seen, with their IT-appropriate acronyms:

TMITQ: Too Much Information Too Quickly: The person doing the training has a motor-mouth delivery that throws out a lot of technical information all at once.
TMT: Too Much Talking: The person doing the training indulges in a one sided lecture to the other employee as a captive audience.
TMA: Too Many Assumptions: The person doing the training makes too many assumptions about what the other person already knows or doesn’t know or comes to know as a result of the training.
NGP: New Guy (or Gal) Paranoia: The person doing the training has some kind of misgivings about the other person’s qualification or something else about the new person.

Here are my suggestions for anyone helping to bring a new person up to speed or doing any kind of cross training:

Understand the purpose of orientation and training. It is to give the other person the information that he or she needs to do his or her job and the tasks that are a part of the job. It is not to try to impress a captive audience with a display of your knowledge.
Get to know enough about the other person’s educational and work experience at the start of training so that you can tailor the training to the person’s level of understanding. Remember that it’s a great waste of time to belabor the basics with senior people who come in with a great deal of experience.
Don’t make the training just technical, but include positive things about company culture, goals and objectives. Avoid any complaining about anything or anyone.
Do not rush through the training, but pace the training to what is comfortable for the other person. Speak slowly and clearly enough so that you see the ‘wheels turning’ as the other person digests what is being communicated, and be ready to stop and clarify if you sense that the other person is getting confused.
Give the other person a chance to take notes and ask questions. In fact, regularly stop, ask if there are any questions and provide the best answers that you can. It should be a regular understanding that there are no stupid questions in IT, but rather conscientious people trying to get the information they need to do their jobs.
If possible, do the training on the other person’s computer, and allow the other person to use the mouse and keyboard as much as possible. If the training involves using a browser, give the other person a chance to bookmark sites.
Provide the other person with as much application and infrastructure information, diagrams and documentation as necessary to do the job. It’s reasonable to give the other person the names of any relevant servers, websites or applications, and to write these down if they do not appear on any documentation.
Repeat things if necessary, since repetition is often necessary to retain information. If someone asks a question that requires repetition of something that was previously discussed, don’t assume that the other person wasn’t paying attention. Rather, the other person may simply need to make connections with the different kinds of information that were provided earlier. Simply backtrack to what had been previously discussed, and take it forward to where the current focus of the training is.
If the training includes modifying and checking in code or fixing bugs – and it should in a software development job – go through fairly simple examples at first, and allow the other person to see the source code and development environment.
If there are internally developed utilities or libraries, or utilities and libraries which with the other is unfamiliar used in the software development process in your organization, provide any documentation, cheatsheets, support websites and anything else helpful to be able to use these utilities and libraries. Inexperience or unfamiliarity here does not mean that the other person does not have the qualifications, experience or capabilities to do the job; it usually means that the other person has worked in another environment or hasn’t had to use them.
If the other person makes mistakes, provide correction and help to resolve any problems without humiliating the other person. Treat each one as a learning experience.

One of the biggest financial investments that IT organizations make is in hiring new employees and in bringing in contractors and consultants to provide additional skills and help shoulder the workload. Simply making sure that new employee orientation and cross training is effective is a great part of making sure that that investment pays off quickly and completely.

Technorati Tags: Training,Cross Training,IT Management,Lateral Leadership,Team Leadership,Team Development,New Hire,New Employee Orientation

What My ‘NonTraditional’ IT Background Really Means

2010-08-16T12:24:00.001-07:00

Over a decade ago, during an interview, a hiring manager whom I greatly respect remarked about my resume, that it was one of the most unique ones in IT. I found that to be an entertaining and tactful way to put it.

Here’s what’s different about it. I have a Master of Divinity degree, and served as a pastor in the Christian and Missionary Alliance from 1985-1993. That’s not where most people in IT come from. What’s more, my undergraduate degree is in Classics -– Greek and Roman language, literature and culture. That’s not the Computer Science or Engineering degree that many of my colleagues have earned.

So, what does this mean as far as my qualifications for IT, and specifically, for software development? Well, on the one hand, that’s not all that there is about my background, skills and qualifications, and on the other hand, there are some things from that part of my background that have some relevancy.

First, there are some false preconceptions that others have about what it has meant for me to be a pastor and what it means for me now.

As a pastor, I wasn’t some kind of political operative. Political indoctrination wasn’t and isn’t part of the mission of a church nor the responsibilities of a pastor. In fact, the IRS will easily revoke the tax exempt status of a church, and in the process, probably get the pastor fired and blacklisted from his denomination if the pastor undertakes these kinds of activities as a church activity and the church facilities are used for political activities.
My background as pastor does not mean that I will come in and try to be the ‘moral policeman’ of a department or an organization. There will be activities that I may decide not to participate in, such as departmental ‘happy hour’ get-togethers, depending on how much pressure there is before and during the activity to drink and to get drunk. (I would add that managers need to be aware of the issues with liability and litigation that can result from these situations.) Nor am I a prohibitionist who goes around trying to reform the ‘party animals’ in an organization. In other words, I will seek to live in accordance with my own convictions, and that can be an asset to an organization, because those convictions include working with foresight, skill and integrity.
My background as pastor does not mean that I will try to do ‘churchy’ things during the course of a work day. As far as me doing things like stopping my work, standing up and delivering impromptu sermons during the middle of the work day, or trying to perform weddings for others in the organization, or badgering people about attending my church – those things simply aren’t going to happen.
I’m not a part of some paramilitary militia or anything like that. I’ve served in a respected denomination that’s been around for over a century with a publicly available website and statement of faith on that website.
I’m not a Catholic priest, nor have I ever been a part of the Roman Catholic Church; I’m a Protestant minister, and no one ever has to call me, ‘Father’, ‘Pastor’ or ‘Reverend.’ I’ve actually always preferred simply to be called ‘Dale.’
I didn’t leave the pastorate because of being connected with any kind of scandal.

Second, the course of my education and background has provided considerable skills and capabilities that proved to be transferable to IT:

As a pastor, I was responsible for public speaking two to three times per week. This transfers into being comfortable in front of audiences and being able to deliver presentations.
As a pastor, sermon preparation called for a great deal of self study and self initiative to get things done each week. So I’ve been proactive outside the pastorate in finding and getting the training that I’ve needed, reading the manuals and documentation, and getting things accomplished without a great deal of supervision and micromanagement.
During my high school, college and seminary education, I gained fluency in Latin, ancient Greek and Biblical Hebrew – three languages which no one speaks. This gave me experience in working with human languages no one speaks, which transfers to working with programming languages no one speaks, and a prior understanding of different fonts and alphabets. Unicode, anyone?
My math and philosophy education included symbolic logic, pre-calculus and calculus, and I understood and was easily able to work with things like Boolean logic, sets, functions and coordinate systems.
During my education, writing played a major part in achieving my degrees, and my ability to write clearly has helped me with preparing technical documentation and with other areas of my work that called for expressing my thoughts and communicating to others clearly through the written word.
My business experience outside IT and the pastorate included call center, business process documentation, financial accounting and operations research experience, and helped me to understand business beyond IT. Moreover, it gave me some ideas and convictions about what efficiency, profitability and customer service mean to a business as a whole.

Third, since I left the pastorate in 1993, I’ve definitely sought to gain whatever training and education that I’ve needed. Here are some things that I’ve done:

I’ve had a personal Microsoft Developer Network (MSDN) license pretty much since 1998, and I first learned classic ASP and MS SQL Server primarily through going through the MSDN documentation.
I’ve taken internal employer provided training wherever possible, and this has included classroom training on Visual C++, DB2, Mercury WinRunner, LoadRunner and TestDirector, quality assurance for IT, and project management, among others, computer based training on C, C++, Visual Basic, HTML, and COBOL, among others.
I’ve taken classes in the Master of Business Administration program at the Weatherhead School of Management at Case Western Reserve University, which included a class on object oriented development and the Unified Modeling Language.
I’ve attended outside special interest groups and seminars where available, and count myself quite fortunate to have heard such technical lights as Juval Lowy, Kathleen Dollard, Julie Lerman and Steve Smith in person.
I’ve acquired a number of manuals over the years, and read as much as possible from classic literature. Recommended reading lists such as that in Steve McConnell’s Code Complete had a considerable influence on the personal IT library that I’ve collected over the years.
I’ve subscribed to a number of magazines over the years, such as Software Development (now a part of Dr. Dobb’s Journal), C/C++ User’s Journal, Visual Studio Magazine and MSDN Journal.

Moreover, to corroborate what I’ve learned, I’ve also put in the time, expense and effort to earn these IT certifications:

Microsoft Certified Developer (MCSD) in C# .NET.
Microsoft Certified Professional Developer (MCPD) Enterprise Developer in C# .NET.
Microsoft Certified IT Professional (MCITP) in MS SQL Server Database Development.

What I’ve learned and put into practice without having a Computer Science or Engineering degree has been more than sufficient for me to fulfill of my work responsibilities, to make significant contributions over the years to many projects completed on time and within budget, and to provide creative and innovative solutions to specifications, requirements and wicked and difficult problems. So, my ‘non-traditional’ background did mean some difficulties in getting established in IT, but it’s made me work harder to keep my capabilities current and to provide solid contributions where I’ve worked.

Over the years, I’ve come into contact with others who have had ‘non-traditional’ backgrounds and who have been working in IT and quite productive and valuable employees, contractors and consultants. When it comes down to it, no one has to understand or approve everything in the background, work experience or off-hours activities of a colleague to work effectively with that person on a team or in a project. Rather, IT provides many opportunities to work with and understand others who are different than we are, and to learn how to work effectively with them.

Technorati Tags: IT NonTraditional Background

PeopleWare Issues: The Impending Personal Evaluation

2010-08-16T10:07:00.001-07:00

As a contractor/consultant, I’ve learned that when the developers who are permanent employees suddenly start doing irrational things on a project, it’s often because personal evaluations are due within a week or two. What happens are things like these:

Developers suddenly start pushing possibly unproven, retrograde and even bug ridden code that they wrote into a project, so they can beef up the accomplishments section of their personal evaluation.
Developers start adding unproven, retrograde and even bug ridden external libraries into a project, so they can beef up the accomplishments section of their personal evaluation.
Developers suddenly start finding long unacknowledged problems for which they can claim implementing fixes on their evaluations.
People who were difficult to work with suddenly start acting nice, so that they can claim that personal conflicts which may have been mentioned on previous evaluations have been resolved.
Coworkers suddenly start sending each other complimentary emails which can be copied and pasted into evaluations.

And so on. There are a lot of things that happen when the personal evaluation is due which can cause problems in IT projects and infrastructure down the line. In addition, the material in the personal evaluation is used extensively to determine promotions, salary increases, bonuses and retention, so skewed data can result in people going into responsibilities for which they are less than qualified in terms of their skills, capabilities, work ethic and teamwork, and perhaps even holding back more qualified people. So, there’s a need to make sure that tasks which seem to being undertaken to beef up the evaluation are evaluated on their own merits and done within established procedures and within quality guidelines. There’s also a need to make sure that the evaluation represents a genuine, solid contribution to the department that has occurred over the evaluation period, and not a flurry of last minute activity nor a parasitical hijacking of credit for the contributions of others.

Here are some suggestions for working through and improving the process:

For managers: Make as clear as possible the goals of the personal evaluation process both when personal evaluations are done and personal performance goals are approved for the time to come.
For managers: Ask for and suggest revisions to provide clarification in standard forms if you find a lack of clarity and that your people are consistently being confused by what standard forms mean. If you cannot do that, go over the forms and develop a list of clarifications as to what the requirements stated on the forms mean in your department -- without contradicting anything set forth by upper management, HR or the legal department, of course.
For managers: Be aware that some people will try to ‘game’ the process and ‘play the system’ to gain undeserved credit for themselves and sometimes at the expense of others in the department and the organization. Get ideas on how to handle these situations from HR, upper level managers and more experienced managers. It is a knock against your own reputation and other’s perception of your competence, integrity and ability if you allow people in your organization to get away with this consistently. Revisions and deletions are appropriate where the depiction of the performance on the evaluation greatly exceeds the actual performance.
For upper managers and HR: Understand that some managers will likewise exaggerate the performance of their direct reports as their way of ‘gaming the system’ to gain undeserved credit for themselves and their department. While some departments really do have a high number of high performers, others may not, though they may try to give the impression that they do. It’s really not fair to downgrade the rewards available to a manager who really manages and develops a high performing team and the members of his or her team, especially if that results from undeserved credit to a manager and team which has actually performed less.
For managers: Make it clear that you’re willing to clarify personal performance goals during the evaluation period. Renegotiation may be necessary in some cases.
For managers: If you are adding project leadership or supervisory responsibilities to someone’s developmental goals, communicate your expectations clearly for how you expect team members to be treated and add on some kind of goals for supervisory and leadership training and enrichment.
For IT personnel: Read the directions carefully for the setting of personal performance goals and the personal evaluation process beforehand.
For IT personnel: Take enough time to put in your part of the personal performance goals for the coming evaluation period and the evaluation itself. Do what you need to do to guard your privacy and avoid interruptions during this time. When I did mine, I usually worked after regular working hours, especially when my cubicle was adjacent to an aisle where my computer screen could be easily seen by everyone who passed by.
For newly hired and entry level IT personnel: Go over the process with an experienced, trustworthy person, and be ready to ask your manager and HR representative any questions. Make sure that this is done as requesting clarification and not criticism of the process – the first will mark you as a conscientious employee and the latter as a potential problem person.
For IT personnel: Take some time – maybe a half hour to an hour every month or every two weeks – to re-read your goals for the evaluation time period, and evaluate your current activities in light of that.
For IT personnel: Keep a running list of how you’ve accomplished the established performance goals throughout the year, rather than trying to think back at the last minute at what you did since the performance goals were handed out.
For IT personnel: Address areas with the manager where things didn’t work out on projects and tasks well before the evaluation deadline. Find also some genuine lessons that you can sincerely say that you’ve learned from the experience, and which you can say that you will do better in the future.
For IT personnel: Step back, consider the whole experience in light of your career and long term goals, and take in the whole experience as relating to building your professional experience and long term qualifications for the future. Take the initiative to deepen and broaden your own professional skills, capabilities, teamwork and integrity, not just accomplish tasks on the list. This process can aid your own development and corroboration of your professional skills, capabilities, teamwork and integrity when the time comes for you to move on to greater professional responsibilities and the concomitant professional rewards.

Technorati Tags: personal evaluation,performance evaluation,performance goals,IT management,PeopleWare

ASP.NET Refactoring for Performance and Maintainability

2010-01-20T13:00:00.001-08:00

Here are some points which I wrote down which are ways in which many legacy ASP.NET applications can be refactored for greater maintainability and performance. Usually these are the kinds of things that I see in ASP.NET applications which are developed by junior programmers or developers coming to .NET from other platforms. These kinds of changes usually deliver substantial improvements in exchange for little investment of time.

Reduce string concatenation. This can often result in greater performance due to less memory being consumed in creating and disposing of string objects and less processor use. The use of StringBuilder objects, string constants with String.Format or StringBuilder.AppendFormat can often reduce the overhead with unnecessary string concatenation.
Replace inline string constants with string resource files or a constants file per namespace or assembly. Many developers have string constants sprinkled throughout their .NET classes, but consolidating them either in resources files or assemblies or a constants file aids reuse of the constants and internationalization of the application.
Change DataSets to lightweight Data Transfer Objects (DTOs) and collections of DTOs. I’m often surprised by how many ASP.NET applications use DataSets. Sometimes programmers prefer to filter DataSets rather than construct SQL WHERE clauses. One of the largest performance penalties that I’ve seen in an ASP.NET application came when a SQL query retrieved an entire table into a DataSet and then the DataSet was filtered on the application server. That method worked fine when the database table had only a few hundred rows, but destroyed performance when it grew to over a million rows in production.
Change .NET remoting and ASMX web services to Windows Communication Foundation (WCF). .NET remoting and ASMX web services are now, since the introduction of WCF, legacy functionality. WCF delivers superior performance, flexibility and maintainability. Invest the time and effort in the change.
Replace inline styles and Web control ‘look and feel’ property settings in ASPX pages with stylesheets, skins and themes. This helps to standardize the look and feel settings for an application. Usually developers unfamiliar with CSS prefer to set the properties in the Visual Studio designer. Yet the rendering is faster with standard style sheets. And skins and themes are one of the most underused features in standard ASP.NET applications.

These simple changes can often deliver a lot to extend the life, maintainability and usability of ASP.NET applications which have been around for a while. It’s well worth it to undertake them during normal maintenance and enhancement releases.

Technorati Tags: ASP.NET,Refactoring,ASP.NET Performance Improvement,ASP.NET Maintainability

The ‘Lack of Experience’ Obstacle in Software Development Organizations

2010-01-14T06:35:00.001-08:00

Kathleen Dollard, one of my favorite authors on software development, once made the remark that a lack of experience is holding our profession back. Over the years I’ve spent in software development, I’ve found substantial reason to agree. Here’s what I see as some of the obstacles to gaining a sound reservoir of experience in a software development organization.

The loss of experienced developers and architects from software development: Experienced developers and architects may go out the back door and take their experience with them.
Micromanagement by technically atrophied management: A number of times experienced developers go into management in software development organizations. Usually, their technical skills quickly atrophy, and they do not keep up with current software development processes. They may continue to give directions, but their directions make less and less sense because of the growing divergence between their own base of experience and current and appropriate software development processes. That’s often the reason why many projects have a strange resemblance to the way COBOL projects were done in the 1980’s.
‘Everyone starts at the bottom’ here ethic: This is an obstacle to bringing experienced new hires up to speed quickly. The assumption is that anyone new to the organization is entry level in his or her skill set. This means underemployment of experienced developers in tasks and responsibilities for which they may be highly overqualified. It costs the organization because they are overpaying for the results that they are achieving through these developers, and they are not developing less experienced developers for the tasks and responsibilities for which they are better suited. What this means is that skills and competence that someone has acquired elsewhere are dismissed once a new person comes into the organization.
‘We only recognize experience here’ ethic: This seems to be from a self-overestimation of the uniqueness of a software development organization. It fails to recognize that there are a large number of transferable skills among developers, such as the languages, environments and work styles. In fact, if any organization is that unique, it is probably highly inefficient and dysfunctional in its development processes and the results that it achieves. Its uniqueness probably comes not from the uniqueness of the business itself but from the quirkiness and inexperience of some of those who put together the current processes, infrastructure, architecture and code base of the current organization. Genuine quality and best practices are usually not unique to a single organization, but quirkiness and the dysfunctions of unconscious incompetence usually are.
Over-idealization of recent college grads: I’ve noticed that some managers far over-idealize the skills and experience of recent college grads who come into the organization. The entry level hires may have great potential, but I’ve found that often they need a long period of personal growth and development in a professional environment to realize that potential.
The pretence of perfection: An IT department or software development organization falls for its own hype and self promotion. Unfortunately, people who do not learn from their mistakes are going to keep on making the same mistakes. Rather, from CIOs on down, IT departments and software development organizations need to be learning organizations.
Business people are the source of all requirements and sponsor all projects: Often this means an unfair burden upon the business analysts and line business managers to understand and apply technology to the needs of business. Usually they do not have the base and breadth of experience to understand what current technology can do to generate cost savings, reduce errors, and gain competitive advantage. Rather, the burden remains on IT and software development managers, architects and developers themselves to get to know the business well enough to see the competitive advantages and cost savings that technology can provide. Creative and innovative applications will come where there is enough awareness of the business needs and capabilities of technology in enough people to see, explore and implement the possibilities.

Technorati Tags: IT Management,Kathleen Dollard,Software Development,Inexperience in IT Organizations

Focus on Appearance: Part IV of What’s Software Development All About?

2010-01-08T11:51:00.001-08:00

In my previous post on Usability I dealt with some basic web usability. Usability is also related to appearance; a usable site is often a site with a pleasing appearance.

Let’s start with another bad example from my own past. This screenshot is part of an old code sample document which I put together some years ago in the 1990s. It represents the state of the art for Microsoft Access 2.0 UI Forms in 1994. For the time, it represented a dramatic change in usability and appearance over character based mainframe application entry screens. Usually, in those screens, the user had to look over the screen for the action that he or she wanted to initiate, and press a function key or another key combination. Sometimes this involved placing the cursor on an input line and entering a command. A user was fortunate if the correct key combinations were displayed on the screen. Otherwise, this involved going to the training manual or having to memorize the correct key combinations. This kind of Windows based form in Access 2.0 was typically considered far easier to view and use than the green on black character based mainframe screens which they usually replaced.

It’s unfortunately true that many web page forms on a number of corporate websites, especially intranet sites, look too much like this page. Here are the problems in the above screen which find themselves into web pages.

The use of buttons. Links are not only more functional and usable, but look and communicate better than buttons like the screen above. They also simply look worse than links.
The use of primary colors to communicate information. This does not work well for color blind individuals. More subtle colors are also available within the safe web palette, such as pastels, and they are better used for backgrounds and contrasts.
The use of a default background color. A correct website should specify a background color which is complementary to the other colors chosen for the site or UI. At least battleship gray should normally be avoided.
The use of non-complementary colors. Many corporate web pages are designed with no awareness of how complementary colors can provide color variety and contrast without being loud and straining the eyes. The unintended, almost subliminal effect is like seeing someone dressed in clothes which clash wildly.
The use of asymmetrical elements. This can be because of differing text label sizes. Rather, the human eye prefers left to right symmetry, and finds something pleasing in it.
The use of serif fonts. A number of corporate web pages do not specify a web-safe font. I’ve been surprised myself to find Internet Explorer users having to use Intranet sites with a lot of Times New Roman. (I’m not fond of Times New Roman even when I’m using Microsoft Word.) Most users find sans-serif fonts more pleasing to the eye.

I’ve found these kinds of problems in Intranet sites which are assigned to developers who are transitioning from some other kind of development, most commonly Visual Basic 6 or mainframe development, to web development. Or, as I stated in my previous post on usability, this may appear in sites where the pages (the ‘screens’) are being designed by business analysts who have no training or experience in contemporary web design.

To avoid this, I would suggest that someone with an awareness of current web design review these kinds of sites as early as possible in the design phase. A definite set of web design standards and guidelines for intranet sites would be well worth the time to give each Intranet site a professional appearance. In addition, business analysts and beginning web developers would do well to go through a book like The Principles of Beautiful Web Design if they are responsible for designing web pages. Or at least go over some of the articles on web design on a site like Sitepoint.

Technorati Tags: Software Design,sofware development,Web Page Design,MS Access 2.0

Focus on Usability: Part III of What’s Software Development All About?

2009-08-20T12:57:00.001-07:00

This is the data entry form for an Access 2.0 database containing the Novell 3.x and 4.0 servers for Key Services Corporation and their corresponding parent organizations and administrators which I created in 1994 and maintained until 1997. In the time this was considered a great improvement over the character based green on black mainframe data entry screens. The user could tab from field to field, use the mouse or key combinations to press the buttons, and proceed fairly rapidly from entering new data to updating or deleting existing data. This was also the way many Visual Basic 3.0 to 6.0 application forms looked in the mid to late 90s.

Then the Internet came on full steam, and web usability became more of an issue. Many sites continued, and some still do, to use web input pages that look like these old Windows 3.x forms. They demonstrated these problems:

Users were forced to scroll right many times to view and fill in any input fields to the right. If these fields off to the right were required fields, it was usually harder to find them if the page failed to submit.
Many times buttons were used instead of links to open up new browser windows (which is an outmoded practice in itself) or to navigate to a new page.
Unrelated data fields were often on the same page, and sometimes not even grouped separately.
Pages which had a lot of data entry fields would take longer to post the data to the server.
The pages often did not have an apparent logical grouping or flow to the input fields and labels.

I believe that one of the reasons why pages designed according to this outmoded idiom persist and continue on some sites is that business analysts or developers from a mainframe or Visual Basic 6 who are not familiar with contemporary web design are designing these pages. I’ve seen this enough to believe that it’s not a problem restricted to one corporation.

Here is a more common way in which data entry forms are done on contemporary web pages. It’s so common that users practically do not have to think when they see a form like this. I’ve worked with web pages that follow this general pattern since 2000, in classic ASP, and it’s a more common and usable idiom on the web.

First Name	First Name Text Box
Middle Initial	Middle Initial Text Box
Last Name	Last Name Text Box
Address 1	Address 1 Text Box
Address 2	Address 2 Text Box
City	City Text Box
State	State Dropdown List Box
Zip	Zip Text Box
Submit

Here are some general guidelines for business analysts prototyping data entry forms/pages:

Understand whether the data entry forms/pages are to be done in Windows or Web.
Windows data entry pages should be prototyped with the print orientation set to landscape if the prototypes are done in Word or Powerpoint.
Web input forms need to be prototyped with the print orientation set to portrait if the prototypes are done in Word or Powerpoint.
Learn which input controls are appropriate to the type of input (checkboxes, radio buttons, list boxes, and dropdown list boxes).
Document the correct text tooltips as well as field labels. Both web pages and Windows forms can implement tooltips, and they form a very handy way to provide immediate help to the user.
Go over the prototypes with an architect or senior developer.
Avoid complexity in one form or page; seek to have one form or page handle input and updating of one set of data and have it do that well.
Be flexible and cooperative with developers if they suggest changes to the prototypes when they are actually implemented. The developers are the first users of the prototypes, and they can often make very constructive suggestions.
Consider getting and reading the book Paper Prototyping by Carolyn Snyder, and going through a paper prototyping process to investigate usability before any kind of implementation is started.

Technorati Tags: Software Design,sofware development,Web Page Design,MS Access 2.0

Downtime Pursuits

2009-08-08T10:00:00.001-07:00

In IT there can be some times when a developer doesn’t have much to do. For a consultant, this is often during the ramp-up time for a project, when the project is first starting, or during the cool down phase, when the project has been elevated to production, and it’s mostly production bug fixes for a while. When I’ve been an in-house developer, this has usually been times between projects.

I’m persuaded that the wise use of this time can make a huge difference for one’s own career progress and the good of the department and corporation as a whole. Unfortunately, there’s often a dearth of good ideas on what to do during this time, and seemingly irrational pushback if someone tries to do something which does not originate in the mind of a business sponsor who is an upper level manager. I think that the pushback comes at least partially from an unarticulated question, “Where we will charge the hours for this idea?” And I think that otherwise pushback comes from the unarticulated question, “Who will get credit for this?” And finally, I think that pushback comes from managers and supervisors who seem to think, “I don’t have time to supervise this or the political capital to get this done.”

Here are the five basic uses to which this time can be put:

Process improvements
Project or departmental infrastructure projects
Documentation
Personal R & D time
Peer training and assistance.

In short, these are the five things for which there are common complaints that there is no time for these things to be done when a project is actually underway, and managers, project managers and team leads are worried about making a due date and adhering to a project timeline. The truth is that these kinds of activities can actually reduce project timelines if they are chosen wisely. They come under ‘working ahead’ and ‘working smart' activities, rather than frenetic ‘I’m working as hard as I can’ activities. And if anyone is worried about charging time for these activities, someone needs to make sure that there is simply a bucket to charge these activities.

The key is that unlike a project for a high level business sponsor, these activities can be:

Low priority: Production issues or business projects take priority over completion of these projects.
IT centered: Directed to the greater efficiency of IT (developers, testers, business analysts, system administrators).
Automate minor manual business processes (1-2 users) such as repetitive data entry, credit inquiries or faxes of incoming information.
Left temporarily incomplete to be taken up by others to complete when time and availability changes.

Here are some ideas that I have for these kinds of activities.

Developing Visual Studio template projects for the kinds of projects which are anticipated in the near future.
Implementing Sharepoint sites with MOSS 2007 or WSS 3.0 for development teams or projects.
Developing code generation utilities for future projects.
Developing an automated build system with CruiseControl.NET.
Developing other departmental or IT utilities.
Developing Visual Studio add-ins or Guidance Automation recipes for future projects.
Documenting existing systems.
Updating existing documentation for existing systems (lots of existing documentation contains omissions and errors, and degrades over time).
Serving as a scribe to take meeting minutes to make sure that decisions and action items are clearly documented (lots of meetings end with no one agreeing on what was actually decided and who would implement the decisions).
Internal cross training.
Performance monitoring existing systems (lots of existing production systems, particularly those with a mid to small number of users, never receive any monitoring once in production).
Looking through event logs for avoidable and fixable errors (lots of fixable problems never are found and fixed even if sufficient information is logged).
Cleaning up bloated error logs and event logs.
Evaluating and upgrading existing error logging functionality.
Reviewing existing code for possible improvements.
Reviewing existing databases for possible improvements (lots of existing databases are never evaluated after being put into production).
Review of existing systems and databases for security bugs and user access (lots of existing systems and databases retain access rights for transferred or terminated employees or too high access levels for non-administrators).
Developing archiving solutions for existing databases (lots of existing databases never archive outmoded or obsolete information).
Developing ETL solutions for existing databases.
Developing automated unit tests for existing code modules (lots of existing code modules never get regression unit tests developed for them, and may break when enhancements are added).
Cleaning up source control projects and archiving outmoded code and projects.
Preparing and delivering peer training presentations, such as for a Lunch ‘n Learn or departmental meetings.
Conducting research on new technologies which could prove useful.
Developing prototypes for new technologies which could prove useful.
Automation of minor business processes with VSTO, VSTA and Microsoft Office.
Development of a process improvement suggestion site.
Development of a departmental wiki.

In short, the tunnel vision that sees any useful activity as having to be initiated by a person who is an IT or business unit manager can miss out on many possible improvements which can be pursued in the time when developers are not dedicated either to production support fixes or major projects. And yet these minor improvements add up over time and add to the bottom line value and efficiency of an IT organization and the corporation as a whole.

Here are some ideas to help this take place in a department or IT organization.

Encourage and reward the initiative and courage it takes to envision and suggest process improvements and to make wise use of down time.
Serve as an ‘angel’s advocate’ for new ideas and process improvements rather than as a cynical devil’s advocate who commits infanticide on the ideas of others.
Allow developers to get close enough to end users to develop the kind of trust to where end users can share their process improvement ideas.
Allow developers to see end users at work enough to where they can spot opportunities for process improvements.
Allow developers to explore new technologies early enough to find possible implementations.
Make sure that ‘idea theft’ is not rewarded either in the short term or long term.

Technorati Tags: IT Management,team development,consulting,contracting,projects,down time,process improvement,IT infrastructure projects

Blast from the Past: Automating Processes with Access Basic Code

2009-08-06T14:41:00.001-07:00

A long time, in a galaxy far, far away, I developed and maintained an Access database of Novell servers for the KeyCorp Help Desk. I developed the following code Microsoft Access Basic to take care of the chore of updating the LAN database when a new Novell server came onto the corporate Wide Area Network (WAN). Another example of the way we used to do things! Note the date in the header!

   Sub Updatewanservers ()
    '***********************************************************************
    ' Author: Dale Hawthorne
    ' Date: September 3, 1996
    '***********************************************************************
    ' Purpose: to run the batch file for the NLIST command, read the resulting
    ' text file into a temporary table, and then perform a comparison query
    ' with the LAN table that will identify the new servers for research and
    ' additional input
    '************************************************************************
    Dim strShellCommand As String
    Dim varVerification As Variant
    Dim intFileNum As Integer
    Dim strInputChar As String
    Dim i As Integer
    Dim strNLine As String
    Dim strServer As String * 25
    Dim strOutputChar As String
    Dim strStatusBar As String
    Dim strSQLStatement As String
    Dim strTitleText As String
    Dim strMessageText As String
    Dim dbCurrent As Database
    Dim qryUpdateLANTable As QueryDef
    Dim rstUpdateSet As Recordset
    'Opening initialization of variables
    On Error GoTo UpdateError
    strNLine = Chr$(13) & Chr$(10)
    Set dbCurrent = DBEngine.Workspaces(0).Databases(0)
    'This section checks for the existence of previous files prior to running
    'this routine
    Application.Echo False
    DoCmd Hourglass True
    DoCmd SetWarnings False
    varVerification = Dir$("C:\SERVER.BAT")
    If varVerification <> "" Then
    Kill "C:\SERVER.BAT"
    End If
    varVerification = Dir$("C:\SERVERS.TXT")
    If varVerification <> "" Then
    Kill "C:\SERVERS.TXT"
    End If
    If IsTableQuery("", "tblTempServers") Then
    strSQLStatement = "DROP TABLE [tblTempServers];"
    dbCurrent.Execute (strSQLStatement)
    End If
    'This command toggles the flags on the New field
    strStatusBar = "Now preparing LAN Table for input . . ."
    varVerification = SysCmd(SYSCMD_SETSTATUS, strStatusBar)
    strSQLStatement = "UPDATE DISTINCTROW LAN SET LAN.New = ""No"";"
    dbCurrent.Execute (strSQLStatement)
    'This section creates a text file from the NLIST command
    strShellCommand = "@ECHO OFF" & strNLine & "NLIST server /a/b > c:\servers.txt"
    intFileNum = FreeFile
    Open "C:\SERVER.BAT" For Binary As intFileNum
    For i = 1 To Len(strShellCommand)
    strInputChar = Mid(strShellCommand, i, 1)
    Put intFileNum, , strInputChar
    Next
    Close intFileNum
    varVerification = SysCmd(SYSCMD_CLEARSTATUS, " ")
    'This warns the user of the batch file about to run
    strMessageText = "A batch file will now run to list all active servers."
    strMessageText = strMessageText & strNLine & "The screen will be black "
    strMessageText = strMessageText & "for several minutes while this happens."
    strTitleText = "Warning!"
    MsgBox strMessageText, , strTitleText
    'This runs the batch file
    varVerification = Shell("C:\SERVER.BAT")
    'now this waits until the batch file has ceased execution
    If varVerification >= 32 Then
    Do While GetModuleUsage(varVerification)
    DoEvents
    Loop
    End If
    ' This section opens the text file for input into an Access Table
    varVerification = SysCmd(SYSCMD_CLEARSTATUS, "Now retrieving values into Access .. ")
    varVerification = SysCmd(SYSCMD_REMOVEMETER)
    strSQLStatement = "CREATE TABLE [tblTempServers] ([Server] TEXT);"
    dbCurrent.Execute (strSQLStatement)
    intFileNum = FreeFile
    Open "C:\SERVERS.TXT" For Binary As intFileNum
    Seek intFileNum, 425
    Do Until EOF(intFileNum)
    strInputChar = " "
    Do Until strInputChar = Chr(10)
    Get intFileNum, , strInputChar
    Loop
    Get intFileNum, Seek(intFileNum) + 1, strServer
    strServer = Trim(strServer)
    If InStr(1, strServer, "A total") = 0 Then
    strSQLStatement = "INSERT INTO tblTempServers ([Server])" & strNLine
    strSQLStatement = strSQLStatement & "VALUES (""" & strServer & """);"
    dbCurrent.Execute (strSQLStatement)
    End If
    Loop
    Close intFileNum
    dbCurrent.Execute ("qryUpdateFromWan")
    Kill "C:\SERVER.BAT,C:\SERVERS.TXT"
    strSQLStatement = "DROP TABLE [tblTempServers];"
    dbCurrent.Execute (strSQLStatement)
    Application.Echo True
    DoCmd Hourglass False
    DoCmd SetWarnings True
    Exit Sub
    UpdateError:
    If Err = 3075 Or 375 Then
    Resume Next
    Else
    MsgBox "Error" & Err & ": " & Error$
    Close intFileNum
    Application.Echo True
    DoCmd Hourglass False
    DoCmd SetWarnings True
    End If
    End Sub

Technorati Tags: MS Access 2.0,Novell,NLIST,Access Basic

Blast from the Past: Disconnected ADO Recordset in C++

2009-08-06T14:30:00.001-07:00

I found this code today also. It’s done in Visual C++ 6.0, Active Template Library/COM, and it returns a disconnected ADO recordset for use in an ASP page. It shows the way things used to be done for developers that worked with web pages but didn’t like Visual Basic 6.0.

   STDMETHODIMP CRequestSecurity::GetRequestSecurity(long ReqID, IDispatch ** rsetptr)
    {
    HRESULT hr = S_OK;
    VARIANT var;
    try{
    _CommandPtr spCmd(__uuidof(Command));
    _RecordsetPtr rs(__uuidof(Recordset));
    spConn.CreateInstance(__uuidof(Connection));
    hr = spConn->Open(connstr, "", "", adConnectUnspecified);
    if(FAILED(hr))
    _com_issue_error(hr);
    spCmd->ActiveConnection = spConn;
    spCmd->CommandText = "get_req_security";
    spCmd->CommandType = adCmdStoredProc;
    _ParameterPtr reqidprm = spCmd->CreateParameter(_bstr_t("req_id"), adInteger, adParamInput, vtMissing, _variant_t(ReqID));
    spCmd->Parameters->Append(reqidprm);
    rs->CursorLocation = adUseClient;
    rs->Open(spCmd.GetInterfacePtr(), vtMissing, adOpenForwardOnly, adLockBatchOptimistic, -1);
    if(rs->State == adStateOpen && rs->adoEOF == VARIANT_FALSE)
    {
    VariantInit(&var);
    var.vt = VT_DISPATCH;
    var.pdispVal = NULL;
    rs->PutActiveConnection(var);
    spConn->Close();
    VariantClear(&var);
    hr = rs->QueryInterface(IID_IDispatch, reinterpret_cast<void**>(rsetptr));
    if(FAILED(hr))
    _com_issue_error(hr);
    }
    else
    {
    hr = rs->Close();
    if(FAILED(hr))
    _com_issue_error(hr);
    }
    }
    catch(_com_error &e)
    {
    hr = e.Error();
    Error(e.ErrorMessage(), GUID_NULL, hr);
    }
    catch(...)
    {
    hr = E_FAIL;
    Error(L"An unspecified error occured.", GUID_NULL, hr);
    }
    return hr;
    }

Technorati Tags: C++,ADO,Classic ASP,MS SQL Server Stored Procedures

Blast from the Past: Shutdown Utility

2009-08-06T14:22:00.001-07:00

Today I came across some code which I had done a few years ago in Visual C++ .NET 2002 (pre-CLI). It calls the Windows API to shut down the current workstation, and it can also be used to shut down a remote workstation where the access rights exist. The .NET API does not have this capability right now. This code was part of an automated test system which needed to be able to shut down the remote workstation if there were problems with the automated test proceeding. The remote workstations were Windows 95 PCs on which .NET 1.0 ran fairly easily. If anyone needed this functionality today, this code could probably be updated to C++ CLI standards fairly easily. But, young Jedi, be sure that this power is used for good and not for evil!

Header file – the contents of SystemUtil.h:

   #using <mscorlib.dll>
    #define _WIN32_WINNT 0x0500
    #include <windows.h>
    #include <winuser.h>
    #pragma once
    using namespace System;
    using namespace System::Runtime::InteropServices;
    #pragma warning(disable : 4101)
    namespace SystemUtil
    {
    public __gc class CSystemShutdown
    {
    public:
    bool RemoteShutdown(String * WorkstationName, String * EventLogMessage);
    bool LocalShutdown(void);
    };
    }

SystemUtil.cpp:

   bool SystemUtil::CSystemShutdown::RemoteShutdown(String * WorkstationName, String * EventLogMessage)
    {
    bool rv = false;
    DWORD error_code = ERROR_SUCCESS;
    HANDLE hToken;
    TOKEN_PRIVILEGES tkp;
    String * error_string = S"Windows Error #";
    if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
    {
    error_code = GetLastError();
    throw new Exception(error_string->Concat(error_code.ToString()));
    }
    else
    {
    ::LookupPrivilegeValue((LPCTSTR)Marshal::StringToCoTaskMemAnsi(WorkstationName).ToPointer(), SE_REMOTE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
    tkp.PrivilegeCount = 1 ;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    if((::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0) && (error_code = ::GetLastError()) == ERROR_SUCCESS))
    {
    if(!InitiateSystemShutdownEx((LPTSTR)Marshal::StringToCoTaskMemAnsi(WorkstationName).ToPointer(),
    (LPTSTR)Marshal::StringToCoTaskMemAnsi(EventLogMessage).ToPointer(),
    0,
    TRUE, 
    TRUE, 
    SHTDN_REASON_MAJOR_SOFTWARE)) 
    {
    error_string->Concat(error_code.ToString());
    if(error_code == ERROR_ACCESS_DENIED)
    {
    error_string->Concat(S" Administrative rights are not in effect for remote rebooting of this workstation.");
    }
    throw new Exception(error_string);
    }
    }
    else
    {
    throw new Exception(error_string->Concat(error_code.ToString()));
    }
    }
    return rv;
    }
    bool SystemUtil::CSystemShutdown::LocalShutdown(void)
    {
    bool rv = false;
    HANDLE hToken;
    TOKEN_PRIVILEGES tkp;
    DWORD error_code = ERROR_SUCCESS;
    String * error_string = S"Windows Error #";
    if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
    {
    error_code = GetLastError();
    throw new Exception(error_string->Concat(error_code.ToString()));
    }
    else
    {
    ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
    tkp.PrivilegeCount = 1 ;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
    if((error_code = ::GetLastError()) == ERROR_SUCCESS) 
    {
    if(!ExitWindowsEx(EWX_REBOOT | EWX_FORCEIFHUNG, 0)) 
    {
    error_code = GetLastError();
    error_string->Concat(error_code.ToString());
    if(error_code == ERROR_ACCESS_DENIED)
    {
    error_string->Concat(S" Administrative rights are not in effect for rebooting of this workstation.");
    }
    throw new Exception(error_string);
    }
    }
    else
    {
    throw new Exception(error_string->Concat(error_code.ToString()));
    }
    }
    return rv;
    }

Technorati Tags: C++,C++ .NET,C++ CLI,Windows API

Death Marches and Lost Patrols

2009-07-21T10:38:00.001-07:00

Recently, while moving around some boxes of books, I came across my copy of Ed Yourdon’s Death March. This morning I read it through again, to see if there were any lessons and comparisons I could make with it since the last time that I read it four years ago.

I’ve been on three projects over the years that could have been legitimately called, ‘Death Marches.’ My supervisor called one as such, another turned into one because of false expectations and schedule pressure, and the last one had Death March features although I asked for and received assurances that it was not going to be a Death March. The human cost and constant failure of these projects forever soured me on these kinds of projects.

With the recent adoption of Agile methodologies and even more use of the Agile buzzword for a spiral project lifecycle, more projects seem to be turning into ‘Lost Patrols’ rather than Death Marches. The metaphor of the ‘Lost Patrol’ comes from the Death March book as well. Death Marches usually have a goal and and a defined endpoint, in the delivery of a definite set of required functionality and features. Lost Patrols start out with a definite goal but end up getting lost in the forest.

This loss of the definite endpoint is a known problem with the spiral project lifecycle methodology. It can hit Agile when the project requirements and endpoints are left so undefined that the project team becomes lost. Activity may continue, but productivity does not. One of the perverse things that can happen with an Agile project is that the business owners and stakeholders get addicted to generating requirements. It becomes more interesting to them to keep on putting together list of requirements than to see a finished product.

As usual, the solution probably is to stop the project, get some bearings, and restart when project requirements and endpoints are more stable. This may require getting the business stakeholders to agree on what should be delivered when and when the product will go out of new development into maintenance and enhancement mode.

Technorati Tags: Death March,Projects,Project Management,Agile Development

Part II: How to Make a Consulting Gig Mutually Effective and Rewarding

2009-06-25T14:57:00.001-07:00

Most of what I put down in my previous post, Part I: How to Make a Consulting Gig Mutually Effective and Rewarding, had to do with defining the assignment and preparing for the new consultant. Here are some more suggestions that I have to make.

Make Sure That All Prospective Interviewers Are Prepared.

Interviewers need to have a current copy of the consultant’s resume. When I’m interviewed about a prospective assignment, I usually have additional copies with my business card and contact information. It’s best to give any prospective interviewers a copy of the resume far enough in advance to go over and assess the fit of the consultant to the assignment.
Interviewers need to have a current job description for the assignment. The assignment is usually important enough and costly enough to write down a list of what is relevant to the assignment.
Interviewers need to know what skills and experience are relevant to the assignment. This simply comes down to what parts of the job description are the most important. Sometimes job descriptions contain ‘nice to have’ skills and experience as requirements, and requirements as ‘nice to have’.
Interviewers need to pursue the technical screening as determining whether the consultant has the required skills and experience but also the capabilities to do the job. This technical screening is not technical oneupmanship, or looking for a weak area on the resume, but assessing the fit to the assignment. They need to look at the intangibles as well, especially where the team will be working with new technology. They need to assess whether the consultant will work to find answers, solve problems and do what it takes to make the project succeed.
Interviewers need to allow for time for the consultant to ask questions and find out about the job to see whether it’s a fit from his or her perspective.

Make Sure That the Team Is Prepared to Integrate with the New Consultant.

Clearly communicate that you, as a manager, expect that they will give the new consultant or contractor full professional cooperation. Sometimes experienced and highly qualified consultants may be threatening to less experienced members of the department or organization. Be on the lookout for defensive denigration (disparagement of the consultant’s credentials, capabilities and experience – which may count in some cases as slander or libel according to the legal definitions), misdirection (deliberately providing false or misleading information and direction), and stonewalling (refusal to provide necessary information and assistance to get the job done) in these cases. Understand that this kind of behavior can sink a project and undermines your ability as a manager to bring in the people that you need to get the job done.
Make sure that you and others understand that ‘new’ in the case of a consultant does not mean entry level. Experienced consultants often need little more than current standards and guidelines, project requirements and other project documents, a development PC, and access to workstations, servers, etc. They do not need to have team members try to guide them through the basics of how to code, etc. For myself, I try to make sure that beyond the particulars of the corporate environment and project specifications, that I know all that’s needed to fulfill my responsibilities and more.
Make time for communication with the consultant. As a consultant, I aim to be as ‘low maintenance’ as possible – but that does not mean ‘no maintenance’! Rather, I still need to touch base, and communicate progress, ask questions, make sure that I’m on the right track, etc. My aim in this is simply to make sure that I’m doing the right things and providing what is expected, and, preferably, more than is expected. It’s usually a good idea to have a weekly or biweekly one on one meeting with a consultant. Management by walking around and asking how things are going works well also.

Make Sure That the New Consultant Receives Realistic and Workable Expectations and Assessment.

Realistic and workable expectations and assessment means sufficient time to complete the assigned task. Experienced consultants can often do much in a short time, but each one of us does require time to produce whatever is being specified. For example, no matter how many years a person codes, no one writes perfect code the first time. What is checked into a source code repository first may not be the final submission but rather simply be to preserve initial attempts against possible loss. Moreover, the code that is produced still needs to be evaluated, unit tested and possibly refactored. The end result is what counts the most. For myself, I aim to produce well designed, documented, understandable and production ready code. I can usually produce this faster than less experienced programmers. But what comes out of the end of my fingers the first time won’t be perfect, although I aim for the end result to fulfill the requirements and functional as possible.
Realistic and workable expectations means receiving tasks in accord with the skills and experience of the consultant. For instance, I can do a number of support tasks such as installations and defining security roles and users, but I’ve never worked as a network administrator. On the other hand, I’ve worked with some very good manual and functional testers, but I do not consider myself competent to do manual system and functional testing. In fact, my total time for manual system testing over 15+ years of IT experience comes down to maybe 8 hours total. (For more on this, see Joel on Software: Top Five (Wrong) Reasons You Don't Have Testers.) It’s usually better to try to find someone who is experienced and trained in these tasks rather than try to throw a consultant experienced in other areas at these tasks.
Realistic and workable expectations and assessment means a method for the consultant to report on his own work. Work out some kind of regular reporting mechanism. In previous assignments I put out a weekly report of my activities where the manager expected one. I’m thinking now that this is advisable in every case, to make sure that the manager gets an accurate understanding of the productivity of the consultant.

Technorati Tags: Consulting,Contracting,IT Management,team development

Building the Sharepoint Development Virtual PC

2009-06-25T13:46:00.001-07:00

Over the past several days I’ve been building a virtual PC on my personal laptop for Sharepoint development. I had to do this because I forgot the passwords to the virtual PC which I used last summer to work through a BizTalk evaluation and some SQL Server Reporting Services exercises. I didn’t have the foresight to put together a virtual password reset disk. But the time in installation and configuration is well worth it. It brings a developer out of the code and back into working with the kinds of personal support tasks that makes one low maintenance.

Here are the steps I took.

Started up Virtual PC 2007 and defined a new virtual PC with the settings for virtual RAM and virtual hard disk size. I wish now that I had increased the size of the original virtual hard disk, but I was able later to add on another virtual hard disk to the PC. I also made sure that I defined a virtual floppy disk for a password reset disk.
Started up the virtual PC which I had just defined. I had the DVD for Windows Server 2008 in the DVD drive while I did this.
Went through the installation of Windows Server 2008 standard edition.
Defined the role as a Web server to install IIS (Internet Information Server).
Installed an antivirus client. I’m also working through the evaluation of the Norton product for Windows Server 2008, and I found it pretty easy to install.
Connected the Windows Server 2008 virtual PC to the internet, and turned on Windows update to pick up the latest updates.
While the Internet connection was active, turned on Norton LiveUpdate to update the virus and spyware definitions.
After the updates to the operating system and antivirus were complete, installed SQL Server 2008 standard edition. I also work with Integration Services (SSIS), Analysis Services (SSAS), and Reporting Services (SSRS), so I added those to the installation also. I checked BIDS but probably did not have to.
Installed Sharepoint Services 3.0 with SP1.
Installed the Sharepoint Services SDK. I don’t know if I needed to do this, but I did it anyway.
Installed Visual Studio 2008. For an installation aimed at primarily Sharepoint development, I tried to leave out as much as possible, such as anything for mobile devices.
Installed the MSDN documentation. I’ve already got the documentation on the laptop itself, but it can be a pain to switch away from the virtual PC to look up something on MSDN.
Installed the Visual Studio extensions for Sharepoint.

There are still four additional things that I want to do. There’s separate documentation for the Visual Studio extensions for Sharepoint, and I want to have that on the virtual PC, so there will still be another installation for that. I want to see how Norton’s product for Sharepoint security installs, so there’s still another installation to go through. And I want to explore using Silverlight with Sharepoint, so there’s still another installation of Silverlight and the Silverlight SDK. And finally, I plan to back all this up, so I don’t have to go through all this installation again if the virtual PC is corrupted.

So, unless there’s someone in your organization who can make and maintain a master virtual PC image for Sharepoint development, plan to do a lot of installation if you want to do Sharepoint development. It takes a long time for these installations to complete, so find something to do with your time while you watch over the installations.

Technorati Tags: Sharepoint,Virtual PC,Windows Server 2008,SQL Server 2008

Emotional Intelligence and Resonant Leadership in IT

2009-06-18T14:00:00.001-07:00

Recently I went through Primal Leadership: Learning to Lead with Emotional Intelligence by Daniel Goleman, Richard Boyatzis and Annie McKee, and right now I’m working through Resonant Leadership by Richard Boyatzis and Annie McKee. In the fall of 1995 I went through the Managerial Assessment and Development course at the Weatherhead School of Management at Case Western Reserve University, and there is some material from that course mirrored in Primal Leadership.

In Primal Leadership, the authors distinguish between resonant leadership and dissonant leadership, and explain the following leadership styles:

Visionary (Resonant): Guiding people by and toward shared dreams.
Coaching (Resonant): Connects a person to the organization by linking their strengths, weaknesses and personal goals to the long term goals of the organization.
Affiliative (Resonant): Connects people through emotional ties and shared concern for each other.
Democratic (Resonant): Connecting people to the organization by listening to them and involving them in the process of getting ideas, making decisions and setting direction.
Pacesetting (Dissonant): The leader holds and exemplifies high performance standards, and demands the same from others.
Commanding (Dissonant): The leader commands, often demanding immediate compliance without any explanations.

As I went through this book, my sense was that within IT, the last, the commanding style, was by far the most prevalent, although it’s marked as the least effective. In fact, the commanding style tends to management by threat and intimidation. This whole style tends to be extremely stressful and counterproductive in the long run. The other dissonant style, pacesetting, tends to micromanagement, and seems to be characteristic of managers and leaders who are technically adept, or imagine themselves to be technically adept. This style also tends to be stressful, and puts people into survival mode. Dissonant leadership tends to discourage, burn out, and drive away people and send them home with chronic stress. I believe that much turnover in IT comes down to dissonant leadership, and the overuse of the commanding style.

Where do people learn the dissonant style? There’s a reason on page 155: “

" . . . people pick up their leadership habits rather haphazardly over the course of life through repeating what they see their models do, or through repeating their own attempts at leading."

This is probably why poor leaders often look like a common definition of insanity ("keep on doing the same thing while expecting different results"). People come to IT management and leadership often without any effective personal coaching in leadership and management – so they act out what they have experienced, seen or imagined to be effective leadership –and they fall into dissonant leadership. The dissonant styles also look a lot like the classic military model of leadership, although recently the U.S. military has been working toward incorporating much more of the resonant styles into their leadership model.

Here are some ideas for incorporating the more resonant styles in IT:

Visionary (Resonant): Guiding people by and toward shared dreams.
Relate whatever projects and tasks in the organization are being done to the overall purpose of the organization. Let those in the organization know that they are contributing to a positive vision. Don’t make this something done once in a long while, but fairly often. Do this without cliches or platitudes, but exemplify that you believe in the vision also.
Coaching (Resonant): Connects a person to the organization by linking their strengths, weaknesses and personal goals to the long term goals of the organization.
Get to know the people in the group as individuals in an in depth manner. Work with them to make best use of their strengths and to minimize their working in areas of their weaknesses. Learn where they want to go in their career and life, and provide as much support as you can.

Do more management by walking around. Find out what people are doing, what is energizing them and what they see is causing them headaches and what their obstacles are. Help them to find and work out solutions. Help them to get training when it is possible; seek to make this a part of the budget.
Affiliative (Resonant): Connects people through emotional ties and shared concern for each other.
Give people occasions to connect with each other. Show concern when people are going through difficult personal times.
Democratic (Resonant): Connecting people to the organization by listening to them and involving them in the process of getting ideas, making decisions and setting direction.
Allow people to become part of the decision making process as much as possible. Discussing a decision with them, the pros and cons, as if it were their decision to make, may bring buy-in and commitment, even when they don't have the final say.

Here are some ideas on when to use the dissonant styles:

Pacesetting (Dissonant): The leader holds and exemplifies high performance standards, and demands the same from others.
Use this style when the leader does have technical expertise and when working with an inexperienced team. Otherwise, let the experienced and knowledgeable work without micromanagement.
Commanding (Dissonant): The leader commands, often demanding immediate compliance without any explanations.
Use this style sparingly. Give clear directions, but most authoritatively during a crisis and an emergency. Do not make ‘fake’ emergencies to make people jump to get something done.

In regard to any use of the commanding style, leaders would do well to remember the observation of Baron von Steuben when he was drilling American soldiers during the American Revolution. He said, “With European soldiers, I tell them what to do, and they do it. With American soldiers, I tell them what to do, and then I have to tell them why.”

Technorati Tags: Emotional Intelligence,IT management,team development,team leadership

Architectural Transitions, Transferences and Learning Curves

2009-06-18T12:45:00.001-07:00

Over the years I worked on a number of projects for a number of organizations where the Microsoft .NET framework was the chosen architectural platform, and the planned application would be primarily ASP.NET. In some of these the organizations, and the managers, developers, analysts and testers within them, were making a transition from a previous architectural platform to ASP.NET. There was a steep learning curve involved, and some individuals within those organizations acknowledged this. Others, however, were unaware of the steepness of this curve, and what elements of their previous experience did and what elements of their previous experience did not transfer to the new architecture.

Here is the list of the transitions which I’ve seen and with which I’ve worked in the organizations.

Transition 1: Mainframe to ASP.NET

Transition from a static character based user interface to a much more fluid user interface based in HTML, CSS and Javascript.
Transition from single tier and single locus of execution, processing and data persistence to multiple tiers and multiple loci of execution, processing and data persistence.
Transition from single development language to multiple development languages.
Transition from procedural methods of development to object oriented development.
Transition from little emphasis on usability and accessibility to a much greater emphasis on usability and accessibility.
Transition from ID based security to security based in IDs, roles, secure coding practices and secure deployment architecture and configuration practices.
Transition from waterfall project management methodology to more iterative project management methodology.

Transition 2: Visual Basic 6 Client Server to ASP.NET

Transition from a pixel based Windows user interface drawn in an IDE to a user interface rendered in HTML, CSS and Javascript that may need to display in multiple browsers in multiple operating systems.
Transition from two tiers and a single locus of execution and processing and two loci of data persistence to multiple tiers and multiple loci of execution, processing and data persistence.
Transition from access to local file system to almost exclusive use of back end databases for data persistence.
Transition from less object oriented development practices permitted by the language and environment to exclusively object oriented development practices enforced by the language and environment.

Transition 3: Java to ASP.NET

Transition from open source utilities and development tools more to Microsoft developed utilities and development tools.
Transition from a platform that they may have been taught to love to one from a company that they have been taught to despise (this is more of a cultural transition).

These transitions show why the adoption of new technology and transition in the development environment often leaves developers gasping and grasping. It involves more than learning a new language or a new tool. For many, it’s a need to learn an a whole new platform, architecture, and complexity. It’s no wonder that some find themselves overwhelmed when the decision is made for them that they will now be ASP.NET developers.

Technorati Tags: ASP.NET,team development,architectural transition

AntiPattern: Hackagile Development

2009-06-12T13:00:00.001-07:00

‘Speaking truth to power’ is a cliche that always seemed to me to smack of someone holding a conversation with a telephone pole. The comic strip Dilbert often does this in a very effective way:

I would suggest that this kind of coding should be termed ‘Hackagile,’ and that it be classified as a development antipattern. What happens after the requirements are delivered in whatever form they take – CRC cards, user stories, page mockups, etc. – is that the development practice then becomes the antipattern that I call the ‘Path to Disaster.’ This antipattern is, as mentioned by Steve McConnell in Code Complete, ‘Rush to Code; Code Like Hell; Code and Fix.’ Design, documentation, and often unit testing are thrown out so that more and more code can be churned out. The management team and lead developers may in fact call this kind of development process ‘Agile.’ But as far as the coding process itself, it’s more like what we used to call, ‘hacking’ – as in throwing together an application without any kind of design or development specifications. Most of the organizations that I know that do this don’t foster a development culture anything like the Agile Manifesto specifies.

‘Hackagile’ can happen when an organization which has done primarily maintenance and enhancement programming goes into new application development. It seems attractive, since most maintenance and enhancement changes are very short range in scope and the changes to actual are very small in comparison to developing a new application from scratch. In addition, most maintenance and enhancement programmers are not used to any kind of software design but may be much more used to jumping into code and rewriting, fixing and enhancing.

Here is a link to a site which gives guidance for Agile with design:

Agile Modeling (AM) Home Page: Effective Practices for Modeling and Documentation

The Agile Alliance also has many articles that deal with Agile Development. They provide a starting point for ‘truth in packaging’ with software development methodologies, so that an obsolete dysfunctional or retrograde process is not called ‘Agile’ because ‘Agile’ is new, hip, and trendy and not well defined to some.

Agile Alliance Home

The Agile Manifesto also has a number of values concerning people and the process which are regularly violated in a ‘Hackagile’ environment. It seems to me that these kinds of development organizations would display much, much more 'Emotional Intelligence’ than almost any development organization I’ve ever worked with ever showed. And I’ll have more to say on that in posts yet to come.

Manifesto for Agile Software Development

Technorati Tags: Emotional Intelligence,IT Management,Agile Development,Software development,Software Design

Why Omicompetent Developer Heroes Are Like Unicorns, Dodo Birds,Passenger Pigeons And Saber Toothed Tigers

2009-06-12T08:59:00.001-07:00

Omnicompetent developer heroes are like unicorns because they don’t exist. They are both mythical animals. Or maybe they’re more like dodo birds or passenger pigeons: they existed once, but overwhelming predation slaughtered them and made them extinct. Or, in my opinion, they are more like saber toothed tigers. They existed once, but the specific environment that nourished them disappeared, and they became extinct.

Omnicompetent developer heroes disappeared because the environment that nourished them – one platform (the IBM mainframe), one or two languages (COBOL, Fortran) and one operating system (MVS) – is no longer the sole environment. The networked Wintel environment has in itself gone far beyond what could have nourished them if they adapted in complexity.

Kathleen Dollard, one of my favorite speakers and writers on all things .NET, compiled a list of what’s changed since development methodologies seemed to have become pretty stable. Here is her list and the associated posts:

The complexity of the environment points to several things.

First, upper level executives and managers who sponsor development projects and attempt to guide them from outside based upon their own experience with development projects prior to the development of multitier applications, Internet and Intranet applications, and interconnected SOA infrastructure will not understand the complexity of the current development environment. They may look for heroes like they remember, but they will not find them.

Moreover, putting more time and effort into a project may not be enough to fill the knowledge gaps. The list goes on and on, and there are not enough hours in the day or training dollars for any organization to produce omincompetent developers in everything. Project teams must therefore be composed of a mix of skillsets for any enterprise level application. This means that the person that is needed for the project may not be the best available coder in the development language for the project. The project may need one or two of these best available coders, but it may need others with strengths in other areas – such as someone who has a knowledge of Visual Basic or C#, but is much stronger in CSS and web design.

Also, no one person can know all that is necessary, and this requires development teams to be truly teams. No one brings all the technical competence to any significant project necessary to the completion of that project. This means that developers, though they have been historically an individualistic lot, must learn to be team players to be effective in the future.

Next, there’s a lot of items on the list which are not related to development languages. It’s now more necessary to learn languages (C#, Visual Basic, Java, COBOL) + operating environments(Windows, Linux, Unix, MVS) + relational database systems (SQL Server, DB2, Oracle) + user presentation (web client, smart client, character based) + project methodologies(agile) + design methodologies (Object Oriented, Structured, AOP, design patterns).

In addition, a development organization which seeks to remain competent must be a learning organization. There must be a continued striving to learn new things and develop new competencies. Instructor led training is expensive and time consuming, and developers that have depended on it must learn to become much more self directed in their learning. Developers that seek to learn and master new things are the backbone of a learning organization, and managers must seek to hire them, retain them, and keep them motivated and productive.

Finally, this means that the developer who takes the initiative to keep on learning is the one who will survive and thrive in the new environment. It means that those who rest on classes taken long ago or degrees earned several years ago may in fact be behind the curve in what is needed to remain competent. It means that being able to search and find information crucial to performing a development task, and being able to learn something quickly is now as important as having done a task; capability and learning speed is now as important as experience and current knowledge.

The hero culture is dead. The environment which nourished it died and killed it.

Technorati Tags: team development,hero culture,IT Management,software development

Add Some Personalization, Please

2009-06-12T07:35:00.001-07:00

As I’ve been thinking over some of the custom controls and some projects that I’ve worked with over the past few years, I’m amazed to realize that there is a significant feature that could have been implemented several times, for little additional cost, that would have greatly improved usability of the sites. That feature is personalization.

In ASP.NET 2.0, the personalization and membership features are out of the box. There have been some role and membership provider implementations for security, but most of the applications were not designed with personalization in mind. I think that there were four basic reasons.

Business analysts were designing the web pages. They did not know about what personalization features were available for the ASP.NET 2.0 web application platform.
Developers were unaware of the personalization features, or were tied into a rigid web page design of their own making that did not allow personalization.
The corporation had its own standard web appearance, and did not consider or want to permit users to change it at any point during their usage of the application.
The project implementation timeline was so aggressive that implementing the basic functionality could only be done, and these possibilities for greater usability would have been only a disdained ‘nice to have’.

I would suggest that the way to incorporate personalization features such as themes, skins and webparts would be to develop two user personas in the design phase.

The naive or first time user of the application. This persona would need the definite instructions on how to get things done in the application and definite paths to follow.
The frequent or power user of the application. This persona might want to be able to customize the appearance at some points or to be able to put together a page of his or her most frequent starting points to other areas of the application.

Throughout the application lifecycle, the design team should consider personalization features at the initial rollout and subsequent enhancements of the application.

During the initial rollout, such features as searching for a certain business entity could be implemented as custom controls and ASP.NET Webparts. A frequent or power user would use search features fairly frequently, and the frequent user would probably find the application much more usable than having to proceed through several other points to get to the search page that he or she wanted in the first place.
During subsequent enhancements of the application, both application developers and testers become power users and frequent users of the application. Their suggestions, as well as those of the actual frequent and power users of the application, need to be sought for places where they could make the application customized to their needs.

Admittedly, adding personalization might be a hard sell in some situations. If there is a corporate Sharepoint implementation, though, there might be enough corporate awareness to see the possibilities. Someone on the project team who ‘sees the light’ on personalization could point out the relevant features on MSN as well. The goal of serving the needs of the users with personalization, and building upon functionality already available in the ASP.NET 2.0 platform should help to make this more of a part of future ASP.NET development projects than previously.

Technorati Tags: ASP.NET,Webparts,personalization,themes,skins

An ASP.NET Double ListBox Control: Implementation

2009-06-08T06:49:00.001-07:00

In previous posts, I demonstrated how to create a double listbox control in ASP.NET. Here are the subjects that were covered:

Here's how the implementation looks inside an ASPX page:

   <%@ Page Language="C#" AutoEventWireup="true"  CodeFile="Default.aspx.cs" Inherits="_Default" %>
 
<%@ Register Assembly="DaleWare.Web.UI.Controls" Namespace="DaleWare.Web.UI.Controls.Validators"
    TagPrefix="DaleWare" %>
<%@ Register Assembly="DaleWare.Web.UI.Controls" Namespace="DaleWare.Web.UI.Controls" TagPrefix="DaleWare" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
    <style type="text/css">
        body {font-family:Verdana, Arial; font-size: small;}
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="ScriptManager1" runat="server">
    </asp:ScriptManager>
    <div>
   
          <asp:UpdatePanel ID="up1" runat="server"><ContentTemplate>
           <asp:Label ID="lblTitle" runat="server">List Picker Control Demo: Greatest TV Shows of All Time: Choose Your Favorites</asp:Label>
           <DaleWare:ListPickerControl ID="LP1" runat="server" 
            Width="100%" 
            ListBoxStyle-Width="100%" 
            NumberOfListBoxRows="15"
            AvailableChoicesLabelText="Available Choices"
            SelectedChoicesLabelText="Selected Choices"
            LabelStyle-Font-Bold="true"
            LabelStyle-ForeColor="Blue"
            Sort="true">
           <AvailableChoices>
           <asp:ListItem>I Love Lucy</asp:ListItem>
           <asp:ListItem>The Dick Van Dyke Show</asp:ListItem>
           <asp:ListItem>M*A*S*H</asp:ListItem>
           <asp:ListItem>All in the Family</asp:ListItem>
           <asp:ListItem>Star Trek</asp:ListItem>
           <asp:ListItem>Gunsmoke</asp:ListItem>
           <asp:ListItem>Land of the Lost</asp:ListItem>
           <asp:ListItem>Make Room for Daddy</asp:ListItem>
           <asp:ListItem>The People's Choice</asp:ListItem>
           <asp:ListItem>Space Angel</asp:ListItem>
           <asp:ListItem>Time Traxx</asp:ListItem>
           <asp:ListItem>Stargate SG1</asp:ListItem>
           <asp:ListItem>Rowan and Martin's Laughin</asp:ListItem>
           <asp:ListItem>Law and Order</asp:ListItem>
           <asp:ListItem>Perry Mason</asp:ListItem>
           <asp:ListItem>The Tonight Show</asp:ListItem>
           </AvailableChoices>
           </DaleWare:ListPickerControl>
           </ContentTemplate></asp:UpdatePanel>           
           <asp:Button ID="Button1" runat="server" Text="Submit" />
     </div>
    </form>
</body>
</html>

Technorati Tags: Ajax.NET,ASP.NET,Custom Controls,Javascript,UpdatePanel

An ASP.NET Double ListBox Custom Control: Step 4

2009-06-08T06:36:00.001-07:00

In my previous posts on the subject of creating a double listbox custom control, I demonstrated:

In this post, a clientside Javascript function is added so that the control can function without postbacks to the server. The user of the control has a property already in the control file which gives the choice as to whether to use the client side Javascript or not.

   function moveListBoxItems(firstListBoxId, secondListBoxId, selectedOnly) {
    var firstListBox = document.getElementById(firstListBoxId);
    var secondListBox = document.getElementById(secondListBoxId);
    
    if ((firstListBox != null) && (secondListBox != null)) {
        for (var i = firstListBox.options.length -1; i >= 0; i--) {
            if (selectedOnly) {
                if (firstListBox.options[i].selected) {
                    secondListBox.appendChild(firstListBox.options[i]);
                }
            }
            else {
                secondListBox.appendChild(firstListBox.options[i]);
                
            }
        }
    }
    return false;
}

Copy and paste the following code into the AssemblyInfo.cs file. This code includes the above file as a web resource inside the custom control assembly.


  [assembly: System.Web.UI.TagPrefix("DaleWare.Web.UI.Controls", "DaleWare")]
[assembly: System.Web.UI.TagPrefix("DaleWare.Web.UI.Controls.Validators", "DaleWare")]
[assembly: System.Web.UI.WebResource("DaleWare.Web.UI.Controls.Validators.WebUIValidationExtended.js", "application/x-javascript")]
[assembly: System.Web.UI.WebResource("DaleWare.Web.UI.Controls.ListPickerClientSide.js", "application/x-javascript")]

Technorati Tags: ASP.NET,Custom Controls,Javascript,UpdatePanel

An ASP.NET Double ListBox Custom Control: Step 3

2009-06-08T06:13:00.001-07:00

In my previous two posts, I showed how to create a basic double listbox control and provide additional extension methods for the listbox controls. In the next step, the project gets a designer to provide more visual feedback to incorporating the control into an ASPX page inside Visual Studio. Here is the code for a designer that provides the visual appearance in Visual Studio.

   using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.ComponentModel;
using System.Web.UI.Design;
using System.Web.UI.WebControls;
 
namespace DaleWare.Web.UI.Controls
{
    /// <summary>
    /// Summary description for ListPickerControlDesigner
    /// </summary>
    public class ListPickerControlDesigner : ControlDesigner
    {
 
        public override string GetDesignTimeHtml()
        {
 
            StringBuilder sb = new StringBuilder();
            ListPickerControl lpc = Component as ListPickerControl;
            sb.Append("<table");
            if(lpc.Width !=null)
            {
                sb.Append(" width=\"");
                sb.Append(ControlDesignerUtility.UnitString(lpc.Width));
                sb.Append("\"");
            }
            sb.Append("><tr><td style=\"width:40%;text-align:left\">\r\n");
            if (string.IsNullOrEmpty(lpc.AvailableChoicesLabelText) == false)
            {
                sb.Append(lpc.AvailableChoicesLabelText);
                sb.Append("<br />");
            }
            sb.Append("<select style=\"width:");
            sb.Append(lpc.ListBoxStyle.Width.ToString());
            if (lpc.NumberOfListBoxRows > 0)
            {
                sb.AppendFormat("\" size=\"{0}", lpc.NumberOfListBoxRows);
            }
 
            sb.Append("\">\r\n");
            if (lpc.AvailableChoices == null || lpc.AvailableChoices.Count == 0)
            {
 
                sb.Append("<li>&nbsp;</li>");
 
            }
 
            else
            {
                                
                foreach (ListItem item in lpc.AvailableChoices)
                {
                    sb.Append("<li");
                    if (item.Value != null)
                    {
                        sb.Append(" value=\"");
                        sb.Append(item.Value);
                        sb.Append("\"");
                    }
                    sb.Append(">");
                    sb.Append(item.Text);
                    sb.Append("</li>\r\n");
                }
 
            }
            sb.Append("</select>\r\n</td>");
            sb.Append("<td style=\"width:20%;text-align:center\">");
            sb.Append("<input type=\"button\" value=\">>\" style=\"width:3em\"><br /><input type=\"button\" value=\">&nbsp;\" style=\"width:3em\"><br /><input type=\"button\" value=\"<&nbsp;\" style=\"width:3em\"><br /><input type=\"button\" value=\"<<\" style=\"width:3em\"><br />");
            sb.Append("</td>\r\n<td style=\"width:40%;text-align:left\">\r\n");
            if (string.IsNullOrEmpty(lpc.SelectedChoicesLabelText) == false)
            {
                sb.Append(lpc.SelectedChoicesLabelText);
                sb.Append("<br />");
            }
            sb.Append("<select style=\"width:");
            sb.Append(lpc.ListBoxStyle.Width.ToString().Trim());
            
            if (lpc.NumberOfListBoxRows > 0)
            {
                sb.AppendFormat("\" size=\"{0}", lpc.NumberOfListBoxRows);
            }
 
            sb.Append("\">\r\n");
            if (lpc.SelectedItems == null || lpc.SelectedItems.Count == 0)
            {
                sb.Append("<li>&nbsp;</li>\r\n");
            }
 
            else
            {
 
                foreach (ListItem item in lpc.SelectedItems)
                {
                    sb.Append("<li");
                    if (item.Value != null)
                    {
                        sb.Append(" value=\"");
                        sb.Append(item.Value);
                        sb.Append("\"");
                    }
                    sb.Append(">");
                    sb.Append(item.Text);
                    sb.Append("</li>\r\n");
                }              
            }
            sb.Append("</select>\r\n</td></tr></table>");
           System.IO.File.WriteAllText("C:\\Users\\Dale\\Documents\\Output.txt",sb.ToString());
            return sb.ToString();
        }
    }
}

Technorati Tags: Custom Controls,ASP.NET

An ASP.NET Double ListBox Custom Control: Step 2

2009-06-08T06:03:00.001-07:00

In my previous post, I gave the basic code for a double list box control class. It’s dependent, however, on these extension methods. Simply add a new C# class to the project, name it ListControlUtility.cs, and copy and paste the following code into it. But beware: there are two more steps to this process of producing a working control!

   using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI.WebControls;
 
namespace DaleWare.Web.UI.Controls
{
    /// <summary>
    /// This is a utility class of extension methods which can be applied to 
    /// a list box. It can be used outside the controls assembly for convenience
    /// simply by including the namespace.
    /// </summary>
    public static class ListControlUtility
    {
        /// <summary>
        /// This method returns a list of selected listitems from the listbox.
        /// </summary>
        /// <param name="lc">The list control.</param>
        /// <returns></returns>
        public static List<ListItem> SelectedItems(this ListControl lc)
        {
            List<ListItem> selectedItems =
                    lc.Items.Cast<ListItem>().Where(item => item.Selected == true).ToList();
            return selectedItems;
        }
 
        #region Sort Implementation
        /// <summary>
        /// This method sorts the items in a listbox.
        /// </summary>
        /// <param name="items">The list control.</param>
        /// <param name="Descending">Whether to sort the list box descending. </param>
        public static void SortListItems(this ListItemCollection items, bool Descending)
        {
            System.Collections.Generic.List<ListItem> list = new System.Collections.Generic.List<ListItem>();
            foreach (ListItem i in items)
            {
                list.Add(i);
            }
 
            if (Descending)
            {
                IEnumerable<ListItem> itemEnum =
                    from item in list
                    orderby item.Text descending
                    select item;
                items.Clear();
                items.AddRange(itemEnum.ToArray());
                // anonymous delegate list.Sort(delegate(ListItem x, ListItem y) { return y.Text.CompareTo(x.Text); });
            }
            else
            {
                IEnumerable<ListItem> itemEnum =
                    from item in list
                    orderby item.Text ascending
                    select item;
                items.Clear();
                items.AddRange(itemEnum.ToArray());
 
                //list.Sort(delegate(ListItem x, ListItem y) { return x.Text.CompareTo(y.Text); });
            }
        }
        #endregion
    }
}

Technorati Tags: Custom Controls,ASP.NET

An ASP.NET Double ListBox Custom Control: Step 1

2009-06-05T14:18:00.001-07:00

On a number of projects I’ve had to implement a double list box control for different clients. It’s not a task I particularly enjoy, since I don’t think that the double list box is particularly user friendly. For the most part, I think that in the majority of cases a CheckBoxList works better and is far more easy to implement than a double list box. But, for those of us who have clients that insist on a double list box, here is the way to get one completed.

1. Create a class library project like in my previous project.

http://thedalehawthorneeffect.blogspot.com/2009/05/another-way-to-handle-client-script.html

2. Add a reference to System.Design.

3. Add a class file named SortDirectionEnum.cs.

4. Copy and paste the following code into SortDirectionEnum.cs:

     
      
      namespace DaleWare.Web.UI.Controls
{/// <summary>
    /// Summary description for SortDirectionEnum
    /// </summary>
    public enum SortDirectionEnum
    {
        Ascending,
        Descending
    }
}

5. Add a class file named ListPickerControl.cs.

6. Copy and paste the code below into ListPickerControl.cs.


    


    


    using System;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Linq;
using System.ComponentModel.Design;
 
namespace DaleWare.Web.UI.Controls
{
    /// <summary>
    /// Summary description for ListPickerControl
    /// </summary>
    [
       AspNetHostingPermission(SecurityAction.Demand,
           Level = AspNetHostingPermissionLevel.Minimal),
       AspNetHostingPermission(SecurityAction.InheritanceDemand,
           Level = AspNetHostingPermissionLevel.Minimal),
       ToolboxData("<{0}:ListPicker runat=\"server\"> </{0}:ListPicker>"),
     SupportsEventValidation(),
    Designer(typeof(ListPickerControlDesigner), typeof(IDesigner))]
    public class ListPickerControl : CompositeControl
    {
        private ListBox _availableChoicesListBox = null;
        private ListBox _selectedChoicesListBox = null;
        private ListItemCollection _availableChoices = null;
        private ListItemCollection _selectedChoices = null;
 
        private Style _buttonStyle = null;
        private Style _listBoxStyle = null;
        
        private bool _sort;
 
        private Button btnMoveAllLeftToRight = null;
        private Button btnMoveSelectedLeftToRight = null;
        private Button btnMoveSelectedRightToLeft = null;
        private Button btnMoveAllRightToLeft = null;
 
        private int _numberOfRows = 10;
 
        private Label _availableChoicesLabel = null;
        private Label _selectedChoicesLabel = null;
 
        private Style _labelStyle = null;
 
        [Category("Behavior"),
       DefaultValue("This property gets or sets whether to use client script to move the items between the list boxes."),
       Description("This property gets or sets whether to use client script to move the items between the list boxes."),
       Localizable(false)]
        public bool UseClientScript
        {
            get;
            set;
        }
 
        [Category("Behavior"),
        DefaultValue("This button moves all values from the left list box to the right list box."),
        Description("Tool tip for the button that moves all values from the left list box to the right list box."),
        Localizable(true)]
        public string MoveAllLeftToRightButtonToolTip
        {
            get;set;
        }
        
        [Category("Behavior"),
        DefaultValue("This button moves all values from the right list box to the left list box."),
        Description("Tool tip for the button that moves all values from the right list box to the left list box."),
        Localizable(true)]
        public string MoveAllRightToLeftButtonToolTip
        {
            get;
            set;
        }
 
        [Category("Behavior"),
        DefaultValue("This button moves all selected values from the left list box to the right list box."),
        Description("Tool tip for the button that moves all selected values from the left list box to the right list box."),
        Localizable(true)]
        public string MoveSelectedLeftToRightButtonToolTip
        {
            get; set;
        }
        
        [Category("Behavior"),
        DefaultValue("This button moves all selected values from the right list box to the left list box."),
        Description("Tool tip for the button that moves all selected values from the right list box to the left list box."),
        Localizable(true)]
        public string MoveSelectedRightToLeftButtonToolTip
        {
            get;set;
        }
        
        [Category("Behavior"),
        DefaultValue("This button moves all values from the right list box to the left list box."),
        Description("Tool tip for the button that moves all values from the right list box to the left list box."),
        Localizable(true)]
        public string MoveAllRightToLeft
        {
            get;set;
        }
 
        [Bindable(true),
        Category("Behavior"),
        DefaultValue(true),
        Description("Whether to sort the listboxes.")]
        public bool Sort
        {
            get { return _sort; }
            set { _sort = value; }
        }
        [Bindable(true),
        Category("Behavior"),
        DefaultValue(SortDirection.Ascending),
        Description("Sort direction for sorting the listboxes.")]
        public SortDirection SortDirection
        { get; set; }
 
        [Bindable(true),
        Category("Layout"),
        DefaultValue(10),
        Description("The default number of rows for the listboxes.")]
        public int NumberOfListBoxRows
        {
            set { _numberOfRows = value; }
            get { return _numberOfRows; }
        }
 
        [Category("Behavior"),
         DefaultValue("This is the label text for the left list box."),
         Description("This is the label text for the left list box."),
         Localizable(true)]
        public string AvailableChoicesLabelText
        {
            get;
            set; 
        }
 
        [Category("Behavior"),
         DefaultValue("This is the label text for the right list box."),
         Description("This is the label text for the right list box."),
         Localizable(true)]
        public string SelectedChoicesLabelText
        {
            get;
            set;
        }
 
     
        [Bindable(true),
         DefaultValue((string)null),
         PersistenceMode(PersistenceMode.InnerProperty),
         Editor("System.Web.UI.Design.WebControls.ListItemsCollectionEditor,System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
         typeof(System.Drawing.Design.UITypeEditor)),
         MergableProperty(false),
        Description("The list of available items intended for the left list box.")]
        public ListItemCollection AvailableChoices
        {
            get
            {
                if (this._availableChoices == null)
                {
                    this._availableChoices = new ListItemCollection();
                    ((IStateManager)this._availableChoices).TrackViewState();
                }
                return this._availableChoices;
            }
        }
        [Bindable(true),
         DefaultValue((string)null),
         PersistenceMode(PersistenceMode.InnerProperty),
         Editor("System.Web.UI.Design.WebControls.ListItemsCollectionEditor,System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
         typeof(System.Drawing.Design.UITypeEditor)),
         MergableProperty(false),
         Category("Data"),
         Description("The list of selected items intended for the right list box.")]
        public ListItemCollection SelectedItems
        {
            get
            {
                if (this._selectedChoices == null)
                {
                    this._selectedChoices = new ListItemCollection();
                    if (this._selectedChoicesListBox != null && this._selectedChoicesListBox.Items != null && this._selectedChoicesListBox.Items.Count > 0)
                    {
                        foreach (ListItem li in this._selectedChoicesListBox.Items)
                        {
                            this._selectedChoices.Add(li);
                        }
                    }
                    ((IStateManager)this._selectedChoices).TrackViewState();
                }
                return this._selectedChoices;
            }
        }
 
        #region Typed Style properties
        [
        Category("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(
            DesignerSerializationVisibility.Content),
        PersistenceMode(PersistenceMode.InnerProperty),
        Description(
            "The strongly typed style for the Button child controls.")
        ]
        public virtual Style ButtonStyle
        {
            get
            {
                if (_buttonStyle == null)
                {
                    _buttonStyle = new Style();
                    if (IsTrackingViewState)
                    {
                        ((IStateManager)_buttonStyle).TrackViewState();
                    }
                }
                return _buttonStyle;
            }
        }
 
        [
        Category("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(
            DesignerSerializationVisibility.Content),
        PersistenceMode(PersistenceMode.InnerProperty),
        Description(
            "The strongly typed style for the ListBox child controls.")
        ]
        public virtual Style ListBoxStyle
        {
            get
            {
                if (_listBoxStyle == null)
                {
                    _listBoxStyle = new Style();
                    if (IsTrackingViewState)
                    {
                        ((IStateManager)_listBoxStyle).TrackViewState();
                    }
                }
                return _listBoxStyle;
            }
        }
 
        [Category("Styles"),
         DefaultValue(null),
         DesignerSerializationVisibility(
           DesignerSerializationVisibility.Content),
         PersistenceMode(PersistenceMode.InnerProperty),
            Description(
                    "The strongly typed style for the listbox labels.")
        ]
        public virtual Style LabelStyle
        {
            get
            {
                if (this._labelStyle == null)
                {
                    _labelStyle = new Style();                    
                    if (IsTrackingViewState)
                    {
                        ((IStateManager)_labelStyle).TrackViewState();
                    }
                }
                return _labelStyle;
            }
        }
        #endregion
 
        #region Protected Properties
        protected bool RenderClientScript
        {
            get { return (this.UseClientScript && (this.Page.Request.Browser.EcmaScriptVersion.Major >= 1)); }
        }
        #endregion
 
        #region Protected Methods
        protected override void RecreateChildControls()
        {
            EnsureChildControls();
        }
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            this.TrackViewState(); // check to see whether this is necessary or not.
        }
 
        protected override void CreateChildControls()
        {
            Controls.Clear();
            this._availableChoicesListBox = new ListBox();
            this._availableChoicesListBox.Rows = this.NumberOfListBoxRows;
            this._availableChoicesListBox.SelectionMode = ListSelectionMode.Multiple;
 
            this._selectedChoicesListBox = new ListBox();
            this._selectedChoicesListBox.Rows = this.NumberOfListBoxRows;
            this._selectedChoicesListBox.SelectionMode = ListSelectionMode.Multiple;
 
            this.btnMoveAllLeftToRight = new Button();
            this.btnMoveAllLeftToRight.Text = ">>";
            this.btnMoveAllLeftToRight.ToolTip = this.MoveAllLeftToRightButtonToolTip;
            this.btnMoveAllLeftToRight.CausesValidation = false;
 
            this.btnMoveSelectedLeftToRight = new Button();
            this.btnMoveSelectedLeftToRight.Text = " > ";
            this.btnMoveSelectedLeftToRight.ToolTip = this.MoveSelectedLeftToRightButtonToolTip;
            
            this.btnMoveSelectedLeftToRight.CausesValidation = false;
 
            this.btnMoveSelectedRightToLeft = new Button();
            this.btnMoveSelectedRightToLeft.Text = " < ";
            this.btnMoveSelectedRightToLeft.ToolTip = this.MoveSelectedRightToLeftButtonToolTip;
            this.btnMoveSelectedRightToLeft.CausesValidation = false;
 
            this.btnMoveAllRightToLeft = new Button();
            this.btnMoveAllRightToLeft.Text = "<<";
            this.btnMoveAllRightToLeft.ToolTip = this.MoveAllRightToLeftButtonToolTip;
            this.btnMoveAllRightToLeft.CausesValidation = false;
                       
            if (this.RenderClientScript)
            {
                this.RegisterClientScriptResource(typeof(ListPickerControl), "DaleWare.Web.UI.Controls.ListPickerClientSide.js");
            }
            else
            {
                this.btnMoveAllLeftToRight.Click += new EventHandler(btnMoveAllLeftToRight_Click);
                this.btnMoveSelectedLeftToRight.Click += new EventHandler(btnMoveSelectedLeftToRight_Click);
                this.btnMoveSelectedRightToLeft.Click += new EventHandler(btnMoveSelectedRightToLeft_Click);
                this.btnMoveAllRightToLeft.Click += new EventHandler(btnMoveAllRightToLeft_Click);
            }
 
            if (string.IsNullOrEmpty(this.AvailableChoicesLabelText) == false)
            {
                this._availableChoicesLabel = new Label();
                this._availableChoicesLabel.ApplyStyle(this.LabelStyle);
                this._availableChoicesLabel.Text = this.AvailableChoicesLabelText;
                this.Controls.Add(this._availableChoicesLabel);
            }
            if (string.IsNullOrEmpty(this.SelectedChoicesLabelText) == false)
            {
                this._selectedChoicesLabel = new Label();
                this._selectedChoicesLabel.ApplyStyle(this.LabelStyle);
                this._selectedChoicesLabel.Text = this.SelectedChoicesLabelText;
                this.Controls.Add(this._selectedChoicesLabel);
            }
 
            this.Controls.Add(_availableChoicesListBox);
            this.Controls.Add(_selectedChoicesListBox);
            this.Controls.Add(btnMoveAllLeftToRight);
            this.Controls.Add(btnMoveAllRightToLeft);
            this.Controls.Add(btnMoveSelectedLeftToRight);
            this.Controls.Add(btnMoveSelectedRightToLeft);
 
            if (this._availableChoices != null && this._availableChoices.Count > 0)
            {
                if (this.Sort) this._availableChoices.SortListItems(this.SortDirection == SortDirection.Descending);
                
                foreach (ListItem li in this._availableChoices)
                {
                    this._availableChoicesListBox.Items.Add(li);
                }
            }
            if (this._selectedChoices != null && this._selectedChoices.Count > 0)
            {
                if (this.Sort) this._selectedChoices.SortListItems(this.SortDirection == SortDirection.Descending);
                foreach (ListItem li in this._selectedChoices)
                {
                    this._selectedChoicesListBox.Items.Add(li);
                }
            }
        }
 
        protected override void Render(HtmlTextWriter writer)
        {
            AddAttributesToRender(writer);
            writer.AddAttribute(
               HtmlTextWriterAttribute.Width, this.Width.ToString(), false);
            writer.RenderBeginTag(HtmlTextWriterTag.Table);
 
            if (this._listBoxStyle != null)
            {
                this._availableChoicesListBox.ApplyStyle(this._listBoxStyle);
                this._selectedChoicesListBox.ApplyStyle(this._listBoxStyle);
            }
 
            if (this._buttonStyle != null)
            {
                this.btnMoveAllLeftToRight.ApplyStyle(_buttonStyle);
                this.btnMoveAllRightToLeft.ApplyStyle(_buttonStyle);
                this.btnMoveSelectedLeftToRight.ApplyStyle(_buttonStyle);
                this.btnMoveSelectedRightToLeft.ApplyStyle(_buttonStyle);
            }
 
            if (this.RenderClientScript)
            {
                this.btnMoveAllLeftToRight.Attributes.Add("onclick", string.Format("javascript:return moveListBoxItems(\'{0}\',\'{1}\',false);",
                    this._availableChoicesListBox.ClientID,
                    this._selectedChoicesListBox.ClientID));
                this.btnMoveSelectedLeftToRight.Attributes.Add("onclick", string.Format("javascript:return moveListBoxItems(\'{0}\',\'{1}\',true);",
                    this._availableChoicesListBox.ClientID,
                    this._selectedChoicesListBox.ClientID));
                this.btnMoveSelectedRightToLeft.Attributes.Add("onclick", string.Format("javascript:return moveListBoxItems(\'{0}\',\'{1}\',true);",
                    this._selectedChoicesListBox.ClientID,
                    this._availableChoicesListBox.ClientID));
                this.btnMoveAllRightToLeft.Attributes.Add("onclick", string.Format("javascript:return moveListBoxItems(\'{0}\',\'{1}\',false);",
                    this._selectedChoicesListBox.ClientID,
                    this._availableChoicesListBox.ClientID));
 
                if(this.IsInsideUpdatePanel() == false)
                {    
                    foreach (ListItem li in this.SelectedItems)
                    {
                        this.Page.ClientScript.RegisterForEventValidation(this._availableChoicesListBox.UniqueID, li.Value);
                    }
                    foreach (ListItem li in this.AvailableChoices)
                    {
                        this.Page.ClientScript.RegisterForEventValidation(this._selectedChoicesListBox.UniqueID, li.Value);
                    }
                }
            }
            
            writer.RenderBeginTag(HtmlTextWriterTag.Tr);
            // first list box cell   
            writer.AddStyleAttribute(HtmlTextWriterStyle.TextAlign, "left");
            writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "40%");
            writer.RenderBeginTag(HtmlTextWriterTag.Td);
            // first list box
            if (this._availableChoicesLabel != null)
            {
                this._availableChoicesLabel.RenderControl(writer);
                writer.WriteBreak();
            }
            this._availableChoicesListBox.RenderControl(writer);
            writer.RenderEndTag();
            // button cell
            writer.AddStyleAttribute(HtmlTextWriterStyle.TextAlign, "center");
            writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "20%");
            writer.RenderBeginTag(HtmlTextWriterTag.Td);
            this.btnMoveAllLeftToRight.RenderControl(writer);
            writer.WriteBreak();
            this.btnMoveSelectedLeftToRight.RenderControl(writer);
            writer.WriteBreak();
            this.btnMoveSelectedRightToLeft.RenderControl(writer);
            writer.WriteBreak();
            this.btnMoveAllRightToLeft.RenderControl(writer);
            writer.RenderEndTag();
            // second list box cell
            writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "40%");
            writer.RenderBeginTag(HtmlTextWriterTag.Td);
            if (this._selectedChoicesLabel != null)
            {
                this._selectedChoicesLabel.RenderControl(writer);
                writer.WriteBreak();
            }
            this._selectedChoicesListBox.RenderControl(writer);
            writer.RenderEndTag(); // td tag
            writer.RenderEndTag(); // tr tag
            writer.RenderEndTag(); // table tag
 
        }
 
        #region Custom state management
        protected override void LoadViewState(object savedState)
        {
            if (savedState == null)
            {
                base.LoadViewState(null);
                return;
            }
            else
            {
                Triplet t = savedState as Triplet;
 
                if (t != null)
                {
                    // Always invoke LoadViewState on the base class even if 
                    // the saved state is null.
                    base.LoadViewState(t.First);
 
                    if ((t.Second) != null)
                    {
                        ((IStateManager)ButtonStyle).LoadViewState(t.Second);
                    }
 
                    if ((t.Third) != null)
                    {
                        ((IStateManager)ListBoxStyle).LoadViewState(t.Third);
                    }
                }
                else
                {
                    throw new ArgumentException("Invalid view state .");
                }
            }
        }
 
        protected override object SaveViewState()
        {
            object baseState = base.SaveViewState();
            object buttonStyleState = null;
            object textBoxStyleState = null;
 
            if (_buttonStyle != null)
            {
                buttonStyleState =
                    ((IStateManager)_buttonStyle).SaveViewState();
            }
 
            if (_listBoxStyle != null)
            {
                textBoxStyleState =
                    ((IStateManager)_listBoxStyle).SaveViewState();
            }
 
            return new Triplet(baseState,
                buttonStyleState, textBoxStyleState);
 
        }
 
        protected override void TrackViewState()
        {
            base.TrackViewState();
            if (_buttonStyle != null)
            {
                ((IStateManager)_buttonStyle).TrackViewState();
            }
            if (_listBoxStyle != null)
            {
                ((IStateManager)_listBoxStyle).TrackViewState();
            }
        }
 
 
        #endregion
 
        #region Event Handlers
 
        void btnMoveAllRightToLeft_Click(object sender, EventArgs e)
        {
            foreach (ListItem li in this._selectedChoicesListBox.Items)
            {
                if (this._availableChoicesListBox.Items.Contains(li) == false)
                {
                    this._availableChoicesListBox.Items.Add(li);
                }
            }
            this._selectedChoicesListBox.Items.Clear();
        }
 
        void btnMoveSelectedRightToLeft_Click(object sender, EventArgs e)
        {
            ListItem li = null;
 
            for (int i = 0; i < this._selectedChoicesListBox.Items.Count; i++)
            {
                li = this._selectedChoicesListBox.Items[i];
                if (li.Selected && this._availableChoicesListBox.Items.Contains(li) == false)
                {
                    this._availableChoicesListBox.Items.Add(li);
                }
            }
            for (int j = this._selectedChoicesListBox.Items.Count - 1; j >= 0; j--)
            {
                li = this._selectedChoicesListBox.Items[j];
                if (li.Selected) this._selectedChoicesListBox.Items.Remove(li);
            }
        }
 
        void btnMoveSelectedLeftToRight_Click(object sender, EventArgs e)
        {
            ListItem li = null;
            for (int i = 0; i < this._availableChoicesListBox.Items.Count; i++)
            {
                li = this._availableChoicesListBox.Items[i];
                if (li.Selected && this._selectedChoicesListBox.Items.Contains(li) == false)
                {
                    this._selectedChoicesListBox.Items.Add(li);
                }
            }
            for (int j = this._availableChoicesListBox.Items.Count - 1; j >= 0; j--)
            {
                li = this._availableChoicesListBox.Items[j];
                if (li.Selected) this._availableChoicesListBox.Items.Remove(li);
            }
        }
 
        void btnMoveAllLeftToRight_Click(object sender, EventArgs e)
        {
            foreach (ListItem li in this._availableChoicesListBox.Items)
            {
                if (this._selectedChoicesListBox.Items.Contains(li) == false)
                {
                    this._selectedChoicesListBox.Items.Add(li);
                }
            }
            this._availableChoicesListBox.Items.Clear();
        }
        #endregion
 
       
        #endregion
    }
}

Technorati Tags: Custom Controls,ASP.NET,Ajax.NET,ScriptManager

Sharepoint and Silverlight Video Lessons

2009-06-04T08:47:00.001-07:00

Technorati Tags: Sharepoint,Silverlight

I’ve become much more enthusiastic lately about video training for developers. I’ve gone over the Silverlight screencasts below, and I’m continuing to go through the Sharepoint videos also.

Screencasts for Silverlight 2

Kirk Evans Blog: Free SharePoint Developer Training

Video training is no substitute for going over the documentation on MSDN for these technologies, and certainly no substitute for setting up a personal development environment and plunging into actually doing some coding, even if it is only a tutorial application. Yet it does engage a person in a different learning pathway than simply reading does. Years ago I learned classic ASP development primarily through MSDN and working alongside other developers. I think that the time to learn would have been less if there had been these kinds of video clips available.

SOA/WCF Design Pattern: The Request Class

2009-06-04T08:05:00.001-07:00

Technorati Tags: SOA,WCF,Design Patterns

This is a design pattern which can simplify tremendously of the number of methods needed to get an entity and a series of entities which satisfy a number of parameters.

For someone who comes from a structured programming background to an object oriented background, there is a tendency to specify and write a large number of methods based on different parameters to return an object or collection of objects which satisfy the specified criteria. Usually, though, this can be reduced to two methods: one which returns a single object based on an object ID and one which returns a collection of objects based on a single Request class.

Most entities have some kind of ID property which corresponds to the primary key of a database table. This will often be either a GUID or an identity integer. This should be the basis of a single method which requests a single entity, such as the following GetCustomer method.

   Customer GetCustomer(System.Guid customerId)      
{
        Customer customer = null;      
    //retrieve customer entity into customer class instance       
    //retrieve any customer property collections into customer properties       
    return customer;       
}

Rather than making a number of methods which provide various parameters, or a single large method with a number of parameters, the Request class contains the parameters in a single class. It returns a collection of the entity class. It is a simple Data Transfer Object (DTO) class; it contains data, not behavior. For example, the GetCustomers method would take a Customer Request class and return a collection of Customers. Here is a sample Customer Request class.

   [DataContract]      
public class CustomerRequest       
{
         [DataMember]      
     public string Name {get; set;}       
     [DataMember]       
     public bool Active {get; set;}       
     // Any other parameters 
    }

Usually these parameters can be passed to a single SQL stored procedure or LINQ to SQL statement. Of course, to avoid SQL injection attacks, these parameters must never be concatenated inside a SQL ‘WHERE’ clause. (It’s amazing how this deprecated and insecure technique continues inside some code samples.) Rather, if necessary, the SQL statement can be concatenated with parameter placeholders which are appropriate to the RDBMS, and then the parameters can be passed in in a type safe manner.

One limitation of this pattern is that it’s difficult to use it to check for a null values in any of the database columns for any of the parameters, though usually there are very few requirements that would entail needing to code this kind of functionality.

In an actual WCF implementation, I would also recommend combining this pattern with an implementation of the Enterprise Library Validation block, and that validation attributes would be applied to the DataMember attributes. This would save the need to write a custom WCF ParameterInspector or MessageInspector for the class. It would, moreover, provide additional defense in depth security from malicious input for the service layer of the multitier application, as parameterized stored procedures and SQL statements would provide for the database layer.

In Praise of Prototypes

2009-06-04T07:46:00.001-07:00

On a number of project I’ve been on, much time and effort could be saved if there were more attention given to making a prototype.

Below are the two types of prototypes that I’ve generally advocated and used throughout the course of my development experience. Many projects which got into trouble fairly far down the road might have ended quicker, on time and with the required functionality if they had taken some time to do a prototype first.

1. The throwaway prototype.

This is the prototype which is used simply as an experiment. Not much attention is paid to making the code on these prototypes very pretty. Some of the connections to other systems may simply be stubs. Yet they are invaluable, especially in the early phases of a project. They can help avoid some nasty surprises later in the project as well as validate the intended implementation of the application.

This kind of prototype is most useful for exploring:

Compatibility between different types of components.

Often organizations may build an application with components from different vendors, or a combination of vendor supplied and internally developed components and component adapters and bridges. Before a commitment is made to any one component as a part of the final application, it needs to be compared for compatibility with the other components in a prototype. This prototype should contain functionality comparable to that of the intended application to make sure that all functionality which needs to be compatible is compatible.

Comparing different kinds of implementations and architectures.

Sometimes the choice is between .NET and J2EE, or some other kind situation where there is a reason to go with one kind of architecture, platform or implementation. Or, these kinds of prototypes could compare an implementation in Silverlight, traditional ASP.NET, or Sharepoint for an Intranet application.Sometimes the implementation for an application is actually chosen on the basis of the skillset of whatever programmers – whatever the programmers are familiar with, like or want to learn -- are available for the project, rather than on whether the implementation is robust, scalable, secure and maintainable. These kinds of prototype can give indication as to which implementation can provide a faster delivery date and future extensibility.

Comparing different types of vendor products.

This is the kind of prototype that the vendors generally hate the most, but it actually gives a great indication as to which product is the best fit. It’s actually rarely done during the evaluation of a product, but it would help to avoid projects to implement a ‘road apple’ product with a great salesman. Simply develop a small prototype in each product, and submit it to manual testing and stress and performance testing, and let the product which produces the desired functionality with the quickest delivery time, scalability, maintainability, extensibility, usability and performance wins.

A model for code generation.

This prototype would be a model of the basic tiers and architecture of an application but with only a subset of the required functionality. This prototype would then be the model for the output of a code generator for the project. The model application is actually the first step that should be taken, for the most part, prior to building a code generator to automate building the boilerplate and repetitive code for an application. The repetitive code could be identified more easily, and, in the case of .NET, moved into partial, generated classes.

2. The evolutionary prototype.

This kind of prototype is a necessity for multitier, complex application. Unfortunately, sometimes organizations attempt to build a multitier application one tier at a time, and then connect them toward the end of the project. There was a well known debacle by a major corporation about a decade ago which attempted this path. Since then, the conventional wisdom has been to build a prototype which exercises a small subset of the functionality but goes from end to end, through each tier, and then build out to final product. This validates the basic design of the tiers and identifies possible bottlenecks along the way.

One thing which does need to be done in this case: the project should keep a copy of original or release level prototype in source control. This original copy can usually be morphed into a throwaway prototype and used in side projects for testing requested changes and additional functionality and exploring newly proposed techniques

There is a third kind of prototype which has never been used on any project that I’ve been on, though I believe that its use could have clarified requirements and shortened project delivery times: the paper prototype. Jakob Nielsen has advocated this type often, and definitely usability would come about more quickly and easily if this type were pursued.

Technorati Tags: prototype,software development,projects,ntier architecture

Suggested ASP.NET Secure Coding Standards and Guidelines

2009-05-28T07:15:00.001-07:00

Often I find when I go to a new project as a consultant, that there is some need for education, standards and guidelines for secure coding practices. Here are a set of sample guidelines that I put together on a recent project. As before, these can be updated, expanded and modified as the need arises.

General:

Validate user input for text length, data type and correct pattern. Use regular expressions to check for correctly formatted input. Enforce correct input rather than trying to filter out incorrect patterns. Data validation is a secure coding practice as well as an application coding best practice. This includes both server side .NET code and client side Javascript, and any source which a malicious user or malicious code intercept and malign.
Do not let sensitive application or database implementation information be returned to the user in error messages.
Make sure that the production builds are in release mode and that no debugging information (.PDB) files are released to the production environment.
Remove or hide buttons rather than disabling them since it is possible for a malicious user to generate a postback through a disabled button (elevation of privileges attack).
Review URLs in code for proper direction to HTTPS for SSL before pages are moved to production.
Avoid passing information between pages through query strings and hidden form fields since these can be exploited by malicious users. Use session state to pass information between pages and viewstate to pass information back to the same page between postbacks.

Code Access Security:

Review code for appropriate implementation of code access permissions.
Avoid use of SecurityAction.Assert in production code.

Authorization

Run any authentication or authorization code on all page requests, including postbacks. Use code like this (move this to a base page or master page class if possible):

protected void Page_Load(object sender, EventArgs e)

{

RunSecurityMethod();

}

Do not produce code like this:

protected void Page_Load(object sender, EventArgs e)

{

if(this.IsPostback == false) RunSecurityMethod();

}

Review code for appropriate implementation of user authorization and authentication.

Cross site scripting attacks:

Make sure that any user input which is echoed back to the web page is HTML encoded (HttpServerUtility.HtmlEncode method) or URL encoded (HttpServerUtility.URLEncode) to avoid Cross Site Scripting attacks. This can also include situations where the user input is saved to a database, retrieved from the database and displayed in a web page.
Make sure that each HTTP request is validated through ASP.NET request validation. The default for the machine.config file should be: <pages validateRequest="true" ... />.
Consider including the Microsoft Cross Site Scripting Library to sanitize data from users and any other outside sources.

Cross-site request forgery (one-click attack):

Make sure that each page sets the ViewStateUserKey value (preferably through a base page class derived from System.Web.UI.Page or a master page).

protected override OnInit(EventArgs e)

{

base.OnInit(e);

ViewStateUserKey = Session.SessionID;

}

SQL Injection Attacks:

Avoid string concatenation to form SQL strings.
Prefer parameterized stored procedures to dynamic SQL.
Avoid dynamic SQL inside stored procedures.
If dynamic SQL is absolutely necessary, use parameters with a constructed string rather than string concatenation.

Encryption:

Do not create your own algorithms for encryption.
Do not use DES or MD5 for encryption since these are known to be breakable. They were included in .NET primarily for backward compatibility.
Use only an industry standard encryption algorithm known to be practically unbreakable.
Use secure storage for all private encryption keys and certificates.

Password storage:

Store a generated hash of a password rather than a password itself.
Do not store or send a password over a network connection in clear text.

Tracing:

Make sure that ASP.NET tracing is not enabled for remote tracing via trace.axd in the web.config file when an application is moved to a production server.
Make sure no sensitive information revealed in Trace statements since traces can be turned on easily in configuration files.

Configuration files:

Do not store sensitive information such as database connection strings in configuration files except in an encrypted section.
Make sure that any WCF services do not enable or expose metadata exchange endpoints in a production web.config file.

Code reviews:

Review code for security vulnerabilities during all formal and informal code reviews.
Review code for Code Access Security permissions during formal and informal code reviews for whether there are more needed, and whether any there need to be more or less restrictive.

For more see:

MSDN Security Developer Center

patterns & practices Security Guidance for Applications

The .NET Developer's Guide to Windows Security (Keith Brown: online reference)

Michael Howard's Web Log

eSecurity Planet

The Open Web Application Security Project (OWASP)

Top 10 Secure Coding Practices

Technorati Tags: secure coding,coding standards,software development,ASP.NET

Suggested Standards and Guidelines for Error and Exception Handling

2009-05-28T05:36:00.001-07:00

Here are a set of basic suggestions that I put together for a client for error and exception handling on a multitier ASP.NET project with Visual Studio 2008/ .NET 3.5 SP1.

Basic Needs for Error / Exception Handling

Flexible framework to log exception details in a way in which developers and support staff can find the information relevant to troubleshooting and fixing the problems.
Coding standard to establish a consistent method to provide user friendly error messages while avoiding disclosing implementation details as a security risk.

Framework /Library Alternatives:

Alternative 1: Microsoft Enterprise Library 4.1 Exception Handling Block

Targeted .NET Framework: 3.5 SP1

Advantages:

Free
Easy to use
Source code examples readily available
Logs information to a variety of destinations such as the event log, files or a database
Highly configurable
Comes with configuration utility
Externally maintained by Microsoft Patterns and Practices Team
Documented and packaged with other Enterprise Library components
Documentation integrated with Visual Studio / MSDN documentation
Specifically targeted for the .NET 3.5 SP1 platform
Incorporates additional functionality for WCF error handling and logging (note the section in the Enterprise Library documentation, ‘Integrating the Logging Application Block with WCF Applications’)
Able to customize
Familiar to many .NET developers

Disadvantages:

Requires some experimentation and prototyping to understand its functionality.

Alternative 2: Log4Net:

Targeted .NET Framework: 2.0

Advantages:

Free
Easy to use
Logs information to a variety of destinations
Highly configurable
Source code examples readily available
Externally maintained by open source community
Able to customize
Familiar to many .NET developers

Disadvantages:

Targets earlier version of the framework
Does not incorporate additional functionality for WCF error handling and logging
No configuration utility

Alternative 3: Internally developed component(s):

Advantages:

Primarily when necessary to meet any internal standards which cannot be met with a free or open source framework.
Internal code maintenance not at the mercy of external corporations or developers.

Disadvantages:

· Cost in time and money for internal development and maintenance

· Learning curve for new hires and external resources

· May reflect personal preferences and “blind spots” of internal developers

· May open up security holes unless carefully reviewed

· May not be transferable to later projects

Suggested common sense coding standards for exception and error handling:

Avoid ‘eating exceptions’ (catching an exception in an empty block):

try

{

// my cool code goes here

}

catch{} // I can’t find out or fix what happens here in production

// errors may still propagate up the call stack and the user

// may have a mysterious failure to deal with

Use a ‘finally { } ‘ or a ‘using . . . { } ‘ block to dispose of unmanaged resources when an exception occurs.
Log exceptions where possible, especially if the error condition indicates a network, database or file I/O problem.
Log exception information such as the call stack and any associated input data along with user information.
Throw exceptions to indicate error conditions rather than returning error codes, since error codes are rarely documented well enough for future maintenance and troubleshooting.
Return null rather than throwing an exception if an expected object cannot be returned from a method, since testing for null in an if statement is usually less expensive than handling exceptions.
Do not use exceptions for control flow. Check for null and error conditions with if and switch statements rather than throwing or catching exceptions.
Use correct exception classes for throwing exceptions, such as ArgumentNullException if a null reference is passed as a parameter to a method and ArgumentException if a parameter passed to a method is otherwise invalid.
Include information in any exceptions thrown to indicate the cause and correction for the exception.
Derive new exception classes from System.Exception. Microsoft has deprecated the previously recommended practice of deriving new exception classes from System.ApplicationException.
Error messages displayed to the user should suggest a possible correction if possible.
Seek to return the application after an exception to a state where the user can continue or correct his or her previous action rather than force the user to start all over again.
Use standard validation techniques as much as possible to correct user input rather than throwing exceptions.
Incorporate a generic exception handling method in base classes that performs the standard method of handling and logging exceptions, such as a in a base web page or master page class.
Incorporate an exception building method that returns the desired exception in classes which throw exceptions.
Provoke exceptions during unit, integration and system testing to determine application security and robustness.
For web pages, include error and exception handling in client side Javascript so that it ‘fails gracefully’ if something undesirable happens.

Recommendations:

Implement the Exception Handling Block of Enterprise Library 4.1, and establish Exception Handling Policies for DataAccessExceptions, SqlExceptions, SecurityExceptions, WCF FaultExceptions and WCF CommunicationExceptions. If the Enterprise Library Validation Block is used, add an exception policy also for ValidationException.
Consider logging error information to a centralized store. The alternatives with the Enterprise Library are to use the Database Trace Listener to log error information to a database or the MSMQ Trace Listener with the MSMQ Distributor Service with the Logging Application Block to log error information to a central store through an MSMQ queue. Log4Net contains database logging functionality.
If the Enterprise Library Database Trace Listener is used, add an event listener for the event log or a flat file, and, optionally, an email listener for the Logging Errors and Warnings category under special sources to catch any errors that cannot be logged to the database.
Establish coding standards for exception handling at each tier / layer of the application.
Consider deriving application specific exception classes to wrap exceptions that get thrown. Examples: MyAppException, MyAppFaultException (for WCF errors), and MyAppClientException(for ASP.NET errors). These could be used for specific exception handling routines.
Document the error logging method and location of error information for ongoing application maintenance and support staff.
Consider using an exception handling and logging library that can send notifications through email to maintenance and support staff for severe errors. Both Enterprise Library and Log4Net contain this functionality. Homegrown logging solutions sometimes expose too much email functionality which can be exploited by malicious users (whether internal or external).
Avoid internal development, maintenance and customization of exception handling and logging libraries unless the need is overwhelming.
Provide a method to handle and log all uncaught exceptions at the ASP.NET and WCF levels. Handle the Application_Error event in Global.asax for ASP.NET pages and implement IErrorHandler at the WCF level. The ASP.NET error page should display a user friendly explanation of what happened.

Lessons in Building Unconditionally Constructive Working Relationships

2009-05-26T14:43:00.001-07:00

Roger Fisher and Scott Brown, Getting Together: Building Relationships As We Negotiate. New York: Penguin Books, 1989.

Summary:

In working relations and human relations in general there is considerable confusion as to what constitutes a good relationship in practical terms. Too often a good working relationship is considered in terms of agreement, approval or having shared values instead of good substantive outcomes that leave the concerned parties emotionally at ease and where differences have been effectively dealt with. Relationship is a process itself separate from its outcomes, and rather is to be pursued on its own merits.

As a process, it is possible to implement a definite strategy to foster good working relationships. The definition of the strategy itself is so concise and striking, it bears full citation:

An Unconditionally Constructive Strategy

Do only those things that are both good for the relationship and good for us, whether or not they reciprocate.

1. Rationality. Even if they are acting emotionally, balance emotions with reason.

2. Understanding. Even if they misunderstand us, try to understand them.

3. Communication. Even if they are not listening, consult them before deciding on matters that affect them.

4. Reliability. Even if they are trying to deceive us, neither trust them nor deceive them; be reliable.

5. Noncoercive mode of influence. Even if they are trying to coerce us, neither yield to coercion nor try to coerce them; be open to persuasion and try to persuade them.

6. Acceptance. Even if they reject us and our concerns are unworthy of their consideration, accept them as worthy of our consideration, care about them, and be open to learning from them.

Roger Fisher and Scott Brown, Getting Together: Building Relationships As We Negotiate (New York: Penguin Books, 1989), p.38

These guidelines are ‘unconditionally constructive’ because they can be good both for the relationship and the person or party that follows them regardless of whether the other side follows these same guidelines.

Rationality. Even if they are acting emotionally, balance emotions with reason.

A proper working relationship means a realization that each one involved, including oneself, ‘the party of the first part,’ is a human being that is both rational and emotional, and that both these aspects need to be balanced. Emotions need to be understood and acknowledged as part of the working relationship, and harnessed to provide motivation and deepen mutual understanding, but not allowed to become so strong that they cloud the judgment one’s own judgment. This will help to deal with the conflicts and problems that may occur.

Understanding. Even if they misunderstand us, try to understand them.

Understanding differences is necessary to understand them. This means seeking constantly to learn more about the interests, perceptions, concerns and values of the others involved in the relationship. It requires the strength to be able to change one’s preconceptions and views during the course of the relationship, and to seek to understand the choices before the others who are involved.

Communication. Even if they are not listening, consult them before deciding on matters that affect them.

Communication is not necessarily an indication of shared values, mutual approval or even friendship, and good communication is more necessary the less of any of these influence the relationship. Ineffective communication is no communication, one sided communication, or inconsistent communication (“mixed messages”). Effective communication means:

· Always consult before deciding. This does not mean an abdication of personal authority or responsibility but rather sharing necessary information.

· Listen effectively.

· Plan the communication to minimize inconsistent communication.

Reliability. Even if they are trying to deceive us, neither trust them nor deceive them; be reliable.

This takes personal trust and/or suspicion out of the process, and shifts the goal to pursue personal reliability and an accurate assessment of the risks of relying on the other person. A history of erratic, careless, deceptive and dishonest conduct is at the root of distrust; predictability, clarity, honesty and taking promises seriously builds trustworthiness and demonstrates reliability. A reliance on ‘pure trust’ in dealing with others will require legitimate actions to reduce risk, granting trust where it has been earned, fair and precise giving of praise and blame, and treating incidents of unreliability as a ground for changing one’s own actions as well as the other person’s actions.

Noncoercive mode of influence. Even if they are trying to coerce us, neither yield to coercion nor try to coerce them; be open to persuasion and try to persuade them.

Coercion damages working relationships and the quality of agreements for the long term, which is the opposite of attempting to build a long term working relationship. Coercive tactics include personal attacks, treating the negotiation as a win/lose contest, taking a hard and fast position, narrowing options to ‘either/or’, trying to break the will of the other side, and making threats. The persuasive tactics are to attack the problem, treat negotiation as problem solving, to remain open to persuasion and to explore interests, to invent multiple mutually advantageous options, deal with what is fair, and to improve one’s own BATNA.

Acceptance. Even if they reject us and our concerns are unworthy of their consideration, accept them as worthy of our consideration, care about them, and be open to learning from them.

Rejection creates psychological obstacles to an effective working relationship; rather the need is a willingness to deal with the other person, treat him or her with respect, give the other person’s interests the weight that they deserve, and treat the other person as a equal as a human being.

Applying the Lessons to Working in IT:

Rationality. Even if they are acting emotionally, balance emotions with reason.

· Since working on a project can mean assessing and evaluating the output of others, it can come up against emotional reactions from others in IT. It is therefore often necessary for the person involved to be the most rational and understanding person involved in the process.

· There is also the potential for emotional reactions from others if there are unexpected indications of poor quality on the project or overly optimistic evaluations of the quality of a project. Again, follow the lesson here.

Understanding. Even if they misunderstand us, try to understand them.

· Those involved in the software testing process can themselves be misunderstood and have their motives and objectives misunderstood. There is always a good possibility of being misunderstood by others on the project team as meddlers and nitpickers. The goal is to work past this and to understand what the project team is actually trying to accomplish, and be a part of this effort.

Communication. Even if they are not listening, consult them before deciding on matters that affect them.

· Constant communication and consultation is necessary throughout the process of testing with others on the project team. Often decisions are made along informal networks by those who have been working together for years. Still, the goal should be in the testing process to involve those who will be affected by testing decisions before those decisions are final.

· This is contrary to a ‘do it first, then ask permission’ way of doing things in an organization. This minimizes the long term and often negative consequences of leaving people who are significantly impacted by decisions and actions out of the path of influencing those decisions and actions.

Reliability. Even if they are trying to deceive us, neither trust them nor deceive them; be reliable.

· Reliability should be a normal qualification and method of operation for anyone involved in software testing or test consultation, or development for that matter.

· Reliability includes basic honesty.

· Reliability is the basis for future respect and being treated as trustworthy.

Noncoercive mode of influence. Even if they are trying to coerce us, neither yield to coercion nor try to coerce them; be open to persuasion and try to persuade them.

· One person may describe his own style of communication as persuasive, but the subjects of that communication style may call it more coercive. The truth is more often in the eye of the beholder in this instance.

Acceptance. Even if they reject us and our concerns are unworthy of their consideration, accept them as worthy of our consideration, care about them, and be open to learning from them.

· Being always open and ready to undertake an effective working relationship with others despite their previous behavior toward us is a sign of strength and confidence that others will respect. At the end of the day, the people we all work with are still people, and as such deserve this kind of quality treatment.

Technorati Tags: Negotiation,IT Management,team development

Lessons in Lateral Leadership

2009-05-26T14:39:00.001-07:00

Roger Fisher and Alan Sharp, Getting It Done: How to Lead When You’re NOT in Charge. HarperCollins Publishers, New York 1999.

Summary:

The goal of this book is to define ways to produce high quality results through collaboration by lateral leadership. Lateral leadership is not guiding by superior authority but rather is inviting colleagues to work with you to solve problems.

The primary guidelines are handled under a three step method to improve oneself first and then to guide others to change:

· Organize and sharpen your personal skills at getting things done by yourself.

· Understand clearly your strategic goal of getting things done with others.

· Develop some tactics of participatory leadership.

DEVELOP PURPOSE.

· Sharpen your purpose: develop a purpose that motivates and guides you, in terms of results to be achieved. Formulate immediate objectives, mid range goals and a long term vision.

· Everyone helps formulate a set of results to achieve together.

· Lead in improving setting the purpose in your own organization. Find out the organizational purpose and the reasons for it, and find ways to make them focused and tangible.

THINK SYSTEMATICALLY.

· Develop a personal framework for organized and clear thinking. Look for information that helps make decisions. Rather than react to symptoms, step back and look for causes. Invent creative approaches to different situations.

· Clarify a vision of collaborative, systematic thinking.

· Stimulate others to think systematically.

INTEGRATE THINKING WITH DOING.

· Follow a sequence of “Prepare -> Act -> Review,” to learn from experience.

· Prepare and review together for a group learning experience.

· Help your colleagues learn from experience.

OFFER EVERYONE A CHALLENGING ROLE.

· Reframe your job to include engaging challenges. Find opportunities to use your best skills, take time to contribute, even when it’s not your job, and expand your job to include things that aren’t being done.

· Clarify a vision of everyone becoming fully engaged. Assume that contributing ideas is everyone’s job, share responsibility for dividing work, frame the success of the whole project as everyone’s responsibility.

· Foster a climate that invites engagement of everyone in the projects, initiatives and group tasks.

EXPRESS APPRECIATION AND OFFER CONSTRUCTIVE FEEDBACK.

· Learn how to offer supportive feedback. Express appreciation to motivate, offer advice to improve performance, evaluate against the performance of others only when needed to make a personnel decision.

· Clarify a vision of mutual support and coaching: “Appreciation makes everyone perform better. Seeking coaching is a sign of competence. Anyone can coach anyone.”

· Encourage others to offer feedback in ways that are helpful.

Applying the Lessons to Working in IT:

DEVELOP PURPOSE.

· Internalize your own reasons for the job role you’re in, in terms of the results that you wish to accomplish, and be able to articulate them.

· Internalize the goals and objectives for your organization in terms of desired results, and relate your job goals and objectives to them. Draw the connections yourself. Use the connections during project consultation.

· Ask intelligent questions about the larger reasons why things are being done the way they are being done, in terms of desired and expected results, rather than established routines.

· Work with others to relate their projects, roles, goals and objectives to the larger organizational goals by asking the intelligent questions to them in a non threatening manner.

THINK SYSTEMATICALLY.

· Research IT problems from both a technical and organizational (“process”) perspective.

· Develop a personal systematic troubleshooting (“root cause analysis”) methodology to identify, formulate and articulate solutions to problems encountered.

· Articulate how to troubleshoot problems efficiently and effectively, and encourage others to work problems through systematically.

· Develop a personal technical analysis methodology to examine I/S initiatives, improvements and solutions for corporate benefits, possible pitfalls, unexplored risks, and possible improvements.

INTEGRATE THINKING WITH DOING.

· Prepare thoroughly but not excessively for ‘action.’ Remember that ‘doing’ can be written and oral communication with others as well as technical ‘hands on’ tasks. Formulate a desired result, consider the task in light of the others who will be or could be evaluating the result, and evaluate the probable effectiveness of the preparation throughout the course of the preparation.

· Execute the planned actions skillfully.

OFFER EVERYONE A CHALLENGING ROLE.

· Take the initiative yourself to look beyond the routine responsibilities of your own job roles to include more challenging responsibilities.

· Look beyond personal and social compatibilities to organizational synergies in working with technical teams.

· Look for important but overlooked tasks that may be vital to the success of the team effort, and take the initiative to achieve those.

· Assist the less forthright and articulate members to express their thoughts and take action, so that their contributions may be recognized.

· Arrange so that all team members both take responsibility and take credit for the result of the team’s goals.

EXPRESS APPRECIATION AND OFFER CONSTRUCTIVE FEEDBACK.

· Look at the validity of information and direction rather than the authority level or position in the hierarchy of the source.

· Express genuine appreciation for help offered and rendered.

· Encourage others to accept valid information and direction and offer genuine appreciation.

Technorati Tags: Negotiation,IT Management,team development

Lessons in Breakthrough Negotiation

2009-05-26T14:33:00.001-07:00

William Ury, Getting Past No: Negotiating Your Way from Confrontation to Cooperation. New York: Bantam Books, 1993.

Summary:

Negotiation, whether informal or formal, can be tough. There are primarily five real world barriers to cooperation:

· Your own reaction to attack and attempts at exploitation.

· The other side’s anger, hostility, fear and distrust.

· The other side’s rigid adherence to their position.

· The other side’s unwillingness to reach a mutually satisfactory agreement.

· The other side’s determination to win as a demonstration of power.

The strategy to break through these barriers are these five steps:

· Go to the Balcony.

· Step to their side.

· Reframe.

· Build them a golden bridge.

· Use power to educate.

Preparation for a negotiating situation is highly urged, and concentrates on thinking through the four major points from the previous book, Getting to Yes, in regard to oneself and the other parties involved in the negotiation.

GO TO THE BALCONY.

The natural reaction to aggressive, devious and stubborn behavior and attempts at exploitation are to strike back, to give in, or to break off relations. This step is the suggested alternative, and is a metaphor for distancing oneself from one’s natural impulses and emotions – detaching oneself from a reaction. The key is to name and recognize the stonewall, the attack, and the tricks, and then buy time to think. This can be done by a pause and silence, review what has transpired so far in the decision making process, or to take a time-out, even a brief one. This will avoid a possibly wrong and hasty decision under pressure.

STEP TO THEIR SIDE

Negative emotions often are behind inflexible positions. Disarming these calls for doing the unexpected, to step to their side. The goal is to create a favorable climate for negotiation. This means:

· Listening to understand – to hear out the other side with patience and discipline – and then paraphrase what they are saying back to them and ask for corrections.

· Acknowledge – but do not necessarily agree with – their point. Recognize their feelings, offer an apology if they feel that they have been wronged and still demonstrate strength and confidence.

· Agree wherever you can. This does not mean conceding anything, but rather returning the focus to whatever common ground can be found.

· Acknowledge the person wherever possible. Act in contradiction to any negative perception, stereotype or caricature of you, and acknowledge whatever genuine authority and competence that they do have, and strive to build a working relationship with that person.

· Express your own views without provocation. State your own feelings in terms of the way that you feel, and continue to stand up for yourself. Acknowledge your differences with optimism rather than antagonism.

REFRAME.

Reframe a tough situation so that it can be directed into a mutual problem solving session. Ask the problem solving questions to discover underlying interests (“Why?” and “Why not?”, to brainstorm on possible solutions (“What if?”), to elicit advice (“What would you do in my situation?”), and to discuss standards of fairness (“What makes that fair?”). Likewise, there are specific tactics to reframe stonewalls, attacks, and tricks, and to negotiate about the negotiation itself. The turning point then comes when the tough negotiation becomes mutual problem solving.

BUILD THEM A GOLDEN BRIDGE.

The four biggest reasons for rejecting a proposal are:

· It was not the idea of the other side.

· It does not meet some basic interests of the other side.

· It would mean that the other side would lose face.

· It seems too much to agree to in too short a time.

Instead of applying pressure, the metaphor is to build the other side a golden bridge to agreement – to draw them in the direction that you want them to come. This gets back to starting from where they are. The basic method again is to ask questions. Ask for their ideas and for constructive criticism of your own, and offer choices and alternatives. If there is still resistance, the advice is to probe for overlooked, often intangible, interests and needs which still have not been met. Additional tactics are suggested against face saving resistance, and helping the other side to frame the agreement in a positive light and to implement the agreement in an easy fashion.

USE POWER TO EDUCATE.

The striking metaphor here is: “Use power to bring them to their senses, not to their knees.” The idea is to bring the other side to see that the cost of no agreement is greater than a mutually beneficial agreement. The idea is not to use power to force or punish, but to bring the other side to continuing to solve the problem together. Then the goal becomes forging a firm and lasting agreement that can be implemented effectively and which gives mutual satisfaction, not victory. A number of ways to do this are elucidated.

Finally, the goal is repeated as not to “ . . . win over them, but to win them over.” This is the final strategy of breakthrough negotiation: to turn an adversary into a partner.

Applying the Lessons to Working in IT:

Many times, people both inside IT and outside IT can be at times notoriously difficult to work with, especially where there are circumstances which require joint efforts. These lessons can help to reduce adversarial conditions and improve cooperation with other areas. The need is still to turn real and potential adversaries into actual partners. The potential adversary can be an internal rival, an irate customer, or an exploitative colleague.

GO TO THE BALCONY

· Emotional outbursts can come from others. Seek to be the calmest person in the room if this happens.

· Base your reaction not on the volatile and possibly provocative actions of others but take the time to weigh your reaction.

STEP TO THEIR SIDE.

· The unexpected reaction of understanding and treating the other person with respect can also be the most powerful.

· Understanding the other person does not invalidate one’s own ideas and interests, but provides the way to build the common ground necessary to build a mutually advantageous, effective and workable solution.

REFRAME.

· A creative and artful act of reframing the negative responses of the other involved parties can be an effective turnaround of an antagonistic situation. Look for the unexplored aspects of the situation.

BUILD THEM A GOLDEN BRIDGE.

· No decision in a corporate environment is ultimately a battle of wills between individuals, since it will have consequences for the future stability, growth and prosperity of the business as a whole. Therefore don’t look for a one sided victory, to ‘beat’ the other person, but rather provide an honorable solution and cooperative working relationship for the future. Each decision, and how the decision is arrived at, has profound consequences for the future morale and cooperation within the organization.

USE POWER TO EDUCATE.

· In IT, power is not necessarily the possession of managerial authority; it can be the possession of technical knowledge and expertise (such as support or programming training) or access to or control over technical resources (such as being a LAN or database administrator). These kinds of power can sometimes be used to try to humiliate or ‘win’ over other people. These kinds of power can also be used to educate others to bring them to a mutually advantageous solution. The people who do the latter are those who gain long term respect and responsibility in an organization.

Technorati Tags: Negotiation,IT Management,team development

Lessons in Principled Negotiation

2009-05-26T14:29:00.001-07:00

Roger Fisher, William Ury and Bruce Patton, Getting to Yes: Negotiating Agreement Without Giving In. Penguin Books, New York 1991.

Summary:

Principled negotiation is the central theme, where different parties work toward a common agreement based upon common principles, as opposed to positional negotiation, where different parties try to reconcile their different positions. Principled negotiation is deemed superior to positional negotiation in producing wise agreements, in efficiency at arriving over conclusions, and in preserving and improving ongoing relationships.

Principled negotiation is based upon four major points:

· People: separate the people from the problem.

· Interests: focus on interests, not positions.

· Options: generate a variety of possibilities before deciding what to do.

· Criteria: insist that the result be based on some objective standard.

It is also not simply ‘deal making,’ where both sides can become ‘partners in crime’, rather than working out decisions and situations where both sides achieve results to their advantage, and where no moral or ethical principles are breached. The goal is to achieve solutions which are also in accord with one’s own conscience.

PEOPLE: SEPARATE THE PEOPLE FROM THE PROBLEM

The primary objective is to deal with the other people in the negotiating process as people, with their own perceptions and emotions that become part of the process. The key is to deal tactfully with these factors and work at making communication with the other parties in the negotiation effective, so that the negotiation is carried out in a working, not adversarial, relationship. Specific instructions include:

· Avoid putting the worst interpretation on the words and actions of the other side(s) or assigning blame to the other side.

· Discuss each others’ perceptions of the situation and issues.

· Don’t react to emotional outbursts.

· Speak to be understood.

· Speak to the problem, not the people.

INTERESTS: FOCUS ON INTERESTS, NOT POSITIONS.

Each negotiation involves the interests – the needs, desires, concerns and fears – of the people involved in the negotiation. These interests may motivate the formulation of opposing positions, but the development of a mutually acceptable solution involves reconciling both shared and conflicting interests. While attempting to understand the other parties involved in the negotiation, decide whose decision you need to affect and what decision you want to ask them to make, and then analyze the consequences of agreement or refusal from their perspective. Then specifically and vividly explain your interests, while acknowledging their interests also.

OPTIONS: GENERATE A VARIETY OF POSSIBILITIES BEFORE DECIDING WHAT TO DO.

In many negotiations, the parties do not explore many options because of premature judgment about the other persons’ reactions or the solutions to the problems, or settling too early on a single answer, or looking to achieve only one’s self interest, or in the outcome of a negotiation as solely a win/lose proposition. The basic suggestion is to have a brainstorming session to explore options, and then to decide. As a tool for finding these, a Circle Chart is provided, to state the problem, to analyze the problem, to generate strategies and to define specific action steps. The aim is then to identify solutions that answer shared interests and dovetailing differing interests, and try to make the decision of the other parties in the negotiation easy for them.

CRITERIA: INSIST THAT THE RESULT BE BASED ON SOME OBJECTIVE STANDARD.

The highest relational cost comes when negotiations become a battle of wills. The solution then becomes negotiation of objective criteria independent of the will of any party to the negotiation. This has the effect of producing wise, efficient and amicable agreements instead of embittering battles for dominance. First, look personally for mutually reasonable and fair standards and procedures for making a decision. In actual negotiation, frame each issue as a joint search for objective criteria, use reason and be open to the reasoning of the other parties in the negotiation. Finally, never yield to pressure, only to principle. If the other side tries to use pressure, “ . . . the principled response is to invite them to state their reasoning, suggest objective criteria you think apply, and refuse to budge except on this basis” (p. 90).

Succeeding chapters deal with a number of specific tactics that are often contradictory to the ‘conventional wisdom’ of negotiating:

· Rather than having a ‘bottom line,’ have a BATNA (Best Alternative to a Negotiated Agreement).

· Verify all factual assertions. Personal trust is not an issue in doing so.

· Use negotiation jujitsu rather than pushback and retaliation to sidestep stubborn assertions of a position, attacks on ideas and personal attacks; try to turn each one into a statement of interest and an attack on the problem. Ask questions and pause for an answer instead of making statements.

· Address tricky, unethical and illegitimate bargaining tactics by negotiating about the rules of negotiating.

· Learn how much authority the other side has to make an agreement.

Finally, the book concludes with a series of clarifying questions and answers to specific application of the methods. Most boil down to variations on getting to know the interests of the other side and understanding one’s own interests and goals in the negotiation process.

Applying the Lessons to Working in IT

People: separate the people from the problem

· Throughout I/S, representatives from different groups must work out solutions to problems and long term goals. Personal histories and reputations, both positive and negative, become can become entrenched over time, many times upon inadequate information, personal grudges, and hearsay. Refuse to judge a person’s potential contribution or cooperation before attempting to resolve the problems with that person.

Interests: focus on interests, not positions.

· Look at what a position, inference or conclusion is based upon – its underlying reasons – when confronted with a set position. Ask questions to determine these underlying reasons if they are not apparent.

Options: generate a variety of possibilities before deciding what to do.

· Use brainstorming effectively to generate multiple approaches and possible solutions and objectives. ‘What if’ questions can be very effective in an IT environment.

· Use the ‘what if’ to generate additional possibilities when it is apparent that decisions are being made prematurely.

Criteria: insist that the result be based on some objective standard.

· The objective standard often can and should be rooted in the common business objectives of the corporation and the goals and objectives of the lower levels in the hierarchy. At other times, appeal can be made to technical realities and industry standards. Whatever the standard, it should be something objective that can become common ground for the involved parties.

· The corporate scandals of recent months have highlighted how unethical working relationships can become. Objective standards also include moral and ethical principles, as well as bare letter of the law. Basing decisions on objective ethical standards rather than ‘what we think we can get away with’ provides decisions which can stand both public and private scrutiny, as well as the scrutiny of one’s own conscience.

Technorati Tags: Negotiation,IT Management,team development

Prologue: Lessons in Productive Negotiation and Cooperation From the Harvard Negotiation Project Team

2009-05-26T14:24:00.001-07:00

There is a constant need for productive working together in the corporate world, especially in IT projects, where much of what is accomplished is done through consultation with others. This means that there is a constant need for constant sharpening of soft skills in dealing with other people, both with those who are already cooperative and with those who are less so. These skills can be as critical as technical skills in achieving genuine productivity.

Insightful lessons in negotiation and cooperation in a working environment come from the four books from lawyers Roger Fisher and William Ury, who were originally part of the Harvard Negotiation Project. Negotiation is a genuine part of the IT work environment when it is defined as mutual problem solving. In order to achieve genuine results in the IT work environment, the productive IT knowledge worker needs to absorb and apply the kinds of lessons that are found in these books. The following blog posts are only an introduction to and application of the lessons that they offer, and is certainly not a substitute for personal reading, understanding and application of their books.

Lessons in Principled Negotiation

Based on: Roger Fisher, William Ury and Bruce Patton, Getting to Yes: Negotiating Agreement Without Giving In. Penguin Books, New York 1991.

Lessons in Breakthrough Negotiation

Based on: William Ury, Getting Past No: Negotiating Your Way from Confrontation to Cooperation. New York: Bantam Books, 1993.

Lessons in Lateral Leadership

Based on: Roger Fisher and Alan Sharp, Getting It Done: How to Lead When You’re NOT in Charge. HarperCollins Publishers, New York 1999.

Lessons in Building Unconditionally Constructive Working Relationships

Based on: Roger Fisher and Scott Brown, Getting Together: Building Relationships As We Negotiate. New York: Penguin Books, 1989.

Technorati Tags: Negotiation,iT Management,team development

Workplace Issues for GTs in IT Organizations

2009-05-25T18:16:00.001-07:00

In my previous post, Managing GTs in IT Organizations, I shared some ideas on how I as a (Gifted and Talented Adult) would prefer to be managed. Since there are a number of GTs in IT, I’m sharing the following observations for their benefit as well.

Overqualification and underemployment are real difficulties for many GT adults in the modern workplace.

Earlier in my career, I found this was an issue with positions in which I was frankly overqualified and underemployed. Our capabilities can put us into situations where we may even find ourselves outperforming everyone around us but being held back by management because we are 'indispensable.' I think the key is to realize that some of these positions are transitional, and to seek to keep ourselves from being 'indispensable' by cross training our coworkers. If we can find some way to let our managers know that we're gifted in an appropriate manner, we can also head off some problems if they begin to expect everyone to be able to pick up things like we can and do the variety of things that we can. But I found that jobs with easily mastered, routine and repetitive responsibilities were not really suitable for me for the long term. Rather, these jobs were stepping stones to other positions with greater responsibilities and challenges.

Generally, most people nowadays seek more out of a job than just a paycheck, and this is even more so for GTs. Unfortunately, many people still have some strange ideas about employment; it does not have to be misery inducing monotony. Rather, a GT is a person who is most satisfied when being productive and making a significant contribution, and this can often be very profitable both for the GT and the organization which employs him or her.
Vocational choice is a real difficulty also for many GT adults.

When a person can do many things well, there are a number of vocational choices open. Here is one of the places where a GT can make a good choice that goes sour when it seems that there are many good choices. It is also a place where externally imposed choices can cause years of heartache and frustration, where a GT person takes up a profession or job which others say would be good for them but is in fact against their best interests and contradictory to his or her entire set of abilities and temperament.

A GT person most likely will deliver excellent results and can often do so within a work environment which is wrong for them in the long term. But the cost will be in lost productivity and lost potential. The reward will be much greater GTs find work environments in which they can find that they can show their potential and demonstrate their personal productivity.
Chronic mismanagement is a real difficulty also for many GT adults in the modern workplace.

The first way in which a GT can be mismanaged is when the greater potential and productivity of the GT are disdained. A nonGT boss may have the belief that anyone can do what we can as fast as we can and with the same quality as we can -- the 'you're nothing special' jibe.

The other way in which a GT can be mismanaged is to attempt to make others do everything that the GT can. Unfortunately, they will all resent this tremendously. All attempts to clone me on and off the job have failed miserably -- thank goodness. The answer is rather to recognize the GT as an individual with his or her own unique potential, like everyone else in the department and organization. This is part of what I wanted to communicate in my previous post, Managing GTs in IT Organizations.

Technorati Tags: Gifted and Talented,IT Management,consulting,team development

Managing GTs in IT Organizations

2009-05-25T17:43:00.001-07:00

Here are a general set of guidelines that I put together. It appeared first on my personal blog, but here I reproduce it for the benefit of others who may have GTs in their departments and organizations.

GT is short for ‘Gifted and Talented.’ These are adults in the workforce who may or may not have been in a Gifted and Talented program during their schooling. They may or may not have received high grades when in school. They may or may not be members of Mensa. Generally, they score in the upper 2% of standard intelligence tests such as the Stanford Binet and also demonstrate multipotentiality (talent and accomplishment in multiple disciplines and areas). It’s more than simply being intelligent. And yes, I qualify as GT under the generally accepted criteria.

Information Technology often has more GTs than other areas of business. Unfortunately, many managers do not know much about how to manage a GT; it’s simply not covered in Organizational Behavior classes or texts on management techniques. Here’s what I came up with when I thought about what I would look for from a manager.

What most GTs need is simply good and fair management. This means management without negative effect on their natural productivity and creativity. If management provides this kind of environment, the GT can both shine individually, and make both the department and the manager look extremely impressive as well.

Recognize that a GT Person in Your Department Can Be a Substantial Asset

A manager can easily be threatened by abilities of many GTs. This may well be entirely unreasonable and more a measure of the insecurity of the manager than the actual intentions, conscious or unconscious, of the GT. Many GTs simply do not want management positions, since those positions would entail dealing with people more than they would like.
Seek to Build a Partnership with the GT Person

GTs will often be quirky people, but they have a surplus of creativity, intensity and understanding and often a very strong work ethic. The aim for a manager should be to build a partnership of mutual cooperation with the GT. An attempt to build a relationship of managerial domination will more often fail than not.
Practice Uniform and Fair Expectations for Performance, Promotion and Pay

One experience that GTs often have in both school and the workplace is a continually rising bar of expectations for them, often much greater than others theoretically at the same grade or job level. Unless there is a special job level especially for GTs (and antidiscrimination laws would not permit this), be fair in applying the corporate expectations for performance, promotion and pay to the GT as to the nonGT. In other words, it is simply discrimination to expect stronger performance from the GT to receive the same promotions and pay that a nonGT with the same responsibilities would receive.
Do Not Assign Them to Work with Underachievers to Bring Up the Performance of the Underachievers

Another experience that GTs often have in both school and the workplace is that they can be paired with the underachievers with the hope that they can bring up the performance of marginal students and employees. This is often quite counterproductive; the marginal employee may simply slack off even more, or even attempt to sabotage the joint effort once because the disparity in abilities simply smarts even more because of having to work with someone whom he or she may deeply resent and envy.
Foster an Atmosphere of and Be an Example of Professional Courtesy and Cooperation

Most companies have values statements which set forth standards of professional conduct. Review them, practice them, and hold others to them. Often these are enough, but unless these standards of professional conduct are followed, they are simply window dressing.
Retain Your Own Authority and Responsibility as Manager

Ultimately, the responsibility for the department is that of the manager. Allow the GT to lead, but do not abdicate authority. Retain and practice your right and responsibility to set the direction and standards of the department.
Provide Challenging Assignments Which Call for Creativity

GTs can be bored easily with routine work. This is one area where it may call for extra thought to provide these kinds of assignments, but the payback in retention of the GT will make it definitely worthwhile.
Accept and Encourage Lateral Leadership by GTs

Refer the GT to the book Getting It Done: How to Lead When You’re NOT in Charge(Roger Fisher and Alan Sharp, HarperCollins Publishers, New York 1999), for the concept and methodology of lateral leadership.
Recognize that GTs May Move Up and Onward More Rapidly Than Others

This may entail some 'going to bat' for the GT with Human Resources, if there is some track laid out for advancement which is too rigid in terms of timelines. The GT employee may actually be promotable more quickly than someone who takes longer to master the same skills. Thus the GT employee may not follow a timetable that was set for the advancement of nonGTs. The danger here is that the GT may become overqualified for his or her job level or responsibilities, and leave to find something else because the way of advancement is simply too slow.

Technorati Tags: IT Management,Gifted and Talented

Suggested Standards and Guidelines for Error and Exception Handling

2009-05-21T14:37:00.001-07:00

Here are a set of basic suggestions that I put together for a client for error and exception handling on a multitier ASP.NET project with Visual Studio 2008/ .NET 3.5 SP1.

Basic Needs for Error / Exception Handling

Flexible framework to log exception details in a way in which developers and support staff can find the information relevant to troubleshooting and fixing the problems.
Coding standard to establish a consistent method to provide user friendly error messages while avoiding disclosing implementation details as a security risk.

Framework /Library Alternatives:

Alternative 1: Microsoft Enterprise Library 4.1 Exception Handling Block

Targeted .NET Framework: 3.5 SP1

Advantages:

Free
Easy to use
Source code examples readily available
Logs information to a variety of destinations such as the event log, files or a database
Highly configurable
Comes with configuration utility
Externally maintained by Microsoft Patterns and Practices Team
Documented and packaged with other Enterprise Library components
Documentation integrated with Visual Studio / MSDN documentation
Specifically targeted for the .NET 3.5 SP1 platform
Incorporates additional functionality for WCF error handling and logging (note the section in the Enterprise Library documentation, ‘Integrating the Logging Application Block with WCF Applications’)
Able to customize
Familiar to many .NET developers

Disadvantages:

Requires some experimentation and prototyping to understand its functionality.

Alternative 2: Log4Net:

Targeted .NET Framework: 2.0

Advantages:

Free
Easy to use
Logs information to a variety of destinations
Highly configurable
Source code examples readily available
Externally maintained by open source community
Able to customize
Familiar to many .NET developers

Disadvantages:

Targets earlier version of the framework
Does not incorporate additional functionality for WCF error handling and logging
No configuration utility

Alternative 3: Internally developed component(s):

Advantages:

Primarily when necessary to meet any internal standards which cannot be met with a free or open source framework.
Internal code maintenance not at the mercy of external corporations or developers.

Disadvantages:

· Cost in time and money for internal development and maintenance

· Learning curve for new hires and external resources

· May reflect personal preferences and “blind spots” of internal developers

· May open up security holes unless carefully reviewed

· May not be transferable to later projects

Suggested common sense coding standards for exception and error handling:

Avoid ‘eating exceptions’ (catching an exception in an empty block):

try

{

// my cool code goes here

}

catch{} // I can’t find out or fix what happens here in production

// errors may still propagate up the call stack and the user

// may have a mysterious failure to deal with

Use a ‘finally { } ‘ or a ‘using . . . { } ‘ block to dispose of unmanaged resources when an exception occurs.
Log exceptions where possible, especially if the error condition indicates a network, database or file I/O problem.
Log exception information such as the call stack and any associated input data along with user information.
Throw exceptions to indicate error conditions rather than returning error codes, since error codes are rarely documented well enough for future maintenance and troubleshooting.
Return null rather than throwing an exception if an expected object cannot be returned from a method, since testing for null in an if statement is usually less expensive than handling exceptions.
Do not use exceptions for control flow. Check for null and error conditions with if and switch statements rather than throwing or catching exceptions.
Use correct exception classes for throwing exceptions, such as ArgumentNullException if a null reference is passed as a parameter to a method and ArgumentException if a parameter passed to a method is otherwise invalid.
Include information in any exceptions thrown to indicate the cause and correction for the exception.
Derive new exception classes from System.Exception. Microsoft has deprecated the previously recommended practice of deriving new exception classes from System.ApplicationException.
Error messages displayed to the user should suggest a possible correction if possible.
Seek to return the application after an exception to a state where the user can continue or correct his or her previous action rather than force the user to start all over again.
Use standard validation techniques as much as possible to correct user input rather than throwing exceptions.
Incorporate a generic exception handling method in base classes that performs the standard method of handling and logging exceptions, such as a in a base web page or master page class.
Incorporate an exception building method that returns the desired exception in classes which throw exceptions.
Provoke exceptions during unit, integration and system testing to determine application security and robustness.
For web pages, include error and exception handling in client side Javascript so that it ‘fails gracefully’ if something undesirable happens.

Recommendations:

Implement the Exception Handling Block of Enterprise Library 4.1, and establish Exception Handling Policies for DataAccessExceptions, SqlExceptions, SecurityExceptions, WCF FaultExceptions and WCF CommunicationExceptions. If the Enterprise Library Validation Block is used, add an exception policy also for ValidationException.
Consider logging error information to a centralized store. The alternatives with the Enterprise Library are to use the Database Trace Listener to log error information to a database or the MSMQ Trace Listener with the MSMQ Distributor Service with the Logging Application Block to log error information to a central store through an MSMQ queue. Log4Net contains database logging functionality.
If the Enterprise Library Database Trace Listener is used, add an event listener for the event log or a flat file, and, optionally, an email listener for the Logging Errors and Warnings category under special sources to catch any errors that cannot be logged to the database.
Establish coding standards for exception handling at each tier / layer of the application.
Consider deriving application specific exception classes to wrap exceptions that get thrown. Examples: MyAppException, MyAppFaultException (for WCF errors), and MyAppClientException(for ASP.NET errors). These could be used for specific exception handling routines.
Document the error logging method and location of error information for ongoing application maintenance and support staff.
Consider using an exception handling and logging library that can send notifications through email to maintenance and support staff for severe errors. Both Enterprise Library and Log4Net contain this functionality. Homegrown logging solutions sometimes expose too much email functionality, however.
Avoid internal development, maintenance and customization of exception handling and logging libraries unless the need is overwhelming.
Provide a method to handle and log all uncaught exceptions at the ASP.NET and WCF levels. Handle the Application_Error event in Global.asax for ASP.NET pages and implement IErrorHandler at the WCF level. The ASP.NET error page should display a user friendly explanation of what happened.

Technorati Tags: Enterprise Library,Log4Net,Exception,Exception Handling,Error Handling,Coding Standards