hwiechers

Stashing Changes in Mercurial

2012-01-28T22:05:00.000-08:00

Stashing means setting aside changes to a working directory without commiting them.

It's useful if, for example, you're adding a feature to one of your projects when you find a bug that you want to fix immediately. You don't want to not mix the fix up with your feature code and you aren't ready to commit and start a new changeset. The solution is to stash your changes, code the bug fix and commit it and then unstash them to resume working on the feature.

Recipe

hg diff | Out-File -Encoding ascii stash.patch
hg update -C
# other stuff...
hg import --no-commit stash.patch

Explanation

Output of hg diff is a unified diff which we save to file. hg update -C, of course, removes the changes from the working directly. Be careful that you don't accidentally lose work when you're doing this! After other stuff, we use the import command to unstash the changes.

Comparison to Other Methods

There are extensions for stashing but, in my experience, they don't work very well.

mq is used for this as well but that procedure is unnecessarily complicated if you don't normally use mq.

Vim: Reading from stdin

2011-09-23T23:21:00.000-07:00

Here is a neat tip for Vim.

To read from stdin use

<other commands> | gvim -R -

-R instructs Vim to read the file in read-only mode.
- is a utility convention that means open from stdin. (See Guideline 13 of Utility Syntax Guidelines from the Posix standard.)

Source: http://stackoverflow.com/questions/230718/redirection-and-vim

Mercurial: Automatically pushing changes on commit

2011-09-18T07:07:00.000-07:00

Here is a neat tip for Mercurial.

To automatically push on every commit add this hook to your repo hgrc:

[hooks]
commit.autopush = hg push

Source: http://stackoverflow.com/questions/1235597/mercurial-automatic-push-on-every-commit

Moving the Windows User folder

2011-03-22T22:30:00.000-07:00

With a bit effort, it's now possible to move your user folder and link to it with junction point. Here are some instructions I found on superuser.com.

This makes it possible to truly separate your data and system files by moving your user folder to a completely separate drive.

Case classes in Python

2010-08-28T00:52:00.000-07:00

I'm trying to build a parser. The main function I've writing is called parse. It takes a str and returns a parse tree of token classes. I have a heap of tests that parse some text and then compare the parse tree against the an expected parse tree.

The way I started testing this looked a little like:

# token classes
class Add(Token):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def __repr__(self):
        return 'Add(' + repr(left) + ', ' + repr(right) + ')'

class Number(Token):
    def __init__(self, numberStr):
        self.numberStr = numberStr

    def __repr__(self):
        return 'Number(' + repr(numberStr) + ')'

