Develocity

How to Find and Land a .NET Development Job

2010-07-17T06:57:00.001-07:00

My developer job resource kit is now available. It's called "Shove It, FizzBuzz: How to find and land a .NET development job."

What's included in this kit?

The kit includes a 200+ page eBook (PDF) that teaches you how to get the job you want (and will make you a better developer in the process). It contains tips on improving your overall developer marketability, 110+ technical questions (with answers), plus general interview questions, puzzle questions, and more.

The kit also includes software that simulates an actual interview and can help boost your confidence during the real thing. You could also just use the software to keep yourself on top of the latest technologies.

Last, but not least, the kit includes a customizable resume (in Word format) that has proven to be effective at getting people jobs.

http://shoveitfizzbuzz.com

Repeating and aligning elements using jQuery and CSS

2010-05-14T14:37:00.001-07:00

Today I had a need to create a dynamic list of checkboxes, and I wanted them all aligned properly, so the results would look something like this:

The layout was simple with CSS, then I added some jQuery to simulate getting the checkbox items dynamically.

Example:

<html>
<head>
    <title>Simple repeater</title>
    <style type="text/css">
    .repeater { list-style-type: none; }
    .repeater li { float: left; width: 150px; }
    </style>

    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js" type="text/javascript"></script>
    <script type="text/javascript">
    $(document).ready(function()
    {
        var names = ["Tanya", "Julia", "Avery", "Dave", "Robert", "Howard", "Greg", "Scott"];
                     
        for (i = 0; i < names.length; i++)
        {
            $("#peopleCheckboxGroup")
                .append("<li><input type='checkbox' />" + names[i] + "</li>")
        }
    });
    </script>
</head>
<body>
    <ul id="peopleCheckboxGroup" class="repeater"></ul>
</body>
</html>

That example produces a list that adjusts appropriately when resized:

ASP.NET Chart Controls Without Web Forms

2010-04-26T10:50:00.001-07:00

I started tinkering with the ASP.NET chart controls last week for a project at work, and the samples available from Microsoft are excellent, except they're mostly all using web forms. So I took it upon myself to do a few things:

Upgraded the existing samples from .NET 3.5 to .NET 4.0.
Added a sample project 'ChartsWithoutWebForms' to show one way to utilize the ASP.NET charts without using web forms at all.
Added a sample project 'ChartsWithMVC' to show one way to utilize the ASP.NET charts with the ASP.NET MVC framework.

The basic idea behind the two additional projects is that the chart is rendered as an image, which means you lose some interactive functionality, but my examples show that you can still fake some interactivity.

I also have an example that shows how you might create a dynamic charting system, which is actually what I'm working on now, but the work is venturing into an area where it will be specific to my employer, so I want to release the samples before that happens.

Feel free to take these updated samples and use them as you see fit. Hopefully they will help you out.

You can download the samples here:
http://www.downcastsystems.com/files/ChartSamples.zip

C# 4.0 dynamic Intellisense : a letter to the C# designers

2008-11-04T20:59:00.001-08:00

I just emailed this to Eric Lippert:

I want to express my concern with the new dynamic language features in C# 4.0.

I think it is important to enable duck-typing along with this feature; possibly by enabling a "fake" cast to an interface. My proposal is below.

public class Person
{
  public string Name { get; set; }
}

public class Fruit
{
  public string Name { get; set; }
}

public interface INamed
{
  string Name { get; set; }
}

public static class Program
{
  public static void Main()
  {
    // these types may be defined in any language; possibly from Ruby, etc.
    // the cast to INamed is "fake"; used only to enable intellisense since actual member resolution is dynamic
    dynamic p = new Person() { Name = "John" } as INamed;
    dynamic f = new Fruit() { Name = "Apple" } as INamed;

    // would get intellisense after "." provided by the INamed interface
    Console.WriteLine(p.Name);
    Console.WriteLine(f.Name);
  }
}

Balsamiq makes mocking up fun!

2008-09-29T15:02:00.000-07:00

Robert sent me a link last week to a new mockup tool called Balsamiq. At first, I didn't really see the point, but after using it for only a few minutes, I was totally sold.

What is it?

Have you ever tried to use Visio to mockup UI? It's a cumbersome process, and no matter what I do, the end result just always looks like a bunch of circles and squares and nothing like what I actually envisioned.

Balsamiq has some ready-made controls that you can easily drop onto your canvas. They look hand drawn, which is absolutely wonderful because then when I show people my mockups, there will be no doubt that they're simply looking at a mockup and not the final version.

Why is it useful?

I was just playing around with Balsamiq for a few minutes and made a quick screen showing a new feature we want to implement. I showed it to Robert, and we found out instantly that I was going about it the wrong way. Imagine if I'd mocked that up in HTML, or in Photoshop? It would have taken me a lot longer, and it would have been harder to modify after my initial mistake. Since I used Balsamiq, i was able to just move the controls around. So it saved me a lot of time and aggravation.

Another Example

We have to implement a way for color blind users to use our web application, so we've been asked to add "Color Schemes" to the User Settings. The user can have an underline or a box around particular fields on the form. The box background color or underline color is affected by changing color schemes.

At first, I thought, the simplest thing to do would be to simply provide a drop-down list of named color schemes with a preview below, so I mocked it up, and it looked like shit. Then I remembered the way Digsby and now the new Windows Live Messenger 9 Beta showed some of the custom UI settings, so I tried to emulate it a bit. (The horizontal rule control in Balsamiq isn't colorable yet, but the author says he's added to his upcoming feature list.)

Also, I just want to note that I've emailed the author twice, and he responded back within a few minutes each time. That's impressive.

Check it out:

http://www.balsamiq.com

Unnecessary Iffage

