Perfecting OO's Small Classes and Short Methods

"In The ThoughtWorks Anthology, a new book from the Pragmatic Programmers, there is a fascinating essay called “Object Calisthenics” by Jeff Bay. It’s a detailed exercise for perfecting the writing of the small routines that demonstrate characterize good OO implementations. If you have developers who need to improve their ability to write OO routines, I suggest you have a look-see at this essay. I will try to summarize Bay’s approach here.

He suggests writing a 1000-line program with the constraints listed below. These constraints are intended to be excessively restrictive, so as to force developers out of the procedural groove. I guarantee if you apply this technique, their code will move markedly towards object orientation. The restrictions (which should be mercilessly enforced in this exercise) are:"

Git and SourceSafe

Procedure for merging from POS-safe. (I documented elsewhere how to do the daily merge.)

1. Diff-tree from master to the desired merge point.
2. Check out the files marked as "M" or "D"
3. Merge desired merge point into master.
4. Check in the files marked as "M" or "D"
5. Add the files marked as "A".
   

Specific commands are here:

1. git diff-tree master POS-safe --name-status -r | tee files.txt
2. ./Python/VSSHelper.py -o -d files.txt
3. git merge POS-safe
4. ./Python/VSSHelper.py -i -d files.txt -c "VSS check-in comment."
5. Manually add files to SourceSafe. This should be easy in Visual Studio. If not, use the VSS client.
   

MSAGL: Microsoft Automatic Graph Layout (formerly known as GLEE)

"MSAGL: Microsoft Automatic Graph Layout

MSAGL is a .NET tool for graph layout and viewing. It was developed in Microsoft Research by Lev Nachmanson. MSAGL is built on the principle of the Sugiyama scheme; it produces so called layered, or hierarchical layouts. This kind of a layout naturally applies to graphs with some flow of information. The graph could represent a control flow graph of a program, a state machine, a C++ class hierarchy, etc."

This was formerly known as GLEE:

"GLEE: Graph Layout Engine
GLEE: Graph Layout Execution Engine Tool purpose GLEE is a .NET tool for graph layout and viewing. It has been developed in Microsoft Research by Lev Nachmanson
http://research.microsoft.com/users/levnach/GLEEWebPage.htm"

Terminal Services Group Policy (how to set timeouts for remote sessions)

How to configure remote desktop (terminal services) to prevent idle users from using up the precious connections.

It's so freaking NON-obvious how to get to the Group Policy Object Editor.

Run this:

C:\WINDOWS\system32\mmc.exe C:\WINDOWS\system32\gpedit.msc

Version Control for Multiple Agile Teams

Sorting for Humans : Natural Sort Order

How to solve the following problem when comparing or sorting strings:
1.1
1.10
1.11
1.2
etc.

1.2 should come *before* 1.10, etc., but in a naive sort it does not.

See also the C# code he cites: http://www.interact-sw.co.uk/iangblog/2007/12/13/natural-sorting

Subversion Authentication With a Windows Domain

Really quite easy, according to a colleague.

Git stuff - Git.Net and "Why DVCS Matters to you today"

Why Distributed Version Control Matters to You, Today - Has groovy diagrams and pictures.

Application for Google Summer of Code 2008, Mono Project - Git.Net. Fantastic idea!

Knowing when to ask for help - Microsoft SharedView

Cool!

Technology Review: Blogs: Ed Boyden's blog: How to Think

Technology Review: Blogs: Ed Boyden's blog: How to Think: "When I applied for my faculty job at the MIT Media Lab, I had to write a teaching statement. One of the things I proposed was to teach a class called 'How to Think,' which would focus on how to be creative, thoughtful, and powerful in a world where problems are extremely complex, targets are continuously moving, and our brains often seem like nodes of enormous networks that constantly reconfigure. In the process of thinking about this, I composed 10 rules, which I sometimes share with students. I've listed them here, followed by some practical advice on implementation."

Tactics for Reducing the Subjective Experience of Down Time

"Time indicators

The formulae below all depend on use of a time indicator. The following choices of time indicators are listed from most to least desirable.