# tests
class Tests(unittest.TestCase):
    def test_add(self):
        self.assertEqual(
            "Add(Number('1'), Number('1'))", 
            repr(parse('1+1'))

Making the token classes was a real chore. After a while, I had around 10 of them and writing them was increasingly tedious. It occurred to me that if I had somethinng like Scala Case Classes, I could change the code to something like:

# token classes
class Add(Token):
    def __init__(self, left, right):
        pass

class Number(Token):
    def __init__(self, numberStr):
        pass

# tests
class Tests(unittest.TestCase):
    def test_add(self):
        self.assertEqual(
            Add(Number('1'), Number('1'), 
            parse('1+1'))

This way the token classes basically write themselves and, because they have a handy eq method, the test don't need those messy string comparisons.

I did some research and found out that I could basically get the case class functionality (apart from the pattern matching aspect) using a custom Metaclass.

Here the result:

>>> from caseclasses import CaseMetaClass
>>>
>>> class MyCaseClass():
...     __metaclass__ = CaseMetaClass
...     def __init__(self, a, b):
...         pass
...
>>> instance = MyCaseClass(1, 'x')
>>> instance.a
1
>>> instance.b
'x'
>>> instance == MyCaseClass(1, 'y')
False
>>> instance == MyCaseClass(1, 'x')
True
>>> str(instance)
"MyCaseClass(1, 'x')"

This is how it works. Case classes are marked with the CaseMetaClass. For each argument in the __init__ method, a read-only property is generated with the same value as the argument when an instance is constructed. It should be obvious from the example how the generated __eq__ and __str__ methods work. I also added simple implementations of __ne__ and __hash__ to be consistnt with the __eq__.

Getting this working was much easier than I expected it to be. Here is the code:

import inspect

from decorator import decorator

class CaseMetaClass(type):
    def __new__(mcs, name, bases, dict):
        def noop(self):
            pass

        for meth in ('__eq__', '__ne__', '__hash__', '__str__'):
            if meth in dict:
                raise Exception('{} must not be defined on class.' % (meth))

        if '__init__' in dict:
            args, varargs, varkw, _ = inspect.getargspec(dict['__init__'])
            if varkw is not None:
                raise Exception("__init__ can't take **kwargs")
            args = args[1:]
        else:
            args = []
            varargs = None

        if args and varargs:
            raise Exception("Case class __init__ can't have both args (other than self) and *args")

        for arg in args + ([varargs] if varargs else []):
            if arg.startswith('_'):
                raise Exception("Case class attributes can't start with '_'.")
            dict[arg] = property(lambda self, arg=arg: getattr(self, '_' + arg))

        def _init(func, self, *init_args) :
            setattr(self, '_CaseMetaClass__args', init_args)
            if varargs:
                setattr(self, '_' + varargs, init_args)
            else:
                for (name, value) in zip(args, init_args):
                    setattr(self, '_' + name, value)
        dict['__init__'] = decorator(_init, dict.get('__init__', noop))

        def str(self):
            values = [repr(x) for x in getattr(self,'_CaseMetaClass__args')]
            return name + '(' + ', '.join(values) + ')'
        dict['__str__'] = str
        dict['__repr__'] = str

        def eq(self, other):
            if other is None:
                return False
            if type(self) is not type(other):
                return False
            return self._CaseMetaClass__args == other._CaseMetaClass__args
        dict['__eq__'] = eq

        dict['__ne__'] = lambda self, other: not (self == other)
        dict['__hash__'] = lambda self: hash(type(self)) ^ hash(self._CaseMetaClass__args)

        return type.__new__(mcs, name, bases, dict)

UDFs and Underlying Schema Changes

2010-04-18T22:03:00.000-07:00

I had a problem at work recently where we changed a column's collation but a User Defined Function that referenced this column didn't reflect the updates and started complaining about collation conflicts. In this situation, most people (at least most people I know) recommend dropping the UDF and recreating it to force the UDF to update, but there is a better way.

sp_refreshsqlmodule will refresh the UDF in a single step and without the risk in dropping an object. The MSDN documentation for CREATE FUNCTION (under Best Practices) recommends creating functions WITH SCHEMABINDING as an alternative.

Truth and Python 3: The 'and' and 'or' Operators

2010-04-03T05:21:00.000-07:00

The Python and and or operators are a little involved but work in a useful and helpful way. These operators combine two objects, called operands, into a single object. The operators can be of any type and aren't restricted to bool. Python uses the keywords for these operators instead of the && and || symbols common in other languages.

The and operator returns the first false operand or the last one if both operands and true. Some examples will make this clearer:

>>> '' and 0
''
>>> 'x' and 0
0
>>> 'x' and 1
1

The or operator returns the first true operand or the last one if both operands are false. Here are some examples:

>>> 'x' or 1
'x'
>>> '' or 1
1
>>> '' or 0
0

Of course, bool(x and y) will always be equal to bool(x) and bool(y). For this reason, and operator will work as expected when used in conditional clauses. Similarly, bool(x or y) will always be equal to bool(x) or bool(y).

These operators are 'lazy' or 'short-circuiting'. The second operand is only evaluated if it would make a difference to the result. Here's an example:

>>> def x():
...     print('x')
...     return True
...
>>> def y():
...     print ('y')
...     return True
...
>>> x() or y()
x
True

In the example above y isn't called since x returns True.

Logically or will return the first operand if it's true, otherwise it will return the last. This means that or works like the null coalescing operator (??) in C# and it's often used in that way. Here's a vague example:

def some_method(some_parameter=None):
    some_parameter = some_parameter or get_default_value()
    # details...

Truth and Python 3: The if statement

2010-03-01T19:44:00.000-08:00

In it's basic form the Python if statement looks like this:

if expression:
    statements

If expression is true, statements are executed; otherwise statements are skipped. expression can be of any type; it doesn't have to evaluate to True or False. The if statement automatically converts expression to bool(expression) if needed.

Unlike other languages, parenthesis are not required around expression. In fact, it's considered bad style to include them.

If statements consists of a single statement, the whole if statement may be written as one line:

if expression: statement

The `else` Clause

The if statement can include an else clause. The else clause is optional; an if statement doesn't have to have one.

if expression:
    statements
else:
    else-statements

The else-statements are executed if none of the other branches of the if statement are executed. In the case above, if expression is false, else-statements are executed.

The `elif` Clauses

The if statement can include one or more elif or 'else-if' clauses. These clauses are also optional.

if expression:
    statements
elif elif-1-expression:
    elif-1-statements
elif elif-2-expression:
    elif-2-statements
more elif clauses...

An elif clause contains an expression and statements. The elif statements are only examined if expression is false. The interpretter starts going through the elif conditions from top to bottom until it finds one that is true. It then executes the corresponding statements and exits the if statement.

The `if` Statement in Full

An if statement may include both elif clauses and an else clause. The complete form of the if statement looks like this:

if expression:
    statements
elif elif-1-expression:
    elif-1-statements
elif elif-2-expression:
    elif-2-statements
more elif clauses...
else:
    else-statement

Truth and Python 3: The bool Type

2010-01-31T07:28:00.000-08:00

Python 3 has a bool type representing Boolean values. There are two builtin bool constants, True and False.

For legacy reasons, bool is actually a subtype of int and True behaves like 1 while False behaves like 0.

For example,

>>> True + 0
1
>>> False * 3
0

and even...

>>> True == 1
True

The main difference between True and 1 is that str(True) returns 'True' and not '1'. Similarly, str(False) returns 'False' and not

'0'.


Any object can be converted to bool by running it through the bool constructor. Here are some examples:
>>> bool(True)
True
>>> bool(None)
False
>>> bool([])
False


For any object, x, if bool(x) is True, we say it's truth value is true and we consider x as true in a Boolean context. If bool(x) is False, we say it's truth value is false and we consider it as false in a Boolean context.

x's  truth value is determined as follows:

    If x is None, it's false
    If x defines a __bool__ method that returns False or 0, it's false.
    
If x doesn't define a __bool__ method but defines a __len__ method that returns 0, it's false.
    Otherwise, it's true


Given the rules above, it's no surprise that the vast majority of objects are considered true. The main ones that are considered false are:

   None
   False
   The zero value of each numeric type i.e. 0, 0.0, 0+0j
   Empty containers e.g. (), {} and [].
   "" (the empty string)



FireFox without a Mouse
2010-01-17T05:12:00.000-08:00
I finished reading The Productive Programmer a few weeks ago and since then I've been thinking about how to be more productive on the 'micro' level. 

"Keep you hands on the keyboard as much as possible" is one of the recommendations that people always make. Constantly moving your hand from keyboard to mouse and back slows you down and feels pretty awkward too.

With that in mind, I've been learning how to browse with FireFox using the keyboard only. Some sites make this difficult but I can now go for much quite a while without reaching for the mouse.

Here are some basic tasks and how to do them with the keyboard. Note that I've chosen the methods and shortcuts that I like best and that there are other ways of doing these things.

Entering an Address

    Use alt+d to focus the Location bar
    Type the URL
    Press enter to open the URL.

        You can hold these keys down to modify the behavior:
        
            ctrl - prepend www. and append .com to the address
            shift - prepend www. and append .net to the address
            ctrl+shift - prepend www. and append .org to the address

            alt - open in a new tab
        

        For example, pressing ctrl+shift+alt+enter with an address of python will open www.python.org in a new tab.
    
     


Searching

    Use ctrl+k to focus the Search bar
    Type the search terms
    Press enter to open the search in the current tab

        You can hold down alt to open the search in a new tab instead


Navigating between tabs
On Ubuntu these shortcuts use alt instead of ctrl.

    ctrl+tab displays the next tab
    shift+ctrl+tab displays the previous tab
    ctrl+n where n is the digit 1 to 8 displays the nth tab
    ctrl+9 displays the last tab
    ctrl+w closes the current tab


Searching within a page 

    Use / to open the Quick Find bar
    Type the search text
    Use F3 to cycle forward and shift+F3 to cycle backward through the matches


'Clicking' on links

    Use ' to open the Quick Find bar for links only
    Type the search text
    Use F3 and shift+F3 to cycle to focus the link you desire
    Hit enter to 'click' the link. The following modifiers are available:
        
            shift - open the page in a new window
            ctrl - open the page in a new tab
            alt - save the page instead of opening it
        
    



Changing Your Domain Password When Your PC is not on the Domain
2009-12-26T08:52:00.000-08:00
Recently, I had to change my domain password from a desktop wasn't on the domain. The solution I found was to terminal service into a server with my domain account and use Ctrl+Alt+End to bring up the Windows Security menu and select Change Password.

This took me way longer to figure out than I'd like to admit.



?? Operator Precedence in C#
2009-12-19T06:07:00.000-08:00
I've been stung by this a few times in the last month.

The ?? (Null coalescing operator) has a really low precedence in C#. It's well below the arithmetic operators. In fact, it's second from the bottom according to MSDN. For some reason, I expected it to be quite high.

Take this code as an example.

    int? x = 10;
    int? y = 10;

    Console.WriteLine(x ?? y + 1);


Previously, I'd expect this to print 11. It actually prints 10 (since x ?? y + 1 is equivalent to x ?? (y + 1)).


Easy Backups with rsync: Part 3 of 3
2009-12-15T19:03:00.000-08:00
In this part we'll write a back up script and finish up.


Boot up off your USB flash drive. Now you need to figure out which drives you want to back up and what they are called in /dev. In puppy this is a piece of cake. An icon for each device is displayed at the bottom of the desktop. Clicking on the icon mounts the device as /mnt/<device name> and opens a file explorer on that drive. All you need to do is click through the devices until you find the ones you want.



Now you need to write the rsync script. Here is mine:


backup.sh
---------
rsync -rltDvP /mnt/sda1/Users/Henri/ /mnt/sde1/backups/windows/
rsync -rltDvP /mnt/sdc3/henri/ /mnt/sde1/backups/ubuntu/



I use this to backup the home directories on my Windows and Ubuntu partitions. Before I run this, I ensure that both sda1 and sdc3 are mounted and my backup drive is mounted at sde1. 


Note that the trailing slashes on the paths are important. Otherwise the source folder will copied into the destination.


The switches were chosen to make a copy of the source directory recursively(-r), with symlinks copied as symlinks (-l) and modification times preserved(-t). The verbose messages (-v) and progress indicators (-P) are turned on. This is equivalent to the archive (-a) option but without preserving permissions, ownership and file groups. Because I'm backing up onto a NTFS drive, those options don't work correctly. (Ultimately I'll add the --delete flag to delete files in the destination not present in the source.)



Now save the script and you're ready. Once a week follow the steps given the Part 1 and your backups are sorted.



Easy Backups with rsync: Part 2 of 3
2009-12-07T11:26:00.000-08:00
In this part I'll give pointer on how to install some version of Linux onto a USB flash drive.

The idea is to be able to boot off the drive and run the backups from there. The set up must have "persistence" i.e. you need to be able to save files to the drive. Not every set up of Linux supports this - some of the Live USB versions are read-only. I use PuppyLinux because it's easy to set up and has quite a pleasant UI. There are many alternatives but most require quite a bit of effort to get working.

Get a smallish USB stick and follow the installation instructions over here.

In the next part, I'll detail how to write the backup script.



Easy Backups with rsync: Part 1 of 3
2009-11-29T00:23:00.000-08:00
The most important thing about a home backup strategy is to make sure that the back ups actually get done. You're more likely to get this right if your process is simple and easy and if you make it part of your routine.

My strategy is to maintain mirrors of my home directories on an external hard drive. The process uses only free software but takes some effort to get set up.

The process has 4 steps.


Shutdown
Boot up Linux off a flash drive
Plug in an external drive
Run a backup script


The backup script mounts the target drives and uses rsync to mirror the home directories on  them onto the external drive.

To set this up you need to:


Have an external drive with sufficient capacity
Have bootable flash drive with some flavor of Linux on it
Write a backup script


In the next post I'll detail how to get Linux on a bootable flash drive.



Book Review: The Mythical Man-Month
2009-11-03T21:12:00.000-08:00
I finished reading the Mythical Man Month last week. I bought the 20th Anniversary Edition
which includes the famous 'No Silver Bullet' essay and some updated content. This must be the oldest coding-related book I have ever bought - even that anniversary edition was published more than 10 years ago! 

The Mythical Man-Month has stood the test of time. In spite of it's age, it's still read and quoted today. If you've been a programmer for a decent length of time you will have come across discussions and references to it. This is the book that introduced Brooks' Law, Second-System Syndrome  and made the much debated recommendation to 'plan to throw one away'. It's also the second book on the Coding Horror recommended reading list. Baring in mind how fast technology changes, it is arguably a classic book in the true sense of the word.

That said, I have mixed feelings about MM-M. The book contains some timeless insights but, unfortunately, whole chapters are completely irrelevant to today's coders. The information is just too dated and obsolete. For example, there is a whole chapter about managing paper based documentation systems including tips about microfiche and page numbering.

Buy MM-M if you're looking for a historical perspective on the craft. If you're purely looking for a practical book on programming practices, try Code Complete
 instead.



Dude, Where's My Powershell 2.0?
2009-11-01T19:38:00.000-08:00
Yesterday, I installed PowerShell 2.0 but encountered some issues that had me scratching my head. After I installed it, I couldn't find it.

I grabbed the latest installer listed on download page and ran it. It completed and then... nothing. I checked under my start menu and I couldn't see any new items. I found the PowerShell 1.0 directory (C:\WINDOWS\system32\windowspowershell\v1.0) but I couldn't find a 2.0 directory. It looked as if the installer didn't install 2.0 at all!

After reading the release notes and some fussing, I found out that 2.0 was, in fact, installed. The short cuts are placed unders 'All Programs' > 'Accessories' and the new files are installed in the 1.0 directory over the previous version.

I wonder if anyone else was confused by this.



Live Expressions With Obtics
2009-10-18T09:08:00.000-07:00
I'm busy working on a WPF app that's replacing a Excel spreadsheet solution. It involves lots of summary stats (sums, averages etc.) against a set of items. As the items are editted the changes need to be detected and the stats have to be updated so that the user can see the affects of his changes.
The normal way of doing this is to make the items implement INotifyPropertyChanged and then listen to changed in the properties that the stats are dependent on. As the stats get more complicated this gets more and more complicated and error prone.
Obtics is a library that makes this much easier.
Take the following example:
public class Portfolio
{
  public Portfolio()
  {
    Holdings = new ObservableCollection<Holding>();
  }

  public ObservableCollection<Holding> Holdings { get; private set; }
}

public sealed class Holding : INotifyPropertyChanged
{
  private int quantity;
  private Stock stock;

  public int Quantity
  {
    get 
    {
      return quantity;
    }
    set
    {
      if (quantity == value) 
      {
        return;
      }
      quantity = value;
      OnPropertyChanged("Quantity");
    }
  }

  public Stock Stock
  {
    get
    {
      return stock;
    }
    set
    {
      if (stock == value) 
      {
        return;
      }
      stock = value;
      OnPropertyChanged("Stock");
    }
  }  

  private void OnPropertyChanged(string propertyName)
  {
    var handler = PropertyChanged;
    if (handler != null) 
    {
      handler(this, new PropertyChangedEventArgs(propertyName));
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;
}

public sealed class Stock : INotifyPropertyChanged
{
  private decimal price;

  public decimal Price
  {
    get
    {
      return price;
    }
    set
    {
      if (price == value) 
      {
        return;
      }
      price = value;
      OnPropertyChanged("Price");
    }
  }  

  private void OnPropertyChanged(string propertyName)
  {
    var handler = PropertyChanged;
    if (handler != null) 
    {
      handler(this, new PropertyChangedEventArgs(propertyName));
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;
}
If I want the value of the portfolio I can write this:

var portfolioValue = Obtics.Values.ExpressionObserver.Execute(() => porfolio.Holdings.Sum( x => x.Quantity * x.Stock.Price));
portfolioValue is of the type IValueProvider and portfolioValue.Value will give the current value of expression. The real magic is that Obtics analyzes the expression and automatically refreshes the value when the inputs change. In this example, adding and removing holdings, changing the holding quantities and even the stock prices will cause the value to update. If you did that by listening to the PropertyChanged events, it would take 10 times the amounts of code.

portfolioValue can also be cast to INotifyPropertyChanged, so porfolioValue.Value can be bound in WPF.




Deleting a Column's Default Constraints
2009-10-11T03:09:00.000-07:00
At work I recently had the problem where I needed to drop some columns that had default constraints which had generated names. Here is the set up:

CREATE TABLE ExampleTable ( 
    ExampleColumn int NOT NULL DEFAULT 0,
    OtherColumn int NULL)
GO

ALTER TABLE ExampleTable
    DROP COLUMN ExampleColumn
GO

Msg 5074, Level 16, State 1, Server HENRI-XP\SQLEXPRESS, Line 1
The object 'DF__ExampleTa__Examp__7E6CC920' is dependent on column 'ExampleColumn'.
Msg 4922, Level 16, State 9, Server HENRI-XP\SQLEXPRESS, Line 1
ALTER TABLE DROP COLUMN ExampleColumn failed because one or more objects access this column.
At this point I could have just dropped the constraint using the name in the error message, however I had to apply the same change to multiple databases with the same schema. Of course, the generated name was different for each database.



I ended up writing a procedure that would look up the default constraint given a table name and column name in the sys views and drop it. It's pretty simple here is the code: 

CREATE PROC dbo.DropDefaultConstraint
    @TableName sysname,
    @ColumnName sysname
AS
    DECLARE @defaultConstraintName sysname;

    SELECT @defaultConstraintName = OBJECT_NAME(default_object_id)
    FROM sys.columns
    WHERE object_id = OBJECT_ID(@TableName) and name = @ColumnName

    IF(@defaultConstraintName IS NOT NULL)
    BEGIN
        EXEC ('ALTER TABLE ' + @TableName + ' DROP CONSTRAINT ' + @defaultConstraintName);
    END;
GO
Of course, this isn't the kind of procedure you'd actually deploy to a production server, but it's handy anyway.


SharpDevelop Rocks
2009-09-30T21:17:00.000-07:00
I'm starting a little OSS project and was thinking about writing it with a free IDE. C# Express was my first thought but I decided to try out SharpDev. 



I last looked at SharpDev out a couple of years ago and wasn't too impressed. It seemed a quite unpolished and a little incomplete. Things have changed - alot! The latest version, 3.1, was released just last month and it's brilliant. It can do WPF apps. It has an integrated debugger. It supports IronPython. It even has a profiler!



I'm definitely using this thing.


Installing Easy_Install and setuptools on Windows 7 64-bit/Python 2.6
2009-09-06T05:47:00.001-07:00
This procedure worked for me.
Download ez_setup.py from the PEAK site. (I found it here: http://peak.telecommunity.com/dist/ez_setup.py.)
Run it!



Left Joins for 1 to 0..1 relationships in Linq
2009-04-05T12:31:00.001-07:00
Here is an example of doing a ‘left join’ between two classes with a 1 to 0..1 relationship between them.
We have an Employee class.
public class Employee
{
    public Employee(int id, int? bossId)
    {
         Id = id;
         BossId = bossId;
    }

    public int Id { get; set; }
    public int? BossId { get; set; }
}
And a collection of employees.
var employees = new[] {
    new Employee(1, null),
    new Employee(2, 1),
    new Employee(3, 2),
    new Employee(4, 2)
};
Each employee has 0 or 1 bosses.
Now to get a list of each employee and his boss, we can use the following linq query. (We want employee 1 to be in the list with a null boss.)
var result =
from employee in employees
join boss in employees
on employee.BossId equals boss.Id
into employeeBosses
select new {
    Employee = employee,
    Boss = employeeBosses.SingleOrDefault()
};
The trick is to perform a group join on the employee and his bosses and then use SingleOrDefault to collapse employeeBosses to a single item or null.

hwiechers

Stashing Changes in Mercurial

Recipe

Explanation

Comparison to Other Methods

Vim: Reading from stdin

Mercurial: Automatically pushing changes on commit

Moving the Windows User folder

Case classes in Python

UDFs and Underlying Schema Changes

Truth and Python 3: The 'and' and 'or' Operators

Truth and Python 3: The if statement

The else Clause

The elif Clauses

The if Statement in Full

Truth and Python 3: The bool Type

FireFox without a Mouse

Entering an Address

Searching

Navigating between tabs

Searching within a page

'Clicking' on links

Changing Your Domain Password When Your PC is not on the Domain

?? Operator Precedence in C#

Easy Backups with rsync: Part 3 of 3

Easy Backups with rsync: Part 2 of 3

Easy Backups with rsync: Part 1 of 3

Book Review: The Mythical Man-Month

Dude, Where's My Powershell 2.0?

Live Expressions With Obtics

Deleting a Column's Default Constraints

SharpDevelop Rocks

Installing Easy_Install and setuptools on Windows 7 64-bit/Python 2.6

Left Joins for 1 to 0..1 relationships in Linq

The `else` Clause

The `elif` Clauses

The `if` Statement in Full