2008-05-02T08:27:00.001-07:00

A friend of mine showed me an example of the kind of bad code he finds every day where he works:

There are a lot of things wrong with the example above. Le'ts pick it apart and simplify.

1. This line is unnecessary:

You could just use SomeBooleanFunction in place of someBooleanValue in the example above, like so:

2. " = True" is unnecessary. The function already returns a boolean value. Get rid of it:

3. anotherBooleanValue is also unnecessary. We could do away with it and return the value immediately from the If statement, like so:

4. In fact, almost all of it is unnecessary:

How does this happen?

Why didn't the programmer just use the existing SomeBooleanFunction() instead of creating a new method that does the exact same thing? I bet I know.

I suspect the original programmer didn't know that SomeBooleanFunction() existed until after he'd already duplicated the same logic in MyBooleanFunction(). Once he found out that SomeBooleanFunction() was there, he wanted to use it, but didn't want to change all the code that was already using his new MyBooleanFunction().

A simple find/replace could have solved his problem, but he may have been afraid to change too much. That's not a good excuse, I know. I'm just sayin'.

Programming Books Usually Suck

2008-04-29T08:33:00.001-07:00

Jeff Atwood over at Coding Horror is always going on about how programmers don't read programming books because most of them suck, and I agree with that. I personally have only read about three really good ones.

In Jeff's post, he mentioned (as an example of poor writing) a book called Perl for Dummies. I followed through to the linked review, and it was great. So I wanted to point out a few of the best (of the worst) examples, as I think programmers who are writing should take notice of these kinds of things.

When there are simple and difficult explanations, you can usually count on Hoffman to find the difficult explanation, and then to tell you how difficult is. For example: (page 93)

int can be a bit tricky because it rounds down for positive numbers and rounds up for negative numbers.

He's right; that is tricky. Wait, which was does it round again? Up, down, positive, negative, I can't remember. But if he had said

int is very simple: It throws away the fractional part of a number, leaving the integer part.

then it is a lot easier and you understand the name so that next week you might remember what it does. Another example of this: In the ill-advised explanation of xor, he says

The operator returns true if the two things have different truth values but returns false if they have the same truth value. (See table 8-2.)

Here's the simple version:

$soup xor $salad is true if either $soup or $salad is true, but not both.

Then you dispense with the table.

Part of the reason Robert and I do Develocity is because we are always finding terrible sample code out in the wilds of the Internet, and it's teaching programmers the wrong ways to do things. It's scary to think people are filling books with the same sort of nonsense.

I'm not a programming expert, and I make my share of mistakes too, but before I post sample code that other people are going to look at and possibly use, I will go through it a few times, seeing if it can be made simpler and easier to understand.

Most examples have too much noise. A "Hello, World" example should do nothing but print "Hello, World" to the screen. Don't add any for loops or random number generators to it.

Learn and Practice LINQ With LINQPad

2008-04-13T18:50:00.001-07:00

LINQPad is a free tool that lets you query your databases using LINQ syntax in an IDE similar to a poor man's SQL Management Studio. It comes packed with 200+ examples.

You can also use it as a code snippet compiler, but I think Snippet Compiler is better suited for that, as LINQPad doesn't have Intellisense at the moment.

http://www.linqpad.net/

Development-Related Uses For Screencasts

2008-04-11T13:11:00.001-07:00

I’ve started using a program called Jing recently. It can record a video of what's currently on your screen.

Possible uses:

Show managers or project sponsors the current state of your in-progress application without giving them access to the version on your machine (that you might accidentally break since you're still working on it).
When a new feature is created, developers could create a video that shows the QA team what the new feature is supposed to do.
When the new feature doesn't work, the QA team can show the developers the steps necessary to reproduce the problem. (Most of the time, a simple text description isn't enough.)
I have a friend who wants to show his users in Asia how to use certain features of his application.
I have another friend who wants to record the repetitive (yet somewhat complicated) tasks he’s currently doing, so he can show someone else how to do those tasks.
Project sponsors could keep customers (internal and external) abreast of new changes to an application via a blog and show off those changes with an embedded screencast.

If you want to get really fancy, you could even create tutorial videos like the kind you see on www.asp.net, but I think a program like Camtasia Studio would probably be better suited to that, as Jing has a 5 minute limit on any videos created, and there is no way to edit the videos it creates.

Also, because I don't want to divulge any company secrets, I'm not sharing my videos to Screencast.com, Jing's default video destination. I set it up to save a file on my hard drive, so that I can attach it to an email or TFS work item.

Jing is free and extremely easy to use.

http://www.jingproject.com/

How To: Hide a Button When Clicked on an ASP.NET Page Containing Validation Controls

2008-04-11T08:17:00.001-07:00

Suppose you have a form with some ASP.NET validation controls on it, and you want to prevent users from clicking the form's submit button more than once.

It might sound easy at first. Just add some javascript to the asp:Button's OnClientClick to hide the button and show your custom message:

<script language="javascript" type="text/javascript">
function DisableButton(button)
{
    button.style.display = 'none';
    document.getElementById('loading').style.display = 'inline';
}
</script>

<asp:Button ID="LoginButton" runat="server" Text="Login" OnClientClick="DisableButton(this)" />
<span id="loading" style="display: none;">Logging in...</span>

Except if you do that, and you're using ASP.NET validation controls on the page, your user could end up in a situation like this:

Now your user is stuck because the Login button is gone!

So, this is how to get around that:

<script language="javascript" type="text/javascript">
function DisableButton(button)
{
    Page_ClientValidate();
    if (Page_IsValid)
    {
        button.style.display = 'none';
        document.getElementById('loading').style.display = 'inline';
    }
}
</script>

