Asim Jalis: Programming Notes

CSBat: The C# Interpreter

asimj — Sat, 21 Jan 2006 04:55:00 GMT

Just to try out this idea I wrote out CSBat.cs, which allows C# code in bat and cmd files.

Here is the problem this solves: Frequently I just want to write a short C# snippet. I don't want to write it as a source file, compile it, and run it. I'd rather just put the snippet in a bat file and run the bat file. I want to shorten the code-compile-execute loop to just code-execute. CSBat solves this problem. (Note: The in-memory compiler code was taken from Don Box's CSRepl from his blog. Also you will need the Whidbey 2.0 runtime to play with this sample.)

Here is how to use the sample:

Save the hello.cmd code below into hello.cmd
Save the csbat.cs code into csbat.cs
Type: csc.exe csbat.cs /r:System.dll
Type: hello.cmd
The hello.cmd script should print "Hello...". Now edit the script and run it again. It should run with the changes.

Here are the contents of hello.cmd:

@echo off
csbat.exe Chk %~f0 %*
goto :EOF

#! -*- csharp script start -*-

using System;
public class Chk
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello world from CSBat.");
        Console.WriteLine("Argument count was: " + args.Length);
        foreach (string arg in args)
        {
            Console.WriteLine("arg = " + arg);
        }
    }
}

Here are the contents of csbat.cs:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;

namespace CSBat
{
    class Program
    {
        static string Eval(string program, string className, string[] args)
        {
            ICodeCompiler compiler = CodeDomProvider.CreateProvider("C#").CreateCompiler();
            CompilerParameters cp = new CompilerParameters();
            cp.GenerateExecutable = false;
            cp.GenerateInMemory = true;

            CompilerResults results = compiler.CompileAssemblyFromSource(cp, program);
            if (results.Errors.HasErrors)
            {
                throw new ApplicationException(results.Errors[0].ErrorText);
            }
            else
            {
                Assembly assembly = results.CompiledAssembly;
                Type target = assembly.GetType(className);
                MethodInfo method = target.GetMethod("Main");
                object[] parameters = new object[]{ args };
                object result = method.Invoke(null, parameters);
                return result == null ? null : result.ToString();
            }
        }

        static void Main(string[] args)
        {
            try
            {
                if (args.Length < 2) { throw new ArgumentException("Usage: csbat CLASS FILE ARGS"); }
                string className = args[0];
                string filePath = args[1];
                List<string> argList = new List<string>(args);
                argList.RemoveAt(0);
                argList.RemoveAt(0);
                args = argList.ToArray();
                string fileContents = File.ReadAllText(filePath);
                fileContents =
                    Regex.Replace(fileContents, "^.*?\n#![^\n]*csharp script[^\n]*\n", "", RegexOptions.Singleline);
                string result = Eval(fileContents, className, args);
            }
            catch(Exception e)
            {
                Console.WriteLine("Error: " + e.Message);
            }
            return;
        }
    }
}

Use CLR Profiler for C# Call Graphs and Optimization

asimj — Thu, 02 Dec 2004 01:56:00 GMT

I recently had the need to debug some code and was looking for an easy way to generate the call graph of the application. For a given function I wanted to see who its callers were and who the callers of the callers were, etc. Turns out Microsoft has a free tool called the CLR Profiler that does precisely this. Here is how to use it:

Download and run the executable from this URL.
Click on "Start" and select "Run".
Type C:\CLR Profiler\Binaries and click "OK".
Click on ClrProfiler.exe.
Click on "Start Application".
Select the application you want to analyze.
Then click on "Kill Application".
To view the call graph click on View and select "Call Graph".

This can also be used to profile the program and to improve and optimize its performance. Also it works with ASP.NET applications. Overall, an extremely cool application.

Ward Cunningham on Simplicity

asimj — Wed, 24 Nov 2004 05:08:00 GMT

Ward Cunningham has some interesting comments about simplicity in his interview with Bill Venners. Here is a link. Here is an excerpt:

A friend of mine once said that there are problems and there are difficulties. A problem is something you savor. You say, "Well that's an interesting problem. Let me think about that problem a while." You enjoy thinking about it, because when you find the solution to the problem, it's enlightening.
And then there are difficulties. Computers are famous for difficulties. A difficulty is just a blockage from progress. You have to try a lot of things. When you finally find what works, it doesn't tell you a thing. It won't be the same tomorrow. Getting the computer to work is so often dealing with difficulties.
The complexity that we despise is the complexity that leads to difficulty. It isn't the complexity that raises problems. There is a lot of complexity in the world. The world is complex. That complexity is beautiful. I love trying to understand how things work. But that's because there's something to be learned from mastering that complexity.

