A few days ago, one of our remote Citrix workstation users reported a login issue. Here was the error message displayed on the client interface.

“Your account is configured to prevent you from using this computer.”

To fix the issue, I confidently used the “tried and true” procedure described below. At the same time, I was “showing” someone else how to address the issue. I was quite surprised when the procedure didn’t work. The registry key values were not displaying in the right pane. The only thing showing up was the tree structure, no data. After awhile, I realized the regedt32 editor was not set to “View->Tree and Data”; it was only set for “View->Tree” structure. After making the trivial adjustment, we ran through the procedure without incident.

Here is the procedure – Source: MS Help and Support

Part 1: Disable the Security Policy
Disable the following Group Policy setting on either the default domain or the domain controller organizational unit:
Computer Configuration\Windows Settings\Security Settings\Local Policies\Security Options\Shut down your system immediately if unable to log security audits
You can find this policy on the default domain policy, default domain controller policy, and local security policy.

Note: After you disable the security policy, you must also remove the security policy registry key.

Back to the top
Part 2: Edit the CrashOnAuditFail Registry Key
1. Click Start, and then click Run.
2. In the Open box, type regedt32.exe, and then click OK.
3. Click the following registry key:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa\CrashOnAuditFail
4. In the right pane, double-click CrashOnAuditFail.
5. In the Value data box, type 0 (zero), and then click OK.
6. Click Start, and then click Run.
7. In the Open box, type secedit /refreshpolicy machine_policy /enforce, and then click OK to apply the new security setting.
8. Restart your server.

There is a job description you may never have heard of, but if you are a savvy IT executive, it may be a job you need to fill in your organization. Roberta J. Witty, a Gartner Inc. research vice president, recommends that firms consider retaining a business continuity manager–someone who creates plans to keep a company functioning after disruptive events such as natural disasters, terrorism, crime, and computer and human error.

According to Witty, such an employee would do a company-wide business impact analysis and risk assessment that includes IT systems, building facilities, personnel and supply chain. She and other experts say that some organizations must, under federal regulations, conduct a comprehensive business impact analysis, and draft detailed business continuity plans. In addition, they note, being unprepared for a major disruption is bad for business.

For more:
- see this Computerworld.com article

Being a huge C/C++ fan, I had a really hard time switching to AS3 and giving up most of C++’s power features as enumerations.

I was surprised that a programming language that is based on Java and C# doesn’t support native enumerations built in the language. After a quick look-up at various Google searches, turns out no one has implemented a type-safe assignable enumerations design pattern in AS3. The various code examples I’ve seen were either not type safe or not assignable (using the enumerations as ‘global’ consts). Since those were not the behaviors I wanted, I had to write my own.

One major problem I was facing was how to shadow the data of the enumerations, just like C++ does (although in C++ they could be used as integers as well). Using integers was out of the question and using strings would be more of a resource hog than helper.

The solution is recursive declaration – declare a class, which has itself on the inside using recursive constructor (a constructor that receives ‘itself’, much like copy constructor in C++).

This may sound crazy, but it actually works – Flash IDE does not complain and the result is a type-safe assignable type that you can only assign a set of specific values to.

This following code is an example of a ‘Direction’ enumeration written in AS3 and I can’t see any reason why not use it, this simple structure enables you to:

• Declare a class typed ‘Direction’
• Set the declared variable to a specific set of values predefined in the class
• Check and compare the variable (using either a boolean condition or a switch statement) to the predefined set of values
• Shadowing of the values to an abstract data, meaning that unlike C++, you cannot preform arithmetic operations on it

And here is the code, commented:

package
{
	class Direction
	{
		/*
		 * The actual enumeration values. Note that the sorting order doesn't matter.
		 */
		public static const NONE:Direction	= new Direction(NONE);
		public static const UP  irection	= new Direction(UP);
		public static const DOWN  irection	= new Direction(DOWN);
		public static const LEFT  irection	= new Direction(LEFT);
		public static const RIGHT  irection	= new Direction(RIGHT);
 
		/* Constructor */
		public function Direction(d:Direction)
		{
			/*
			 * Empty fake constructor
			 * The part that matter is that it accepts a 'copy' of itself
			 * For the recursive assignment to work
			 */
		}
	}
}