In the script above, you'll notice I'm using a Page_ClientValidate() method and a Page_IsValid boolean variable. Those are exposed as part of ASP.NET's Client-Side Validation API.

What's happening:

Page_ClientValidate() forces the validation to happen immediately.
If the validation tests pass (Page_IsValid), hide the button, show the message, and submit the page.
If the validation tests fail, ASP.NET will handle showing the validation errors for you, and the page will not be submitted.

For more information on ASP.NET Validation, see this article on MSDN:
http://msdn2.microsoft.com/en-us/library/aa479045.aspx

Enhancing C#'s switch statement with a fluent API

2008-04-04T20:02:00.001-07:00

A colleague pointed me to this article today. It shows a very clever set of utility classes that can dramatically improve the usefulness of the "switch..case" concept. Since the C# language can't be extended, it is implemented as a fluent API that tries to mimic the built-in switch statement.

The most interesting use to me is the generics-based double dispatch using delegates that enables a sort of visitor pattern:

void Do(Control c) 
{ 
     new Switch(c) 
          .Case<Label>(l => 
          { 
               // ... 
          }) 
          .Case<Button>(b => 
          { 
               // ... 
          }) 
          .Default(cc => 
          { 
               // ... 
          }); 
}

An interesting oddity of the implementation is that the various Case() overloads are implemented as Extension methods on the Switch types. That is the only thing I don't like in the linked article. It exploits a "feature" of Extension methods that sorta allows you to call methods on null references. The case "statements" (method calls) are short-circuited by returning null and additional calls to Case() check for the null "this" pointer (the fake "this" which is the first parameter to extension methods) and exits quickly. To me, this seems like abuse of extension methods since the same thing can easily be accomplished with a traditional class.

Here is a modified version of the Switch<T> class implemented as a simple class without the extension methods:

public class Switch<T>
{
    public T Object { get; private set; }
    private bool hasBroken = false;

    public Switch(T obj)
    {
        this.Object = obj;
    }

    public Switch<T> Case(T other, Action<T> action)
    {
        return this.Case(other, action, SwitchBehavior.Break);
    }

    public Switch<T> Case(T other, Action<T> action, SwitchBehavior behavior)
    {
        return this.Case(x => object.Equals(x, other), action, behavior);
    }

    public Switch<T> Case(Func<T, bool> condition, Action<T> action)
    {
        return this.Case(condition, action, SwitchBehavior.Break);
    }

    public Switch<T> Case(Func<T, bool> condition, Action<T> action, SwitchBehavior behavior)
    {
        if (!this.hasBroken && condition(this.Object))
        {
            action(this.Object);
            if (behavior == SwitchBehavior.Break)
                this.hasBroken = true;
        }

        return this;
    }

    public void Default(Action<T> action)
    {
        this.Case(t => true, action, SwitchBehavior.Break);
    }
}

public enum SwitchBehavior { FallThrough, Break }

A functional C# (type)switch - B# .NET Blog

Javascript: More than meets the eye...

2008-04-04T17:06:00.001-07:00

I recently ran across a presentation on InfoQ by Glenn Vanderburg called "The Power of Javascript" that was recorded at JAOO.

Summary
Glenn Vanderburg makes the case for Javascript, a language long overlooked. This presentation from JAOO 2007 shows how its OOP model and other language features make it a very powerful tool and how to use these features to get the most out of the language.

The presentation describes how Javascript got its name - starting out as LiveScript developed by Netscape and later rebranded as Javascript to exploit the popularity of the new kid on the block - Java, developed by Sun. He explains why it is commonly considered to be a "toy language" and why it isn't.

A while ago I posted the first in a series of articles about javascript. Since then I've been somewhat stingy in releasing the other proposed articles. I'll try to get back into the swing of things promptly.

Sorting a Generic List of Custom Objects Simply

2007-11-15T08:50:00.001-08:00

For a defect I was working on today, I just wanted to sort a list of users by username in a very simple fashion.

Google failed me. I wasn't able to find a good example of how to do this easily in VB.NET. As usual, most examples are full of noise, like this, this, this, or that.

So, once I figured out how to do it, I thought I should share it.

First, we create a function to handle our comparison.

Private Function UsernameComparer(ByVal x As User, ByVal y As User) As Integer
    Return x.UserName.CompareTo(y.UserName)
End Function

Next, we use it.

myUserList.Sort(AddressOf UsernameComparer)

Now our user list is sorted by username.

In C# 2.0, using anonymous methods, it can even be done all at once:

myUserList.Sort(delegate(User x, User y) { 
    return x.UserName.CompareTo(y.UserName); 
});

If you know of an even simpler way to do this, leave some comments and let us know!

MSDN code examples are terrible

2007-10-17T13:47:00.001-07:00

This is the page that really got my goat. I'll list the relevant parts here for ease of reading.

Page.RegisterOnSubmitStatement Method

Allows a page to access the client OnSubmit event. The script should be a function call to client code registered elsewhere.

   1: '[Visual Basic]    2: Dim scriptString As String = "<script language=JavaScript> function doClick() {"   3: scriptString += "document.write('<h4>' + myForm.myHiddenField.value+ '</h4>');}<"   4: scriptString += "/" + "script>"   5: RegisterHiddenField("myHiddenField", "Welcome to Microsoft .NET!")    6:     7: RegisterOnSubmitStatement("submit", "document.write('<h4>Submit button clicked.</h4>')")    8:     9: RegisterStartupScript("startup", scriptString) 

   1: //[C#]    2: void Page_Load(Object sender, EventArgs e)    3: {    4:    String scriptString = "<script language=JavaScript> function doClick() {";   5:    scriptString += "document.write('<h4>' + myForm.myHiddenField.value+ '</h4>');}<";   6:    scriptString += "/" + "script>";   7:    RegisterHiddenField("myHiddenField", "Welcome to Microsoft .NET!");    8:    RegisterOnSubmitStatement("submit", "document.write('<h4>Submit button clicked.</h4>')");    9:    RegisterStartupScript("startup", scriptString);  10: } 

