Darrell Hawley: Home Page

Note to Self 10 – JQuery Selectors and Custom Functions and a thought on JQuery

2009-06-28T09:01:00.001-07:00

After using Python, diving into jQuery has proven exceptionally difficult. Even though it solves the not-so-small problem of commonizing the DOM across multiple browsers, I find it very difficult to read. I know with time I’ll get used to it and maybe even find some beauty in my jQuery code, but it will never stop me from wishing for a cleaner syntax like that of Python or Ruby.

With that said, here’s a bit of what I learned about jQuery recently.

Selectors in jQuery are a syntax for selecting an html element. Selectors can return a single element or several (or none if nothing matching is found).
$(“#[elementID]”) – finds an element with an id attribute equal to “elementID”.
$(“[name=’elementName’]”) – gets all elements with a name attribute equal to “elementName”
$(“[name^=’element’]”) – gets all elements with a name attribute that begins with “element”
$(“[name$=’Name’]”) – gets all elements with a name attribute that ends with “Name”
$(“input:checkbox”) – gets all checkboxes
$(“#blah > input:checkbox”) – gets all checkboxes within a parent element of id “blah”
Creating a custom function in jQuery:

$.fn.CustomFunctionName({function()({
//code here
})

$.fn.exclaim = function(message){
alert(message)
}
$.fn.exclaim("hello, world")

Note to Self 9 – Exploring SharpDevelop and Going off Topic

2009-05-29T07:05:00.001-07:00

It’s been too long since I last blogged which typically means I have too many competing ideas to settle on just one. So welcome to Note to Self 9!

SharpDevelop is an open source IDE for the .NET platform. Is it new? Hardly. Based on the history of news releases from their website, It’s been around since December of 2000. Considering that the .NET platform was publicly announced only 6 months earlier, SharpDevelop seems only that much more mature.
If you’re comfortable with the basics of Visual Studio, SharpDevelop should feel like home to you. In fact, the best way to describe SharpDevelop is “Visual Studio without a lot of stuff I don’t want and a few thid-party items I do”.
SharpDevelop uses NUnit instead of MSTest. That’s right. No third party plugins to make your IDE work with NUnit. It simply works.
It’s time for me to confess. It’s all about IronPython. The reason I started investigating SharpDevelop is because of my frustration with Visual Studio’s lack of support for the language. Specifically, I want Intellisense when I write IronPython. To be sure, you only get Intellisense for “non-DLR code”, but surprisingly that doesn’t seem to be as much of a handicap as you might think.
Speaking of first class citizens, SharpDevelop comes stock with C#, Visual Basic, Boo (I can hear Jay Wren cheering now), IronPython and F# (now a number of SRT folks are cheering).
If you’re frightened of the consequences that may come from changing your development environment, don’t be. You can open one of your existing Visual Studio solutions with SharpDevelop and start coding. Switching back is as simple as opening up your now modified project/solution in Visual Studio.
For clarity, SharpDevelop is new to me. I haven’t used SharpDevelop for any projects yet so I can’t tell you about any of its nuances. I plan on putting it to the test, however, over the next several weeks. I’ll be posting about my experiences.
Now for the off-topic part. I’ve been listening to The History of Rome, a FANTASTIC podcast series on, well, the history of Rome. Mike Duncan, creator and narrator, is not only an engaging story teller, but also has the technical savvy to put together a professional podcast. Though it’s not the sort of podcast typically on a geek’s menu, I think there are enough parallels to some of the challenges we are facing in the software industry to make it worthwhile.

Anatomy of an IronPython Application at AADND

2009-04-07T20:00:00.001-07:00

I'm going to be talking IronPython at the Ann Arbor .NET Developers Group at SRT Solutions tomorrow night (April 8) at 6:00. I'll be showing you how you might introduce IronPython into your existing .NET environment through a lot of sample code and very few PowerPoint slides. I hope to see you there.

Anatomy of an IronPython Application

You've heard about IronPython and maybe have even taken the time to write the obligatory "Hello, World" application. Now what? The buzz around IronPython continues but there's still little guidance on tools and development processes. This presentation focuses on the basics of interacting with C# and VB.NET libraries using IronPython while introducing useful tools and techniques to get you started. Though experience with .NET is necessary, the samples and discussions are understandable to even beginning Python developers.

Writing an IronPython WCF Host

2009-03-15T06:19:00.001-07:00

This is a simple WCF host written in IronPython that consumes a library I wrote in C#.

import clr
clr.AddReferenceByPartialName("System.ServiceModel")
clr.AddReferenceByPartialName("CSharpClass")

from System.ServiceModel import ServiceHost, BasicHttpBinding
from System.ServiceModel.Description import ServiceMetadataBehavior
from CSharpClass import PersonService, IPersonService
from System import Array, Uri

uri = Uri("http://localhost:1234/people")
uriArray = Array[Uri]([uri]) # creates a generic array of type Uri
serviceHost = ServiceHost(PersonService, uriArray)

binding = BasicHttpBinding()

serviceHost.AddServiceEndpoint(IPersonService, binding, "http://localhost:1234/people")

behavior = ServiceMetadataBehavior()
behavior.HttpGetEnabled = True
serviceHost.Description.Behaviors.Add(behavior)

serviceHost.Open()

raw_input("Service has been started. Press Enter to exit...")

Running nose with IronPython

2009-03-06T11:28:00.001-08:00

I just spent the past week at the 2009 Microsoft MVP Summit where I got a chance to talk to the some of the crew behind the dynamic languages at Microsoft. When I mentioned that I had gotten nose, a Python unit testing framework, working with IronPython, I was strongly encouraged to blog about it. Without further adieu, here's my code.

import sys
sys.path.append(r"C:\Python25\Lib\site-packages\nose-0.10.4-py2.5.egg")
sys.path.append(r"C:\python25\lib")
sys.path.append(r"C:\Python25\Lib\email")
sys.path.append(r"C:\Python25\Scripts")
import nose
nose.main()

I dropped this script into a directory with a couple of bogus unit tests and ran it with Python 2.5.4. Results were consistent with my expectations - successful tests passed and failing tests threw exceptions. When I ran the same suite against IronPython 2.0.0, I still received the correct results but the script took 1 minute and 20 seconds to complete. Compare that to less than a second (estimated) for CPython. For the sake of completeness, I ran the same test with IronPython 2.0.1 and received the same result.

The root of the problem appears to be the large number of GeneratorExitExceptions being thrown. I'm not sure why they're being thrown, but I'll continue to investigate and report my findings. If you're interested in the gory details, here's the stack trace of the first exception:

at IronPython.Runtime.PythonGenerator.ThrowThrowable()
at IronPython.Runtime.PythonGenerator.CheckThrowable()
at IronPython.Runtime.PythonGenerator.
CheckThrowableAndReturnSendValue()
at IronPython.Runtime.Operations.PythonOps.
GeneratorCheckThrowableAndReturnSendValue(Object self)
at S$11.lambda_method$312(Closure , Int32& state, Object& current) in C:\python25\lib\types.py:line 52
at Microsoft.Scripting.Runtime.GeneratorEnumerator`1.
System.Collections.IEnumerator.MoveNext()
at IronPython.Runtime.PythonGenerator.MoveNextWorker()
at IronPython.Runtime.PythonGenerator.System.
Collections.IEnumerator.MoveNext()
at IronPython.Runtime.PythonGenerator.throw(Object type, Object value, Object traceback)
at IronPython.Runtime.PythonGenerator.throw(Object type)
at IronPython.Runtime.PythonGenerator.close()

IronPython Exception: [A]Person cannot be cast to [B]Person

2009-02-20T12:54:00.001-08:00

Had an interesting problem while using the Hosting API the other day. Here's the exception message.

[A]CSharpClass.Person cannot be cast to [B]CSharpClass.Person. Type A originates from 'CSharpClass, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' in the context 'LoadNeither' at location '[project directory]\bin\Debug\CSharpClass.dll'. Type B originates from 'CSharpClass, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' in the context 'Default' at location '[temp directory]\CSharpClass.DLL'.

I was struggling with this for a while until I found this link. In order to get my IronPython scripts to communicate with my CLR-based code, I was using the clr module's AddReference methods. These methods require you to point at the appropriate copy of the library you want to consume. I do stress "copy". Let's say you point your IronPython script at the bin\debug folder of a C# library project you're consuming in a console application. When you run the application, you'll get the exception message above. To make this example work, you'd have to point your IronPython script at the bin\Debug folder of your console application instead. Clearly, this is a maintenance nightmare. Instead, insert the following chunk of code into your hosting application (in the example described above, your console application) to avoid the problem all together.

Assembly assembly = typeof (CSharpClass.Person).Assembly;
runtime.LoadAssembly(assembly);

Note to Self 8 - IronPython2, Hosting, DLR

2009-02-04T19:03:00.001-08:00

The latest DLR code and documentation can be found at www.codeplex.com/dlr
For the examples below, here is the Python script I'm using

class Person(object):
    def __init__(self, name, phone):
        self.name = name
        self.phone = phone
    def TalkToCSharp(self):
        val = {"name":self.name, "phone":self.phone}
        return val

def GetPerson():
    person = Person("darrell", "555-4321")
    return person.TalkToCSharp()

def GetPersonWithParams(name, phone):
    person = Person(name, phone)
    return person.TalkToCSharp()

theNumberFive = 5
myPerson = GetPerson()

Simplest thing you can do is execute a Python script.

static void ExecutePythonScript(string path)
{
ScriptRuntime runtime = Python.CreateRuntime();
runtime.ExecuteFile(path);
}

Sometimes you need to get a variable after a script has run.

static void GetDoubleVariable(string path)
{
    ScriptRuntime runtime = Python.CreateRuntime();
    ScriptScope scope = runtime.ExecuteFile(path);
    object x = scope.GetVariable("theNumberFive");
    Console.WriteLine(x);
}

What happens if you're trying to return a custom class defined in the script? The easiest - and IMHO the best - way to go about this is to convert the object to a dictionary before passing it to your C# code.

static void GetInstanceCustomClass(string path)
{
    ScriptRuntime runtime = Python.CreateRuntime();
    ScriptScope scope = runtime.ExecuteFile(path);
    PythonDictionary dictionary =
        scope.GetVariable("myPerson")
        as PythonDictionary;
    foreach (var property in dictionary)
        Console.WriteLine(property.Key +
            " == " + property.Value);
}

Getting properties is definitely useful, but you'll probably want to call a function.

static void CallingAFunction(string path)
{
    ScriptRuntime runtime = Python.CreateRuntime();
    ScriptScope scope = runtime.ExecuteFile(path);
    ObjectOperations op =
        scope.Engine.CreateOperations();
    ObjectHandle handle =
        scope.GetVariableHandle("GetPerson");
    var x = op.Call(handle, new object[0]);
    PythonDictionary dictionary =
        x.Unwrap() as PythonDictionary;
    foreach (var property in dictionary)
        Console.WriteLine(property.Key +
            " == " + property.Value);
}

Here's an example of passing parameters to a Python function.

static void CallingAFunctionWithParameters(string path)
{
    ScriptRuntime runtime = Python.CreateRuntime();
    ScriptScope scope = runtime.ExecuteFile(path);
    ObjectOperations op =
        scope.Engine.CreateOperations();
    ObjectHandle handle =
        scope.GetVariableHandle("GetPersonWithParams");
    var x = op.Call(handle, "Larry", "555-1234");
    PythonDictionary dictionary =
        x.Unwrap() as PythonDictionary;
    foreach (var property in dictionary)
        Console.WriteLine(property.Key +
            " == " + property.Value);
}

Note to Self 7 - Naming Python Modules, SciTE, IronPython and name

2009-01-29T08:14:00.001-08:00

Be careful naming your Python modules. If you name a Python file the same as an existing file in your Python install directory, you may get the following exception message: "'module' object has no attribute '[some-attribute-name]'".
I'm really loving SciTE. It's a dead simple code editor that offers syntax highlighting for an impressive number of languages and displays the results of the run in it's own output window.
More SciTE: If you decide to use SciTE, you'll probably want to customize how it works. Here's a nice quick reference to supplement the SciTE documentation to help guide you through the config files.
If you want to use SciTE as your IronPython editor, you'll need to modify the existing python.properties file. Select "Open python.properties" from the "Options" menu. Search for "command.go" and modify the value so that it points at your IronPython directory.
All Python modules have a special variable called "__name__". When the code in your module is executed with CPython, __name__ is set to the file name of your module minus the "py" extension ("mymodule" if the file name of your module is "mymodule.py", for example), except when the module is executed directly. If that's the case, __name__ is equal to "__main__". Unfortunately, this is not the case if you execute it with IronPython. The special variable __name__ will always be based on the file name. UPDATE: The above is true only when you compile your IronPython code. If you launch a *.py file with ipy.exe, the __name__ variable will be "__main__".

Note to Self 6 - IronPython, pyc.py and SciTE

2009-01-19T20:09:00.001-08:00

The pyc.py file can compile you IronPython code into .NET executables.
The pyc.py file is part of the sample code released with IronPython. It can be found here. Look for the "IronPython-2.0-Samples.zip" link.
Typing out "[IP directory]\ipy [code directory]pyc.py" explicitly everytime you want to use the tool is somewhat annoying. Consider creating a script to do this for you. Here's a simple batch file.

cd C:\data\FeClass
c:\fepython\ipy.exe pyc.py class.py /main:main.py

Note that you'll have to copy the pyc.py file to the same directory as your code for this to work.
IronPython Studio just isn't up to snuff. You're better off to use a text editor and a build script
I like SciTE as my IronPython editor even more so than Notepad++. I really like that I can run my Python or IronPython script from SciTE and the output the normally would be displayed in the command window is captured in SciTE.

SQL Alchemy ORM Basics

2009-01-11T20:25:00.001-08:00

In my previous post, Learning SQL Alchemy, I focused on the SQL-like aspect of SQL Alchemy. You'll need to review the sample code in that post before understanding the code below. On with the code.

class User(object): pass
mapper(User, user_table)

Believe it or not, we just created a class with an ID, Name and Password. Simply create an empty class and pass it to the the mapper along with the user_table we had created. How do we use it? First off we have to create a Session object. Note that when we call the sessionmaker, it returns a Session class which you use to create the session.

Session = sqlalchemy.orm.sessionmaker()
session = Session()

All have we to do now is create a new User object, set the appropriate fields and pass it to the "save" method.

user = User()
user.name = "Fred Flintstone"
user.password = "yaba daba doo"
session.save(user)

But how do we get our user back from the database?

query = session.query(User)

We can now iterate through the query like any list.

for user in query:
print user.id, user.name, user.password

You can see the new record we inserted along with the other records in the table.

2 angie password2
3 nate awesomeness
4 Fred Flintstone yaba daba doo

The important thing to note is that the query object is actually a list of the very same User type I defined at the beginning of this post. Of course we probably don't want everything in the table, so here's an example of getting back a single object.

for user in query.filter_by(name = "angie"):
print user.id, user.name, user.password

The result is just what we would expect.

2 angie password2

But let's say I want to change Angie's password.

user.password = "a much more secure passphrase"

for user in query.filter_by(name = "angie"):
print user.id, user.name, user.password

The result?

2 angie a much more secure passphrase

Learning SQL Alchemy

2009-01-07T17:58:00.001-08:00

I spent a portion of my holidays studying the basics of SQL Alchemy. My first lesson is that SQL Alchemy is NOT an ORM for Python but instead a SQL abstraction tool with an ORM built-into it. At first I was having trouble understanding what this really meant, but after seeing an example it sunk in. Let's start by building a table.

from sqlalchemy import Table, Column, Integer, String

meta = sqlalchemy.MetaData("sqlite:///")

user_table = Table('userTable', meta,
    Column('id', Integer, primary_key=True),
    Column('name', String, unique=True, nullable=False),
    Column('password', String, nullable=False))

meta.create_all()

First thing we need is a MetaData object which holds all of our database schema information as well as our engine for executing queries. By passing "sqlite:///" in the MetData constructor we create an engine pointing at an in-memory SQLite database. To create a table, we just declare an instance of the Table object and pass in the necessary parameters: table name, our MetData instance and whatever columns we need in the table. The constructor for the Column class not only takes the column name and type, but constraints as well. Then all we have to do is execute the statement by using the create_all() method of the MetaData class.

Did you note the user_table variable we created? That comes in really handy when we want to start manipulating our new table.

insert = user_table.insert()
insert.execute(name='darrell', password='password1')
insert.execute(name='angie', password='password2')
insert.execute(name='nate', password='password3')
insert.execute(name='drew', password='password4')

See how easy inserting data is? There are methods just like the insert method above for select, insert and delete. Let's take a look at the select method.

select = user_table.select()
results = select.execute()

for row in results:
print row.name, row.password

The result are just as you would expect.

darrell password1
angie password2
nate password3
drew password4

That's great, but how do we change Nate's password and then return only his record?

update = user_table.update(user_table.c.name=='nate')
update.execute(password='awesomeness')

select = user_table.select(user_table.c.name=='nate')
results = select.execute()

for row in results:
print row.name, row.password

It's very simple and readable code with one caveat: what is "user_table.c.name"? It's a convenience attribute containing a collection of all the columns in userTable. So what our update statement is saying in terms of SQL is "UPDATE userTable SET ????? WHERE name = 'nate'". The only thing we don't know at this point is what to change. That happens when we execute the statement on the next line. If you understand the update statement above, the select statement works exactly the same way. Our result is below.

nate awesomeness

We've seen select, update and insert, but what about delete?

delete = user_table.delete(user_table.c.name.like("d%"))
delete.execute()
select = user_table.select()
results = select.execute()

I couldn't help myself - I had to confuse the issue by using "LIKE". In my defense, now you know how to introduce a "LIKE" comparison into your code AND that the "c" attribute is more than just a collection of strings. Beyond that, the delete works exactly the way you would expect it to work: call the delete method by passing the constraining expression as a parameter and then execute the result.

Now I understand why SQL Alchemy is an SQL abstration tool. All I did in the examples above were execute very basic SQL statements; the ORM was never used. Why is this so powerful? Imagine being able to write the same code for a SQL Server database as you did for a MySQL server and having the confidence that it's going to work. That's the power of SQL Alchemy.

Congratulations 2009 Microsoft MVP!

2009-01-02T06:26:00.001-08:00

That's the subject line of an email I received yesterday. No one is more surprised than me. Considering who the other MVPs are, I'm honored to be among them. I'm not entirely sure what I did to deserve this, but I'm grateful all the same. Thank you, Microsoft, for noticing me and here's to a productive 2009. Cheers!

Note to Self 5 - Inherit and Override

2008-12-27T08:37:00.001-08:00

I've been reading Working Effectively with Legacy Code by Michael C. Feathers. It's a trove of useful information for turning your unreadable and unreliable code into the complete opposite.

Here's a useful technique for dealing with dependencies that have problematic methods for testing. Mark the offending method as virtual and inherit from the class. Now you can use this new derivative class in your test methods in place of the original. Here's an example in C#.

public class MyClass
{
    public MyClass()
    {
        Console.WriteLine("MyClass has been initialized");
    }

    public virtual void DifficultMethod()
    {
        Console.WriteLine(
                "Difficult method makes testing difficult.");
    }
}

public class MyClassDerived : MyClass
{
    public MyClassDerived() : base()
    {
    }

    public override void DifficultMethod()
    {
        Console.WriteLine("It's testable!");
    }

}

public class ClassToTest
{
    public ClassToTest(MyClass myclass)
    {
        Console.WriteLine("Initializing ClassToTest");
        myclass.DifficultMethod();
    }
}

The ClassToTest has a constructor that takes a MyClass parameter. Unfortunately, MyClass has the DifficultMethod which is a very...well, difficult method. By marking DifficultMethod as virtual we can override it in a derived class which can then be used to pass into the ClassToTest constructor. Handy.
Here's the same idea in Python

class MyClass(object):
    def __init__(self):
        print "MyClass Initialized"
    def difficult_method(self):
        print "this makes things hard"

class MyClassDerivative(MyClass):
    def __init__(self):
        MyClass.__init__(self)
    def difficult_method(self):
        print "MUCH better"

class ClassToTest(object):
    def __init__(self, myClass):
        print "ClassToTest has been initialized"
        myClass.difficult_method()

Using Lambdas to Avoid Gnarly IF Statements

2008-12-16T20:20:00.001-08:00

Do you have a function in your C# code somewhere that takes a parameter - the type doesn't matter - and then executes another function based on that parameter's value?

public void what_to_do(string param)
{
    if (param == "this")
        DoThis();
    else if (param == "that")
        DoThat();
    else
        DoSomethingElse();
}

Whenever I see "else if", my spider-sense starts tingling. Adding another "else if" is just too easy and the result can be cumbersome. I do use "else if" (and "switch" - it's just as vulnerable to this idea), but I don't always like it. The good news is that there is a fix - if you're willing to think "functionally". The bad news is it took me so long to piece it all together.

When did this epiphany come? At the latest MichiPUG meeting, while Mark Ramm was demonstrating a Python library for implementing generics, he displayed an interesting technique for avoiding the Python version of the above code. Here's my rendition of what he showed us:

whatToDoDictionary = {'this':do_this, 'that':do_that}

def what_to_do(param):
    if param in whatToDoDictionary:
        whatToDoDictionary[param]();
    else:
        do_something_else();

The key to this bit of Python is the values in the whatToDoDictionary. Instead of your standard string or integers, the values are functions. When we call the what_to_do method, we look to see if the parameter is present as a key in the dictionary. If it is, we simple execute the value portion of the key/value pair. Voilà! No more "else if"!

Can we do this in C#? Sure. Let's do it using lambdas.

Dictionary<string, Action> dict =

     new Dictionary<string, Action>();

public Lambda()
{
    dict.Add("this", () => do_this());
    dict.Add("that", () => do_that());
}

public void WhatToDo(string param)
{
    if (dict.ContainsKey(param))
        dict[param]();
    else
        do_something_else();
}

The concept is exactly the same. Build a dictionary of lambdas (functions in Python), see if the parameter passed to the WhatToDo(string) is in the dictionary and then execute the lambda if it is.

Note to Self 4 - Python Editors, Debuggers, stdout and stderr

2008-12-13T13:11:00.001-08:00

PyScripter has been IDE of choice for Python, but I've run into some problems with it. I would have continued to use it, but I noticed that the latest anyone did any work on it was October of 2006 - or at least that's what I thought. It turns out that early this year PyScripter is now maintained in Google Code and supports Python 2.6. You can download it here.
I've started using Notepad++ for editing my Python. Though it's only an editor, it uses syntax highlighting, supports macros and allows me to define hot keys to run external programs. This last point makes it possible for me to launch my code in Python with a simple keypress.
Want to know how to use Notepad++ to launch the file you're currently editing in Python? Type "[%Python directory%]\python.exe "$(FULL_CURRENT_PATH)" into the Notepad++ Run dialog and then save it to the keystroke combination of you choice.
If you took my previous bullet point to heart, you'll find that Python launches in a command window and then promptly closes after your tests run losing any output you may have had. The only way that I've been able to solve this is by pointing the stdout and stderr to a file. I would prefer to override the these when I launch Python, but instead I have to put some addtional code into my application. Bummer.
WinPDB is a debugging tool for Python. The only tool I'd used for debugging in the past is the one embedded into PyScripter. When I started using Notepad++ as my editor, I started trying to debug from the command line using the PDB module. No fun. That's when I came across WinPDB. It's worked well for the past few days that I've been using it, but it still isn't as nice as having your debugger integrated into your environment.

Note to Self 3 - CodeMash Screen Casting Options

2008-11-17T10:41:00.001-08:00

I've been learning a lot about Screencasting this week...

I've updated my podcasting links at http://delicious.com/dwhawley/podcasting with a couple of new items.
I reviewed a couple of USB devices to capture video and audio (USB 28000D DVD Maker and the Diamond VC500 One Touch Video Capture Device) and I wasn't happy with any of the reviews. This really seemed to be the simplest avenue but seems to be a dead-end.
The solution I'm searching for assumes that I'll only have laptops available. There are a lot of video capture cards out there for a desktop machine but I'm avoiding this one for now.
I like the VNC option the best, but a major problem with this is that we'll need to rely on speakers installing something on their machine. Jason Follas pointed this out to me and he's right. I think the only way to resolve this is ask the community. If they don't like the solution I'll know to keep looking. Besides, someone might have a really good idea.
Jing is cool. Jay Wren gave me quick demo earlier today and I was impressed with it's simplicity. One of the things that I really like about Jing is it's social spirit. I was looking at Camtasia, another offering by TechSmith , but I think Jing may be a better fit.

Note to Self 2 - Capturing Multiple Conference Sessions Simultaneously

2008-11-04T11:00:00.001-08:00

I'm the A/V Coordinator for CodeMash 2009 and as such I have a lot of sessions to capture. Here are some notes.

I'm storing links related to podcasting at http://delicious.com/dwhawley/podcasting.
According to Wikipedia, "Virtual Network Computing (VNC) is a graphical desktop sharing system which uses the RFB protocol to remotely control another computer. It transmits the keyboard and mouse events from one computer to another, relaying the graphical screen updates back in the other direction, over a network." In short, the VNC server displays what's on the screen of the VNC client.
Every presenter will require a VNC client of some sort on their machine. The client will connect to a VNC server where the actual video capturing will take place. I'm assuming one server per client with each hard-wired to a switch, but I'm hoping for more 2 or more clients per server.
Without knowing much about it, I had been using VNC for quite some time. I've used both GoToMeeting and NetMeeting with excellent results.
Because this is CodeMash, there will be three different families of Operating Systems represented: Windows, Mac and Linux. Theoretically, my Windows based VNC Server should have no problems seeing a Linux- or Mac-based client, but I've heard this sort of thing before. I will be setting up a test network in the very near future.
Audio will have to be recorded separately since it isn't part of the RFB spec (communications protocol between VNC client and server). I know some tools cover this for you, but I can't count on it in platform agnostic environment.

Note to Self 1

2008-11-03T13:57:00.001-08:00

I haven't been blogging much lately, which is no surprise to anyone who follows my blog. To those three readers, I'd like to tell you that writing - to me - is a very much a love/hate relationship. When I'm inspired, writing becomes an obsession I can't possibly put aside. Even if what I produce is not noteworthy among my colleagues, the process of putting my thoughts into words helps me clarify personal thoughts like no other learning experience could. It confirms truths. It tears-down misconceptions. It's the highest form of human expression. It's REALLY exhausting. So If I don't have the time or energy to write, how do I effectively maintain a blog?

The title of this post sums up my solution. If I don't have the time or energy to write the kind of post I want, just write short bullet points on the things that I've been exploring. What I really like about this approach is that I do a lot more in the course of a day than I could possibly convey through my blog. For example, since I last blogged, I've experimented with jQuery, VMWare Player, Virtual PC, Python and SQL Alchemy. Even at the best of times, there is no way that I'm going to cover all of those topics before forgetting one or more of them. With that said, time to write some notes.

jQuery rules, though I've had problems debugging using FireBug. Apparently it requires a bookmarklet though that still doesn't seem to work for me.
The mapper class in SQL Alchemy - Python ORM - gets rid of having to manually set properties of derived classes when the corresponding base class is already known (i.e., Employee.Name = Person.Name). This is the sort of code that really annoys me and I'm glad there's a way to avoid it.
Virtualization rocks, but it gets tough on a laptop. My host machine is Vista and my guests are all XP. I've tried Vista as guest before, but it was so slow I couldn't really do anything with it. Some of my virtualization links can be found at http://delicious.com/dwhawley/virtual.
I've been using both VMWare Player and Virtual PC. VMWare Player works with more than just Windows allowing me to periodically play with Linux, but doesn't have the really cool pause feature that Virtual PC has. Virtual PC seems a bit snappier to me, but it lacks support for USB. No excuses for that.
Azure is really cool though you should keep in mind that this is in direct competition with Google Apps. Either way, I'll be using both.
Of all of the features I've heard about Windows 7, I'm most excited about it's smaller footprint.

A Visit from Redmond - Catching up on Visual Studio Team Edition with Mark Mydland

2008-10-27T13:54:00.001-07:00

On November 12th, Mark Mydland, Group Manager for the Visual Studio Team Edition for Software Testers, will be speaking at the Ann Arbor .NET Developers Group. This is your opportunity to glimpse the future of - possibly even influence - the tool you spend the most time using, so clear you calendar!

The phrase “drive quality upstream” has been abused so badly by ALM software vendors that it has to be relegated to the platitude junk pile along with such all time favorites as “work smarter not harder,” “think outside the box,” and “synergistic leveraging of code reuse.” Before we drive quality anywhere, we need to give quality a seat at the table. VSTS Rosario release will do this by automatically gathering critical information about the project and code and making that data available when, where and to whom it is needed. During this discussion we will examine how Rosario impacts quality across the application lifecycle by:
* Allowing testers to provide developers with details about what the code did instead of just providing the details about what the tester did.
* Allowing development leads and architects to visualize and understand their current code (not the code they wish they had, but the code they really have) so that they can minimize the impact of changes; and
* Allowing developers to understand the impact of their changes in terms of affected tests, concurrency and bounds checking.
The Rosario release of VSTS will bring all project stakeholders together to allow richer information to be shared across every role to make software quality accessible and achievable.

About Mark

Mark Mydland is a Group Manager for the Visual Studio Team Edition for Software Testers product at Microsoft. In the past 12 years, Mark has worked as a developer and consultant across a wide variety of applications and industries. Mark first joined Microsoft in 2001 working as a member of the Natural Interactive Services Division (NISD). During his time in that group, Mark was the development manager for a team focused on analytics for assessing the efficacy of natural language interpreters with a particular emphasis on driving authoring simplification and relevance quality for user assistance. Based on this work, Mark filed numerous patents and coauthored a paper for the SIGIR journal. In 2004, Mark left Microsoft to work as a Director of Development at Getty Images where he led a change in process from a traditional waterfall methodology to a scrum-based agile approach which brought the release frequency from 12-18 months down to 1 month. Since Getty made extensive use of VSTS, it seemed a natural fit for Mark to join VSTS on his return to Microsoft in 2006. Mark received his B.S. from West Point in 1991. He has also held positions with USWeb/marchFirst and Andersen Consulting/Accenture.

Class Variables versus Instance Variables in Python

2008-09-05T08:39:00.001-07:00

While writing some Python, I ran into a behavior that I didn't expect. Check out the following chunk of code:

import unittest

class Task(object):
keywords = []

class TestClass(unittest.TestCase):
    def test_keywords(self):
        mytask = Task()
        mytask.keywords.append("one")

        mytask2 = Task()
        mytask2.keywords.append("two")
        self.assertEqual(mytask2.keywords[0], "two")

When I ran the test, it failed with the following exception: "AssertionError: 'one' != 'two'". As I dug into the code I found that the mytask and mytask2 instances had received both of the keywords, not just one a piece. My initial reaction was that this must be some sort of Python bug. But as I investigated I found that I had actually created a Class Variable - Python's way of saying "static". What I really wanted was an Instance Variable.

class Task(object):
def __init__(self):
self.keywords = []

By declaring "keywords" inside the constructor it is now guaranteed to be unique to each instance of the class allowing my test to pass. This link in the Python Reference Manual explains it much more clearly. Note that IronPython behaves in the same manner.

More Lessons from Project Management in the Physical World

2008-08-29T08:10:00.001-07:00

This post is a continuation of my post from July 30 on some project management lessons I learned while roofing my garage.

I had all of my roofing supplies, my work force was in place and the big day had arrived. Everything was just as I had envisioned it. Then my first volunteer arrived and told me he wasn't sure how long he was going to be able to help. His wife had gotten sick the day before and it didn't appear she was going to be in any shape to watch their children. If he would have been the only person I recruited to help, I may have been hard-pressed to accomplish my goal of completing the roof by Sunday evening. But he wasn't. I still had one other person to help that day and I could have probably found additional help the following day if necessary. Crisis averted.

Lesson 4: Mitigating risk is time well spent especially when risk becomes reality.

I had researched getting a dumpster and instead found a company that would load your garbage in a truck with their own work force. They had a nice website that detailed their costs - or so I thought. It turns out that they had a special pricing for roofing which I didn't learn about until 3 hours prior to pick-up. The additional cost was excessive and there was no way I was going to pay for it. I had no backup plan aside from just leaving a pile of roofing in my driveway until I found alternative. Fortunately, my friend let me borrow his truck and I was able to dispose of the old roofing for a fraction of the cost. I was lucky. In retrospect, having a dumpster on site ahead of time would have completely eliminated this risk. Instead, I knowingly introduced a number of unnecessary variables into my project (reliability of the company schedule, truck and web site pricing for example).

Lesson 5: You may not know ALL of the risks ahead of time, but you CAN minimize them by limiting your unknowns.

When Sunday evening did come, I could say that I had met my goal of having a roof in place. Unfortunately, the job was far from done. The rain storm that had hit meant I had to clean out the garage and I still had a truck load of roofing to take to the landfill. It turns out "done" really meant that the only change to my property was a new garage roof - definitely not the case on Sunday evening. I could have blamed the rain for not meeting my goal but that would have done nothing but assuage the problem. The rain had only changed the actions necessary to attain my goal not change the goal itself.

Lesson 6: Make sure that everyone on the team clearly understands what "done" means.

When the rain started coming down, I looked at it as a bad thing. But it forced me to go through the "features" of my garage - spare sheets of drywall and scrap lumber for example - and make some decisions on them. Removing these features made my garage a more useable space. The irony of course, was that I considered rain a risk not an opportunity.

Lesson 7: Beware of bloat

Lesson 8: Look for the opportunities in setbacks. Sometimes they can contribute to the success of the project.

Speaking at GANG on Wednesday Night

2008-08-19T18:30:00.001-07:00

Just a note that I'll be doing my "Getting Started with IronPython" talk at the Great Lakes Area .NET User Group in Southfield, MI tomorrow night. I'm always glad to go back to GANG since this is where my User Group career started before I moved over to the Ann Arbor .NET Developers Group. Come out and learn about one of the new .NET languages while networking with local community leaders. I Hope to see you there.

Lessons from Project Management in the Physical World

2008-07-30T20:27:00.001-07:00

When developers talk about projects, they probably are talking about software. But however hard they try, they cannot completely escape "real" world projects. This is especially true when it comes to home ownership. When my wife and I noticed our garage roof deteriorating, I realized I was going to be confronted with an especially nasty real-world undertaking. By looking at it through the eyes of a project manager however, I was able to take an unpleasant task and turn it into a successful learning experience.

Like any project, replacing a roof requires planning and my plan focused on a single goal: there will be a new roof on my garage come Sunday night. The five basic items on my task list - schedule a weekend, purchase supplies, order a dumpster, remove the old roof and install the new roof - were all focused toward achieving that goal. I was concerned about inclement weather, unforeseen repairs and lack of personnel, so I created a plan for each risk and a trigger for implementing it. What I did not plan was HOW to roof the garage. I simply had to be confident that the implementation team could do the work using pre-defined best practices.

Lesson 1: Planning is about achieving a goal, identifying general tasks and knowing how to deal with risks. Planning is NOT about implementation details.

I felt the project could be completed quickly though I didn't have the experience to say for certain. I contacted someone with more experience (my dad) and he confirmed that one day should be enough time for a 2-man crew to roof a one-car garage. My experience however, told me to include extra time and any additional personnel I felt I could keep consistently busy. In the end, myself and 2 people were able to replace the roof in one very long Saturday. If additional time was required, we still had Sunday as a buffer.

Lesson 2: Experience is invaluable. If you don't have it, find it.

Risk exists. Acknowledge it up front or spend your life being constantly surprised by it's consequences. When I chose my weekend to roof, I knew three days in advance that rain was a possibility. I knew that afternoon thunderstorms were a certainty the night before. To mitigate the rain risk, I bought a tarp large enough cover only a portion of my garage. I felt that the extra $80 was not worth protecting things that I could either handle the wet or that I could live without. With plan in place and thunderstorms in the forecast, I pressed forward. Guess what? We had a two hour downpour in the morning almost immediately after we had finished removing the old roof. Critical items were protected, but I still suffered some minimal damage. When I cleaned out my garage, the only things I had lost were time and expendable items.

Lesson 3: Just because you mitigate risk doesn't mean you completely avoid it's consequences. Take a moment to imagine handling the consequences before committing to anything.

As this could turn into such a large blog post, I thought I'd break it up into a couple of chunks. I'll post part two sometime in the next week. John Hopkins, I acknowledge that you've called me out and I owe a post on who inspires me.

Speaking at GLUG.Net Tonight

2008-06-19T05:58:00.001-07:00

I'll be giving my now re-tooled introduction to IronPython this evening at the Greater Lansing User Group .Net meeting. Entitled "Getting Started with IronPython", I'll be focusing on the syntax, rules and "gotchas" of IronPython by making comparisons to C# as well as writing lots of code. My end point - if there's enough time - is to get started on a very simple windows application. Hope to see you there.

AADND and Lessons Learned on Speaking

2008-06-12T07:19:00.001-07:00

I gave my Looking Out For IronPython talk at AADND last night which went really well. People were asking questions and genuinely seemed engaged. But as far as knowledge gained is concerned, I think I was the big winner last night. After the meeting had cleared out, Bill Wagner gave me the most in-depth speaking critique I have ever gotten. Typically, the only feedback a speaker gets is a stack of evaluation forms with a bunch of numbers circled and an occasional useful comment. Bill's comments focused not only content, but also pace and physical movement. His comments in summary...

Only move to different locations in the room if there is a purpose in doing so. I have a tendency to pace which only distracts the audience from your point. Check out this post by Josh Holmes to hammer home the point. If you have the time, browse his blog in it's entirety. He has a lot to say about public speaking.
Posture is important. It magnifies your presence and conveys confidence. Putting your hands in your pockets kills your posture and thus your presence. Even worse, you loose credibility with your audience. Stand tall, keep your hands out of your pockets and use hand gestures only if necessary.
It's OK to say, "I don't know," but it's not OK to advertise it (yes, there is irony in this post). When you speak, you become the self-professed expert in the room. In this context, I viewed any question from the audience that I couldn't answer as a failure. Now that I've learned differently, I seemed to have gone too far. I LIKE to talk about the issues I'm trying to solve. Great for personal growth, not so much for presentations. I need to focus on what I know.
Looking out for IronPython was intended to be an introductory talk. People are showing-up to learn the basics of IronPython, not to be wowed by what IronPython can do. I spent too too much time on complex examples that had little value to the audience.
My talk was structured so that the first half was entirely PowerPoint and the second half was entirely code. This sort of thing can be taxing on an audience's attention span. Do a few slides, show a demo, do some more slides, then do another demo. This breaks things up into smaller, more digestable chunks.
Showing an audience something they already know and then morphing it into something new is an effective teaching technique. I did it in Looking out for IronPython and I should consider it for future talks.
Humor is risky which is why I have made the conscious decision to stay away from a lot of jokes in my presentations. I did insert one slide that last nights audience found entertaining (earlier audiences did not), but it was directly relevant to my point. My lesson here? Don't plan a joke. If the opportunity comes, jump on it. Otherwise, just be yourself.

Bill's comments were a nudge in the right direction. If I'm really serious about improving though, I need to find the nearest Toastmasters group. All I have to do is find the time!

I know I promised a post of IronPython resources. I'm still compiling my list and hope to have those posted by this weekend.