1. Estimated and remaining-time indicator. Place this either in a modal dialog or in the status bar at the bottom of the window.
2. "The system is alive" indicator. When it is impractical to offer the actual times, show an animated object that will let users know the system has not frozen. For longer waits, choose the rolling barber pole often found in status bars or other large animated object. For shorter waits (less than 10 seconds), you may use, instead, an animated "wait" mouse pointer, such as a spinning ball or animated hour glass.
3. "I hear and understand" indicator. When the expected wait is of short enough duration (less than 2 seconds) that displaying elapsed time, etc., is meaningless, display the hour glass."

7 Food Hacks to Stay Alert Without Caffeine

Kinda cool.

How-To: vmware-tools hgfs module on Ubuntu Gutsy Gibbon (7.10)

Arg. Doesn't work out of the box, disallowing you to use shared directories. Luckily this guy provided a way to fix it!

Intercepting method calls in C#, an approach to Aspect-Oriented Software Development

Cool! Roy Osherove used this to develop XtUnit, an NUnit addin which implements database rollbacks, described here. He uses System.Transactions.TransactionScope, which is a .NET facility for creating transactable components. Tres cool, no?

.NET Makes Window Subclassing Easy - Tap into Windows OS messages

NativeWindow -- kinda cool.

Community Pricing for goods (books, specifically)

This is something like an auction, no? Very interesting concept.

http://radar.oreilly.com/archives/2008/02/community_pricing_for_books.html

Git: Viewing history of one file

How cool is this?

gitk HEAD -- filename

Git stuff

From Wincent: his git knowledge base.
Git for computer scientists.

Signs of a Bad Boss (seen by me in the wild)

A certain someone at a certain company fit this to a T.

Bosses are supposed to ask themselves these questions:

1. Have you ever publicly criticized an employee?

2. Do you take credit for your employees’ work?

3. Do your employees fear you?

4. Do you expect employees to do what you tell them without question?

5. Do you believe employees should know what to do without you telling them or providing guidelines?

6. Are you a yeller?

7. Do you demean employees as a form of punishment?

8. Do you play favorites?

9. Do you hate delegating?

10. Do you check everyone’s work?

How to find files that are different between two git trees (working with git and, *gulp*, SourceSafe)

I do this a lot in my project. I change a bunch of files, and since I'm working with SourceSafe, I need to know which files to check out of SourceSafe so that I can replace them with the changed versions.

Use this command:

git diff-tree -r --name-status branch1 branch2

where branch1 is the branch I'm going to check into SourceSafe and branch2 is the upstream branch.

Example:

/c/Yellowstone.master
$ git diff-tree -r --name-status master POS-safe
M       Databases/OpenBook/Alter Scripts/THE ONLY 2.2 ALTER SCRIPT YOU NEED.sql
M       OpenBookSolution/HotL/DirectBillPaymentForm.cs
M       OpenBookSolution/HotL/EditReservationForm.cs
M       OpenBookSolution/HotL/NonGraphicalReserveForm.cs
M       OpenBookSolution/HotL/OpenBook.cs
M       OpenBookSolution/HotL/ReportForms/ReportSelectorForm.cs
M       OpenBookSolution/HotL/SelectDirectBillAccountForm.cs
A       OpenBookSolution/HotLOnly.sln
D       OpenBookSolution/HotLOnly/HotLOnly.sln
M       OpenBookSolution/Yellowstone.OpenBook.BusinessEntities/MonetariesBusinessEntity.cs

/c/Yellowstone.master
$

The basic procedure is:

1. hack hack hack
2. Get my tree in good shape, usually by rebasing my branch onto the SourceSafe tracking branch.*
   
3. Run the diff-tree command above to find changed files.
4. Check out those files. If there are any warnings from SourceSafe about the files being different (and not just writable), then do the following:
1. Get latest from SourceSafe into the SourceSafe tracking branch (typically "master") in my project.
2. Commit.
3. Go back to step 2 above.
   
5. Merge development branch into master. Sometimes I do this step a commit or three at a time instead of an en masse merge of the branch all at once.
   
6. Check changed files back into SourceSafe.
   

*I realize that rebasing my development branch onto "master" probably isn't the wisest thing in the world, as it loses information -- specifically, the fact that I had branched the code. It was an interesting experiment, though. Perhaps I'll go back to merging again. Although the fact that we're using SourceSafe, which doesn't have the concept of a branch, probably means that what I'm doing isn't all that un-kosher.

The flavor of git I use is msysgit.