Ok, how many things can you find wrong with this simple example?

string concatenating to make a script block

a bunch of totally unrelated code that muddies the point

document.write() - who does that?

VB and C# code don't even match; C# includes the method declaration; VB only includes the method body

scriptString += "/" + "script>"

definition says "The script should be a function call to client code registered elsewhere." but that is not what the example code does

Here's my stab:

   1: //[C#]    2: void Page_Load(Object sender, EventArgs e)    3: {    4:   if (!IsClientScriptBlockRegistered("doClickScriptKey"))   5:   {   6:     String scriptString = @"   7:     <script type='text/javascript'>   8:         function doClick() { alert('the form is about to submit!'); }   9:     </script>";  10:     RegisterClientScriptBlock("doClickScriptKey", scriptString);  //"registered elsewhere"  11:   }  12:   RegisterOnSubmitStatement("submitScriptKey", "doClick();"); //"function call to client code registered elsewhere"  13: } 

Conversation about Patterns, Developers, and whatnot

2007-09-14T20:13:00.001-07:00

(9:10 PM) Robert:

how's the job going this week?

(9:11 PM) Daniel:

better actually, we're digging into this arcade game
and I'm starting to understand things more

(9:11 PM) Daniel:

but its all-consuming in my head, i can't seem to think about anything else
i.e. dave's game

(9:12 PM) Robert:

that's understandable

(9:12 PM) Daniel:

I really want to help dave though, cause I want him to finish it

(9:13 PM) Daniel:

maybe on the weekends I'll have time

(9:24 PM) Robert:

i hate words that have extraneous letters
such as Lincoln

(9:24 PM) Robert:

what's that second L doing in there?

(9:24 PM) Daniel:

just hangin out man

(9:24 PM) Robert:

nobody says "Leen-koln"

(9:25 PM) Robert:

back to programming a bit...

(9:25 PM) Daniel:

I feel your pain

(9:25 PM) Robert:

have you read about "design patterns"?

(9:26 PM) Robert:

(along with "anti-patterns")

(9:26 PM) Daniel:

I'm staring at a book called Design Patterns at this very moment

(9:26 PM) Daniel:

not reading it, its on the table

(9:26 PM) Robert:

"Elements of Reusable Object-Oriented Software"?

(9:26 PM) Daniel:

you're meaning things like the factory method, singletons...etc

(9:27 PM) Robert:

yeah

(9:27 PM) Daniel:

yeah, that's the one

(9:27 PM) Robert:

cool

(9:27 PM) Daniel:

dedrick had it in the office and I'm borrowing it

(9:27 PM) Robert:

you're already light-years ahead of most developers

(9:27 PM) Robert:

of your own accord or upon his suggestion?

(9:28 PM) Daniel:

no, I've been wanting to learn about them

(9:28 PM) Daniel:

and it turns out he had just the book I was going to buy

(9:28 PM) Robert:

i was teaching Greg at work about the Strategy pattern today

(9:29 PM) Daniel:

I guess I don't know greg

(9:29 PM) Robert:

you don't

(9:29 PM) Daniel:

but yeah, I've been wanting to read up on the patterns for awhile now
after learning they existed

(9:29 PM) Robert:

do you know if that book also talks about "anti-patterns"?

(9:29 PM) Daniel:

not sure

(9:30 PM) Daniel:

not in the index
anyway

(9:32 PM) Daniel:

I don't understand something

(9:33 PM) Daniel:

you mention a lot that most developers don't do this, or know about that
but jeez, what do they know?

(9:33 PM) Robert:

they know how to write "spaghetti code" until it just barely works

(9:34 PM) Robert:

"spaghetti code" is probably what your early expirements looked like

(9:34 PM) Daniel:

that sucks, they don't even want to make it good?

(9:34 PM) Robert:

nope
they are victims of "good enough"

(9:37 PM) Robert:

http://www.amazon.com/AntiPatterns-Refactoring-Software-Architectures-Projects/dp/0471197130/ref=pd_bbs_1/104-0707808-5144724?ie=UTF8&s=books&qid=1189647010&sr=1-1

(9:37 PM) Daniel:

I guess I don't have enough time working with dedrick and the other guy to see what they're attitude is, they seem to be okay

(9:38 PM) Daniel:

sounds like a funny book
interesting

(9:39 PM) Robert:

this is the exact reason why i think i told you before - i'd rather hire a mediocre-but-passionate dev than a well-trained-but-unmotivated dev

(9:39 PM) Daniel:

I can see that

(9:40 PM) Daniel:

do you ever get input on who your company hires?
give input

(9:41 PM) Robert:

passion begets constant improvement and excellent developers that can encourage other devs

(9:42 PM) Robert:

lack-luster begets wasted time/effort and code that is difficult to maintain
no

(9:43 PM) Robert:

though i was asked to write a small code-snippet that would be presented to interveiwees to see what they understand about it
i'll show you - you won't get it - it's probably too difficult

(9:43 PM) Daniel:

(9:46 PM) Robert:

    static class Foo<T> where T : new()
    {
        private static T bar = new T();
        public static T Bar
        {
            get { return bar; }
        }
    }
that's the whole class, and it's quite useful

(9:47 PM) Daniel:

ok, let me look

(9:47 PM) Robert:

i had to replace real names with Foo and Bar or else you'd know right away

(9:48 PM) Daniel:

don't tell me

(9:49 PM) Robert:

the point of the code in the interview isn't to see if you get it right, it's to see how much of it you can explain