Password Managers

asimj — Wed, 24 Nov 2004 05:04:00 GMT

Here are some neat password manager products:

Microsoft's Fingerprint Reader: Microsoft now has a cool hardware-based password manager, that uses your thumb print to figure out who you are and then automatically types in your internet passwords. This addresses the two big problems with passwords: (a) writing passwords on paper is unsafe -- someone else might see them, (b) remembering lots of passwords is hard.

Keith Brown's .NET Password Manager: If you prefer a software password manager, Keith's program is an option. Note: the program requires the .NET framework. At the bottom of Keith's article is a link to a password manager that does not require the .NET framework.

Adam Bosworth on Simplicity

asimj — Tue, 23 Nov 2004 01:32:00 GMT

Here is a talk by Adam Bosworth on software simplicity. His assertion is that simple sloppy systems with weak rules are more likely to be useful in unforeseen scenarios and therefore are more likely to succeed in unexpected ways than systems with strong rules.

Learning to Fly in Halo2

asimj — Tue, 23 Nov 2004 00:16:00 GMT

Here is a video demo on the experience of flying in Halo2.

Free Visual Studio and SQL Server Downloads

asimj — Mon, 01 Nov 2004 23:07:00 GMT

You can now download free beta versions of Visual Studio. Here is a link to the Visual C# Express Edition Beta. Here is the link to all the Express Edition products (Visual Basic, C++, J#, etc). Also while you are at it you can also grab the free SQL Server Express Edition Beta.

Lunar Eclipse Video

asimj — Mon, 01 Nov 2004 22:59:00 GMT

John Archer has made a really neat time lapse video of the recent lunar eclipse using Microsoft Movie Maker 2. Click here to see it.

Sometimes Barney Appears on the Screen and Sometimes He Doesn't

asimj — Mon, 01 Nov 2004 22:36:00 GMT

Another humorous KB (knowledge base) whitepaper; this one's on Barney.

The Crabby Lady Is For Real

asimj — Mon, 01 Nov 2004 22:33:00 GMT

See videos of the Crabby Lady taking on reader's comments about Microsoft Office tools.

Visual Studio and .NET Framework Feedback

asimj — Mon, 01 Nov 2004 22:32:00 GMT

The Developer Division now accepts direct feedback (feature suggestions, bugs) about VS (Visual Studio), the .NET framework, and other developer tools, here on their LadyBug site.

Literate Programming and XP

asimj — Thu, 02 Sep 2004 05:37:00 GMT

I recently read Don Knuth's "Literate Programming". It seems to me that a lot of writing on the web ignores the main point of literate programming. The main point is not to mix comments and code. That is pretty easy to do in most languages.

What Don is really talking about is how to lay out your program so that it's layout matches the way we think rather than the way a compiler works.

When I write a program (when I am not using XP and when I am not pairing) I spend some time writing notes to myself, reflecting on the program, and exploring what different parts of it will do. The final product is still vague. I am just getting a feel for the conceptual space around the program. I am also trying to poke around my understanding of the problem I am trying to solve. My notes consist of a lot of English, some of it transformed into pseudo-code, and some of this translated into actual code. It also contains data definitions.

Eventually when I have a reasonable grip on what needs to be done I start coding. At this point I throw away all my notes.

Don is proposing a system in which I can run my notes through a pre-compiler (which he calls WEB) to produce my program. This way the notes stay connected to the code.

In these notes the flow of reasoning is neither top-down nor bottom-up. In fact it bounces around between components -- like a web. Each time I pin down a detail on one side I have to come back and talk about how this will impact other decisions in other components. So its a winding iterative process.

Compilers do not permit this kind of flimsiness. The require that you talk about one thing at a time. They cannot talk about something else for a while and then come back to the original point. Compilers can only follow one train of thought at a time. They have tunnel vision. They are incapable of taking a global view of the system. They are focused on getting the job done and if you leave out the smallest detail or try to change the subject midstream in the conversation they completely freak out.

The ability to add comments does not change this basic fact about how compilers expect code to be laid out. You are only allowed to talk about one thing at a time. And once you start talking about a class you cannot change the subject till you have said everything there is to be said about the class.

In my mind Literate Programming is a way to get around this incompatibility in thinking. I don't know how well Don's system does this job. But whether he succeeds or not, it seems like a worthwhile goal to make the layout of computer code more compatible with the way we (humans) think, explain things to each other and understand new things.