The reason the above code uses the ‘recursive’ constructor structure, is to ensure type safety. When assigning a new Direction type, only the above predefined list of values can be assigned. Another reason is, when you declare a function that takes a direction, you eliminate the possibility to invoke the function with ‘new Direction()’ as an argument and passing an undefined value (Direction.NONE should be used for that).

The constructor only requires one argument, which is typed as Direction as well, eliminating any possible casts to another type, shadowing the actual data (a reference to self) inside the class, making it a true type safe implementation.

Since in AS3, everything must be an object (a class), this leads to some interesting options, such as ‘helper functions’ which could be embedded inside the ‘enum’ itself, for example, the Java-like ‘toString’ function, could be easily implemented inside the Direction class as:

public function toString()
{
	switch(this) {
		case Direction.UP:
			return "Up";
		case Direction.DOWN:
			return "Down";
		case Direction.LEFT:
			return "Left";
		case Direction.RIGHT:
			return "Right";
		default:
			/* Direction.NONE is considered 'undefined' (no direction) */
			return "undefined";
	}
}

Now you can do anything an enueration was designed to do:

var dir:Direction = Direction.UP;	// Legal, Direction.UP is valid.
dir = 0;				// Illegal, '0' is not in the predefined set of values
trace(dir.toString());			// Will print 'Up' if above method is used

There you have it – a type safe assignable enumeration implementation in AS3.

Today is System Administrator Appreciation Day. As SysAdminDay puts it, it is a thankless job for 364 days. You do not receive a lot of attention when things are going well. But when things do go wrong, you do, in deed, receive a lot attention – the type that spikes your stress level. You routinely get those dreaded calls between 12 am and 4 am or on your days off: “I need YOU to come in ASAP!” A lot of people will say that SysAdmins can just work from home. I wish. You can be rest assured that is not always the case or even possible (depending on the type of work).

By the way, you are reading this post because some underappreciated system administrator at Blogger is taking care of the “behind the scenes” activities – Thank you Mr/Ms. SysAd @Blogger.

But when it is all said and done for me, being a SysAdmin is one of the best darn occupations in the world. Frankly speaking, I really can not think of a more interesting profession.

By the way, today, we lost an inspirational leader in the field of computing: Dr. Randy Pausch, “Last Lecture Professor,” 1960-2008

How do you predict demand from your distributors? Would you try demand simulation, predictive analytics, or a complex mathematical model? Try experimental economics. Wired points us to a story (found via Techdirt) of Kay-Yut Chen who is an experimental economist at HP solving the complex demand forecast problems.

One of Chen’s recent projects involved finding a way for H.P. to more accurately predict demand from its nine distributors, who collectively sell as much as $3 billion worth of H.P.’s products. The problem? Its distributors’ forecasts for demand were frequently off by as much as 100 percent, wreaking havoc on H.P.’s production planning.

Chen’s solution to the planning problem, which H.P. intends to test soon with one distributor, was to develop an incentive system that rewarded distributors for sticking to their forecasts by turning those forecasts into purchase commitments. In the lab, the overlap between distributors’ forecasts and their actual orders using this system increased to as high as 80 percent. “That’s pretty astonishing given that the underlying demand is completely random,” Chen says.

The human beings are terrible at making rational decisions and the complex problems such as demand forecast cannot really be solved by complex modeling algorithms or predictive analytics. Applying the economics of incentives to such problems is likely to yield better results. Freakonomics explains the creative use of economics of incentives in great depth. Dan Ariely writes in Predictably Irrational about people predictably making irrational decisions and how it breaks the rules of traditional economics and free markets that are purely based on demand and supply ignoring the human irrationality.

There is a lesson for an enterprise software vendor to design human-centric software that supports human beings in complex decision management process. Good news is that I do see the enterprise software converging towards social computing. Topics such as security that have been considered highly technical are being examined with a human behavior lens ranging from cognitive psychology to anthropology of religion.

I would welcome a range of tools that could help experimental economics gain popularity and dominance in the mainstream business. For instance behavior-based AB testing can be set up in a lab to test out hypothesis based on experimental economics and the results of the experiment could be directly fed to a tool that reconfigures an application or a website in real-time.