(9:50 PM) Daniel:

it looks like a generic class that just makes things
to me

(9:50 PM) Daniel:

some parts of the code confuse me however

(9:51 PM) Robert:

explain...

(9:51 PM) Daniel:

explain what I don't understand?

(9:51 PM) Robert:

yeah

(9:52 PM) Daniel:

in the class heading, you have "where T : new()
I don't get that

(9:53 PM) Daniel:

maybe I'm just reading it wrong

(9:54 PM) Robert:

that is a "generic type parameter constraint"

(9:55 PM) Robert:

it say's "you can use any T as long as it has a default public constructor"

(9:55 PM) Daniel:

I see

(9:55 PM) Daniel:

is this an object factory?

(9:56 PM) Robert:

if a type only had a private constructor or the only public constructor (abbrv. "ctor") requires any parameters

(9:56 PM) Robert:

that's close - it's a very special type of "factory"

(9:57 PM) Robert:

want me to explain?

(9:57 PM) Daniel:

yeah, don't think I can get any closer

(9:58 PM) Robert:

hint: it's not building very many objects - "new T()" is only called once

(9:59 PM) Daniel:

a singleton?

(9:59 PM) Robert:

yep
it externalizes the concept of "singleton" to a separate generic class

(9:59 PM) Robert:

you would use it like this:

(10:00 PM) Robert:

WizardGame game = Singleton<WizardGame>.Instance();

(10:00 PM) Robert:

the Singleton class (Foo) ensures that there is only one

(10:01 PM) Daniel:

how does it do that?
what prevents you

(10:08 PM) Robert:

brb; putting dishes away

(10:09 PM) Daniel:

(10:36 PM) Robert:

hey
i'm back

(10:37 PM) Daniel:

(10:37 PM) Robert:

every question you ask me tells me more about what you know and don't know about C#/.Net

(10:37 PM) Daniel:

(10:37 PM) Robert:

...as an interviewer

(10:38 PM) Robert:

at first, i knew that you at least understood the C# language at a basic level
and you understood the basic concepts of Generics

(10:38 PM) Robert:

but not some of the finer points (constraints)

(10:39 PM) Robert:

after my hint, i knew that you were familiar with the concept of "design patterns"

(10:39 PM) Daniel:

a lot of information from just a little bit of code

(10:40 PM) Robert:

and now i know that you aren't familiar with the intricacies of C#

(10:40 PM) Robert:

here's the non-obfuscated code:
    static class Singleton<T> where T : new()
    {
        private static T instance = new T();
        public static T Instance
        {
            get { return instance; }
        }
    }

(10:41 PM) Robert:

and now to answer your question...

(10:41 PM) Robert:

first, you have to understand that Singleton<Foo> is a different class than Singleton<Bar>

(10:42 PM) Daniel:

seems logical enough

(10:45 PM) Robert:

was looking up some terms i forgot for a second

(10:45 PM) Robert:

Singleton<T> is called an "open" generic type as long as T is undefined

(10:46 PM) Robert:

Singleton<Foo> is a "closed" generic type b/c T has been defined as Foo

(10:46 PM) Daniel:

(10:46 PM) Robert:

Singleton<T> == S<T> from now on

(10:46 PM) Daniel:

(10:47 PM) Robert:

so now that you know S<Foo> is a totally different class than S<Bar>...

(10:47 PM) Robert:

notice that the class is static - both member (field and property) are both static

(10:47 PM) Daniel:

I see

(10:48 PM) Daniel:

so you don't need an instance of the class, but it returns an instance
of T

(10:50 PM) Robert:

    class Foo
    {
        public object bar = new object();
    }
is basically the same as...
    class Foo
    {
        public object bar;
        public Foo()
        {
            bar = new object();
        }
    }

(10:50 PM) Robert:

first initializes bar inline; second initializes bar inside the constructor

(10:51 PM) Daniel:

I'm with you

(10:51 PM) Robert:

first is essentially converted to second when compiled

(10:51 PM) Robert:

C# guarantees that all fields will be initialized before any user-defined ctor code is executed

(10:52 PM) Daniel:

(10:52 PM) Robert:

    class Foo
    {
        public int bar = 3;
        public Foo()
        {
            bar = 2;
        }
    }

(10:52 PM) Robert:

in this case, bar is initialized to 3, then immediatly overwritten with 2

(10:53 PM) Daniel:

I see

(10:53 PM) Robert:

C# also guarantees that a static constructor will be executed exactly one time per class (per AppDomain)

(10:54 PM) Robert:

and that it will be executed immediatly before the first access of any static members of the class

(10:54 PM) Daniel:

does the constructor need an access modifier?

(10:54 PM) Robert:

static constructors can't have access modifiers

(10:55 PM) Robert:

instance constructors follow the same rules as other members - everything without an access modifier is private by default

(10:55 PM) Daniel:

ok
let me soak in what you wrote

(10:57 PM) Daniel:

so its the static keyword in the constructor that makes it the singleton

(10:57 PM) Robert:

the class i sent you doesn't even have an explicit constructor

(10:58 PM) Daniel:

oh, you're right

(10:58 PM) Daniel:

hmm

(10:59 PM) Daniel:

so the fact that its a static class then

(10:59 PM) Robert:

sorta - in C# a static class is just a way to ensure that all members are static
it doesn't mean much

(11:01 PM) Robert:

(in .Net 1.x they shipped with a class that was expected to be "static", but it had a public instance method and the only instance ctor was Private - that meant that there was no way for anyone to instantiate the class and use the public method - in .Net 2.0 they added the concept of a "static class" to prevent things like that in the future)

(11:02 PM) Daniel:

I see

(11:03 PM) Robert:

i have given you all the info you need to answer your orig. question

