U.S. Patent and Trademark Office (USPTO) recently granted Microsoft a patent on a “personalized version” of the sudo command with GUI. Sudo is a command that has been in use since 1980′s or even before by Unix and other operating systems to allow running other commands with elevated privileges. For one, why would Microsoft try to patent something like this? Secondly, does USPTO grant patents on anything you ask them for?

We are witnessing a time in the history of technology when there is more free (open source or otherwise) software available than anyone ever cares to know, and it’s increasing at a higher rate than anyone can even keep track of. For any application that one can conceivably imagine, chances are that there is a free alternative out there. Why in the world then a company such as Microsoft would patent tiny things such as sudo commands, especially when they “borrowed” the original idea from elsewhere anyway? On one hand we see companies like Google releasing entire programming languages into open source, and on the other hand companies like Microsoft acquiring patents on simple sudo commands… we live in truly amazing times don’t we!

Groklaw has much more detailed information on this story. You can also find the original Microsoft patent at the USPTO here.

The latest beta version of FxCop 1.36 was recently made available for download. This new version includes various features and fixes that include:

• 200+ bug fixes that reduce noise, missing analysis and rule crashes
• Support for analyzing anonymous methods and lambda expressions
• New option for skipping analysis over tool generated code
• Better support for C++/CLI and the Compact Framework
• Language ‘friendly’ API names in the UI and resolutions
• New globalization, design and usage rules
• Performance improvements that cut analysis by 2x and use half as much memory
• Documentation that is now available on MSDN

FxCop is an excellent free static code analysis tool from Microsoft that checks .NET managed code assemblies for conformance to Microsoft’s .NET Framework Design Guidelines.

To alleviate some of the pain, Microsoft finally came up with a Windows Installer Cleanup Utility, that can be used to remove all references to a given application from your system. This utility just saved me a few hours worth of work when Installer refused to uninstall a given application from my system so that I could install a newer version. Without this utility I would have had to go through and search my registry for all references to the application and remove them by manually hand. Then, if I was lucky, I would be allowed to install the newer version of the application. With this utility I removed the application from my system in seconds and painlessly installed the newer version after that.

After the popularity of Logo (Turtle Graphics) in the 80′s, the Massachusetts Institute of Technology (MIT) has once again come up with a new programming language for kids called Scratch. Scratch teaches kids skills necessary to become future technology professionals, such as creative thinking, clear communication, systematic analysis, iterative design, and continuous learning, while they create fun and interesting projects such as interactive stories, graphic animations, games, music, and art. Projects created with Scratch can be shared on the web with others.

In addition to home, Scratch can be used by schools, museums, community centers, or other group settings. While the tool is intended for 8 to 16-year olds, with some adult help it can definitely be used by younger children.

Scratch is available for both Windows and Mac platforms, and is available as a free download.

JavaScript and JScript languages provide a convenient Eval method that allows for dynamic evaluation of expressions. This functionality can be duplicated in C# using Microsoft’s JScript CodeDomProvider and Reflection.

Following class automatically compiles an in-memory assembly using JScript CodeDomProvider. The Eval method uses this assembly to dynamically evaluate specified expressions:

using System;
using System.CodeDom.Compiler;
using System.Reflection;
using Microsoft.JScript;

///
/// Implements JScript/JavaScript Eval like
/// functionality in C# to allow dynamic evaluation
/// of expressions.
///
public static class ExpressionEvaluator
{
    #region Private Members

    private static Type _evaluatorType;
    private static object _evaluatorInstance;
    private static readonly string _jscriptEvalClass =
    @"import System;
class JScriptEvaluator
{
public static function Eval(expression : String) : String
{
return eval(expression);
}
}";

    #endregion

    #region Private Methods

    ///
    /// Creates a dynamic in-memory assembly using JScript.NET
    /// to evaluate expressions.
    ///
    private static void Initialize()
    {

        CodeDomProvider compiler = new JScriptCodeProvider();

        CompilerParameters parameters = new CompilerParameters();
        parameters.GenerateInMemory = true;
        parameters.ReferencedAssemblies.Add("system.dll");

        CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptEvalClass);

        Assembly assembly = results.CompiledAssembly;
        _evaluatorType = assembly.GetType("JScriptEvaluator");
        _evaluatorInstance = Activator.CreateInstance(_evaluatorType);
    }

    #endregion

    #region Public Methods

    ///
    /// Evaluates specified expression using reflection
    /// on the assembly generated in Initialize() method.
    ///
    /// The expression.
    /// A string representing evaluated expression.
    public static string Eval(string expression)
    {
        if (_evaluatorInstance == null)
            Initialize();

        object result = _evaluatorType.InvokeMember(
        "Eval",
       BindingFlags.InvokeMethod,
        null,
       _evaluatorInstance,
        new object[] { expression }
       );

        return (result == null) ? null : result.ToString();

    }

    #endregion
}

Using this class, we can execute statements such as:

        Console.WriteLine(ExpressionEvaluator.Eval("2 + 9"));
        Console.WriteLine(ExpressionEvaluator.Eval("System.DateTime"));
        Console.WriteLine(ExpressionEvaluator.Eval("Environment.OSVersion.VersionString"));