(11:04 PM) Robert:

(inline initialization == ctor initialization; static ctor is called exactly once and just before first access of any static member)

(11:06 PM) Daniel:

I get it

(11:06 PM) Robert:

you grok it?

(11:06 PM) Daniel:

no, I don't want to say I grok it until I've used it

(11:07 PM) Daniel:

so pretty much that's how you do a singleton in .net?

(11:08 PM) Daniel:

or is that across other languages as well?

(11:08 PM) Robert:

other languages/platforms have different intricacies
and that's not the normal way to do a singleton
it's my own invention

(11:08 PM) Daniel:

seems elegant

(11:09 PM) Daniel:

although I don't know the other way

(11:09 PM) Daniel:

I have a question for you

(11:10 PM) Daniel:

its C++ but more OOP specific

(11:11 PM) Daniel:

in the main class I'm doing at work, it has a bunch of functions that work with the member data

(11:12 PM) Daniel:

it basically has one method, and inside that method I've broken tasks down into their own methods

(11:12 PM) Daniel:

but since its all within the class I don't have to pass anything into these methods since I already have access to them

(11:13 PM) Daniel:

but it feels weird or something

(11:13 PM) Robert:

it's a bad habit

(11:13 PM) Daniel:

I thought so, but I wasn't sure

(11:14 PM) Robert:

unless the data (state) needs to be persisted even after the call to the "basically one method" then it should be passed to each method as needed

(11:15 PM) Daniel:

ok, I felt that was the right way
tomorrow I'll fix it

(11:16 PM) Daniel:

I mean I felt that passing parameters was the right way

(11:19 PM) Robert:

this is the conventional singleton pattern
    public class Foo
    {
        // prevents public instantiation
        private Foo() { }
        private static Foo instance;
        public static Foo Instance
        {
            get
            {
                // this is called the "double-checked locking" singleton pattern
                // it attempts to solve a "race condition" that may occur in multi-threaded systems
                if (instance == null)
                {
                    lock (this)
                    {
                        if (instance == null) // another thread could have assigned it since the previous check
                        {
                            instance = new Foo();
                        }
                    }
                }
                return instance;
            }
        }
    }

(11:20 PM) Robert:

http://www.ibm.com/developerworks/java/library/j-dcl.html

(11:21 PM) Robert:

"The bottom line is that double-checked locking, in whatever form, should not be used because you cannot guarantee that it will work on any JVM implementation."
same thing on the .Net platform

(11:23 PM) Robert:

"Listing 10" in that article is "good" but not great in .Net b/c it isn't lazy enough

(11:24 PM) Robert:

access to *any* static member will instantiate the "instance" field even though i may not be using it
anyway, it's bedtime
i think you've got enought for tonight

(11:24 PM) Robert:

i had fun teaching you

(11:24 PM) Daniel:

for sure, thanks

(11:25 PM) Daniel:

interesting how you merged our two topics
did you notice that?

(11:25 PM) Robert:

no?

(11:25 PM) Daniel:

we were talking about design patterns then about programmers you don't like, which lead to my question about how much input you have in the hiring

(11:26 PM) Daniel:

which lead to you giving me the example snippet you wrote for interviewees

(11:26 PM) Robert:

which went back around to patterns

(11:26 PM) Daniel:

which was about a singleton
:0-)
uh,

(11:26 PM) Robert:

i'm just good like that
goodnight

(11:26 PM) Daniel:

guess so, night

Object Oriented? You can't even define classes, can you?

2007-07-25T19:27:00.000-07:00

For some reason, unlike other modern languages, the ability to define custom types seems to be a Javascript language feature that is often passed over. Only advanced Javascripters seem to ever get around to learning about this underused feature. Defining a new type in Javascript is easy; you just have to get used to the syntax and understand that in Javascript, everything is an object; Functions are Objects, too.

   1: function Person(fname, lname)   2: {   3:     this._fname = fname;   4:     this._lname = lname;   5: }   6: var dave = new Person("Dave", "Haynes");

The code above defines a function called Person which takes two parameters; notice how it assigns the value of the parameters to a pair of expando properties on this. What is this?

First, notice the new keyword used in the assignment to dave. The new keyword basically calls the function in the context of a new object of type Person - this refers to that new object within the scope of the function. The function then adds new expando properties to this object, then the object is assigned to dave. You can consider the Person function to be both the constructor for and the definition of the Person type. Without the new keyword, the expando properties would be added to the global scope and dave would be assigned the return value of the traditional function call. Since the function doesn't have a return statement, it implicitly returns null.

Remember earlier when I said "Functions are Objects, too"? Let's expand the sample a bit...

   1: function Person(fname, lname)   2: {   3:     this._fname = fname;   4:     this._lname = lname;   5:        6:     this.GetFullName = function(){   7:         return this._fname + " " + this._lname;   8:     }   9: }  10: var dave = new Person("Dave", "Haynes");  11: alert(dave.GetFullName());

Now we have added a new expando property called GetFullName, but this time it is assigned a function that takes no formal parameters. This demonstrates that a function is an object just like everything else in Javascript. It can be passed around to other functions, stored in variables, garbage collected, etc.

Garbage Collection? That's gross!

2007-04-25T07:22:00.000-07:00

"Garbage Collection" probably sounds like a strange term if you've never heard of it before. So what is it? Well, you've all probably heard of a "memory leak" before. Garbage Collection, or GC, is essentially an attempt to prevent memory leaks. Back in the old days, developers had to be very diligent about cleaning up after themselves. If an object was allocated repeatedly but never "destroyed" or cleaned up the system would gradually use more and more memory until there was no more available memory and the application would crash.

Today, platforms like Java, .Net, Javascript, Perl, Ruby, and PHP have GC built-in. In platforms with GC, objects that are no longer referenced (because the reference has gone out of scope or because the variable was set to null) become eligible to be automatically destroyed and the memory used made available for new allocations. Notice that i said they become eligible; the objects are not immediately cleaned up when they go out of scope. The garbage collector only performs the collection when it is necessary, such as when the system is running low on memory.

Javascript has the ability to be garbage collected or to use explicit memory management when necessary or desired with the delete keyword. The two graphs below show the difference.

The first graph shows memory consumption over time while the garbage collector is allowed to manage the memory.

The second graph shows the same thing while the program manages it's own memory by explicitly deleting the objects when it is done with them.

   1: <%@ Page Language="C#" AutoEventWireup="true" Codebehind="Default.aspx.cs" Inherits="ItsJustJavascript._Default" %>

2:

   3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

   4: <html xmlns="http://www.w3.org/1999/xhtml">

   5: <head id="Head1" runat="server">

   6:     <title>Untitled Page</title>

   7: </head>

   8: <body>

   9:     <form id="form1" runat="server">

  10:         <div>

  11:             <button onclick="cancel = false; useMemory(false);">

  12:                 start (normal)</button>

  13:             <button onclick="cancel = false; useMemory(true);">

  14:                 start (self cleanup)</button>

  15:             <button onclick="cancel = true;">

  16:                 stop</button>

  17:             <br />

  18:             <input type="text" id="output" />

  19:         </div>

  20:     </form>

  21:     <script type="text/javascript">   1:  
   2:     var cancel = false;
   3:     var output = document.getElementById("output");    
   4:     
   5:     function useMemory(selfCleanUp)
   6:     {
   7:         if (cancel) return;
   8:         
   9:         output.value = (new Date()).toString();
  10:         for (var i = 0; i<100000; i++)
  11:         {
  12:             var foo = new Object(); //just consume a small amount of memory
  13:             foo.bar = new Object(); // and a bit more memory, plus an expando!
  14:             if (selfCleanUp)
  15:             {
  16:                 foo.bar = null;
  17:                 delete foo.bar;
  18:                 foo = null;
  19:                 delete foo;
  20:             }
  21:         }
  22:         
  23:         window.setTimeout("useMemory(" + selfCleanUp + ")", 1);
  24:     }
  25:     
</script>

  22: </body>

  23: </html>

Additional Info:

Garbage collection @ Wikipedia

Presto Expando

2007-04-23T06:31:00.000-07:00

It's hard to know where to start, but you've got to start somewhere, right?

JavaScript is a very dynamic language. That basically means that objects can be created and modified at runtime. It is also very loosely-typed which means that you can treat a string variable as an integer or an integer as a date, or a date as a string, or... well, you get the point.

So what do I mean by "objects can be created and modified at runtime"? In static languages, the members (attributes, properties, methods, etc.) and behaviors of a type are explicitly defined at design-time and then compiled. After compilation you cannot add or remove any of the members. I suppose you've already guessed what i'm going to say next. In dynamic languages (depending on the degree of dynamicism), any member can be added, removed, or replaced at runtime. In Javascript, members you add at runtime are commonly called "expando properties".

   1: var someObject = new Object();

2:

   3: //calls builtin toString method

   4: alert(someObject.toString());

5:

   6: // adding an attribute

   7: someObject.myExpando = "hello expando";

8:

   9: // replaces builtin toString method

  10: someObject.toString = function()

  11: {

  12:     return this.myExpando;

  13: }

14:

  15: // notice how the toString method has been replaced

  16: alert(someObject.toString());

17:

  18: // adding a new method to the new object

  19: someObject.tellTime = function()

  20: {

  21:     alert(new Date());

  22: }

23:

  24: someObject.tellTime();

25:

  26: //removing the method we just added

  27: delete someObject.tellTime;

28:

  29: //calling the method now will be an error

  30: try

  31: {

  32:     someObject.tellTime();

  33: }

  34: catch(e)

  35: {

  36:     alert(e.message);

  37: }

Additional Info:

It's just Javascript, right?

2007-04-20T18:29:00.000-07:00

Recently I realized that most developers I've known (and therefore, probably most developers in the world) think of Javascript as just:

a bunch of variables,
inline code in an onClick attribute, and
global methods on a webpage.

How many of you are saying "yeah, what else is there?"; raise your hands...

I'll discuss the language in more detail in a series that will start out simple and then build upon itself. Hopefully each episode will leave you dying to find out what happens next - like an episode of Lost or 24. Some of the episodes will be called:

Presto Expando
Garbage Collection? That's gross!
Boolean. Not the meat cubes; and not the gold bricks.
Object Oriented? You can't even define classes, can you?
Prototype? But hasn't Javascript been around for a while now?
Functional? Of course it is, I mean, I've seen it work.
What's in the Dictionary?
Who is this J[a]SON i've been hearing about?
The library formerly known as "Atlas"

Declarative vs. Imperative

2007-03-23T13:45:00.000-07:00

Recently i was talking to Michael Silver about declarative vs. imperative programming; he found an article on the topic saying that declarative programming is overrated and that "languages like Ruby" allow writing imperative code that "looks" and "feels" declarative. The article didn't give any examples, but Michael sent me an example using ActiveRecord to define a database schema.

   1: ActiveRecord::Schema.define(:version => 2) do   2:     3:   create_table "comments", :force => true do |t|   4:     t.column "body", :text   5:     t.column "post_id", :integer   6:   end   7:     8:   create_table "posts", :force => true do |t|   9:     t.column "title", :string  10:     t.column "body", :text  11:     t.column "created_at", :datetime  12:     t.column "author_name", :string  13:     t.column "comments_count", :integer, :default => 0  14:   end  15:    16: end

After a while of figuring out the semantics of the Ruby syntax, i realized that it isn't even a *language* feature that the article was touting - it's simply a "fluent API" which is apparently fairly common in Ruby libraries.

So I thought I would try to create a library in .Net that would "feel" very similar to the Ruby style.

So, here's the same code in VB.Net...

   1: With ActiveRecord.DefineSchema().AsVersion(2)   2:     3:     With .WithTable("comments").UseForce()   4:         .WithColumn("body").AsType(Of String)()   5:         .WithColumn("post_id").AsType(Of Integer)()   6:     End With   7:     8:     With .WithTable("posts").UseForce()   9:         .WithColumn("title").AsType(Of String)()  10:         .WithColumn("body").AsType(Of String)()  11:         .WithColumn("Created_at").AsType(Of Date)()  12:         .WithColumn("author_name").AsType(Of String)()  13:         .WithColumn("comments_count").AsType(Of Integer).UseDefault(0)  14:     End With  15:    16: End With

...and here's the same code in C#...

   1: ActiveRecord.DefineSchema(delegate(ARSchema s)   2: {   3:     4:     s.WithTable("comments", delegate(ARTable t)   5:     {   6:         t.WithColumn("body").AsType<string>();   7:         t.WithColumn("post_id").AsType<int>();   8:     }).UseForce();   9:    10:     s.WithTable("posts").UseForce(delegate(ARTable t)   11:     {  12:         t.WithColumn("title").AsType<string>();  13:         t.WithColumn("body").AsType<string>();  14:         t.WithColumn("Created_at").AsType<DateTime>();  15:         t.WithColumn("author_name").AsType<string>();  16:         t.WithColumn("comments_count").AsType<int>().UseDefault(0);  17:     });  18:    19: }).AsVersion(2);

The VB and the C# versions both take advantage of the language features. VB supports the With statement, while C# supports anonymous delegates. Both of these scenarios were enabled with overloaded methods within the same library.

How To Post Code From Visual Studio 2005 To Your Blog

2007-03-15T06:59:00.001-07:00

You would not believe how much time we've spent trying to find an easy way to post code samples to this blog. Research (via Google) has proven that we're not the only ones who have spent countless hours trying to do what should be very simple.

Now that we've figured out an excellent way to do it, we thought we'd share it with everyone else.

Step-By-Step Instructions:

1. Download, install, and run Windows Live Writer. Setup your blog following the wizard.

2. Download and install the Code Snippet Plugin for Windows Live Writer.

3. Open Visual Studio 2005.

4. Copy the code from Visual Studio 2005 that you want to post to your blog.

5. Switch to Windows Live Writer. Make sure you're in Web Layout mode. Click the link on the sidebar that says Insert Code Snippet.

6. When the Code Snippet window pops up, paste your code into the top window.

7. Be sure Embed Styles is highlighted (it's between the top and bottom windows). This will make it so that the code will retain its formatting on your blog.

The end result will look something like this:

public string SayHello(string Name)
{
    return "Hello: " + Name + "\n\nWe are glad you have decided to read posts on the Develocity blog. We are trying to bring you quality, helpful stuff on here.";
}

You can adjust the width and height of the code box from within Windows Live Writer.

That's it! It wasn't too painful, I hope.

The Ten Commandments

2007-03-13T18:06:00.001-07:00

(from http://builder.com.com/5100-6404-1045782.html)

What we need is a set of rules or guidelines to help developers keep themselves (their egos, actually) separate from their code. Hence our Ten Commandments for Egoless Programming, which you can also download in handy "stone tablet" format:

Understand and accept that you will make mistakes. The point is to find them early, before they make it into production. Fortunately, except for the few of us developing rocket guidance software at JPL, mistakes are rarely fatal in our industry, so we can, and should, learn, laugh, and move on.
You are not your code. Remember that the entire point of a review is to find problems, and problems will be found. Don't take it personally when one is uncovered.
No matter how much "karate" you know, someone else will always know more. Such an individual can teach you some new moves if you ask. Seek and accept input from others, especially when you think it's not needed.
Don't rewrite code without consultation. There's a fine line between "fixing code" and "rewriting code." Know the difference, and pursue stylistic changes within the framework of a code review, not as a lone enforcer.
Treat people who know less than you with respect, deference, and patience. Nontechnical people who deal with developers on a regular basis almost universally hold the opinion that we are prima donnas at best and crybabies at worst. Don't reinforce this stereotype with anger and impatience.
The only constant in the world is change. Be open to it and accept it with a smile. Look at each change to your requirements, platform, or tool as a new challenge, not as some serious inconvenience to be fought.
The only true authority stems from knowledge, not from position. Knowledge engenders authority, and authority engenders respect—so if you want respect in an egoless environment, cultivate knowledge.
Fight for what you believe, but gracefully accept defeat. Understand that sometimes your ideas will be overruled. Even if you do turn out to be right, don't take revenge or say, "I told you so" more than a few times at most, and don't make your dearly departed idea a martyr or rallying cry.
Don't be "the guy in the room." Don't be the guy coding in the dark office emerging only to buy cola. The guy in the room is out of touch, out of sight, and out of control and has no place in an open, collaborative environment.
Critique code instead of people—be kind to the coder, not to the code. As much as possible, make all of your comments positive and oriented to improving the code. Relate comments to local standards, program specs, increased performance, etc.

PasteBin - easy way to share source code

2007-03-13T17:44:00.001-07:00

If you've ever wanted to share source code with someone, here's a better way than IM or email. It allows longer snippets than IM normally does and includes syntax highlighting.

http://pastebin.com/

I'm going to try using it to post source code on this blog using a "private" PasteBin at http://develocity.pastebin.com.

(btw, this was posted with Word 2007)