David Buck - Blog

"the system has captured all the unhandled exceptions along with tracebacks for us to analyze and find bugs" -- this is a very cool idea, David. I think I'll implement it here at Northern Natural Gas.

David: "masked by static typing ... arithmetic on uninitialized variables"
Masked by default variable initialization, not by static typing.

void main(String[] args){     
   int x;
   x++;
}
I:\Nice\test\Test.nice: line 3, column 4:
Variable x is not initialized

David: "I categorized 95% of them ... only one ... could have been detected by static typing"
What about the "initialized to nil and raised an exception" ?

void main(String[] args){     
   let x = null + 5;
}
I:\Nice\test\Test.nice: line 2, column 17:
No possible call for +.

Thank you for at least trying to add some data amongst the opinions.

Comment on Bug rates in a Smalltalk project by James Robertson

More hand waving Isaac. Note that in Smalltalk we get null initialization without the developer having to remember to do it.

Comment on Bug rates in a Smalltalk project by David Buck

Isaac: If the variable is declared as an instance variable, can your compiler detect that it's uninitialized? I doubt it. It would have to be a runtime test at the very least and this gives the same effect as in Smalltalk (raising an exception). Detecting this at compile time is only possible in trivial cases.

The likely case is that unitialized variables aren't detected at compile time or ar run time. In that case, the variable as to contain some sort of data or it won't be valid. This data would be used in calculations and give answers which may be wrong. The right answer is to raise a runtime exception which is what Smalltalk does.

Some people have commented that languages like C# detect uninitialized variables at compile time. This is true for temporary variables but not always true for instance variables. Check out the following C# code:

class InitializationTestClass
{
	int x;

	static void Main(string[] args)
	{
		InitializationTestClass test = new InitializationTestClass();
		System.Console.WriteLine (test.Calculate().ToString());
	}

	public int X
	{
		get {return x;}
		set {x = value;}
	}

	public int Calculate()
	{
	return x+5;
	}
}

This code compiles cleanly and executes printing "5" but does so using an uninitialized variable x. The compiler can't detect it and neither can the runtime environment. The error, therefore, is being masked.

David: "can your compiler detect that it's uninitialized? I doubt it"
In this language "If no default value is given, then every call to the constructor must specify the value for this field."

class MyVal { int x; }

void main(String[] args){     
   let y = new MyVal();
}

I:\Nice\Test\Test.nice: line 5, column 12:
Fields of class Test.MyVal require initial values.
Use the following syntax:
  new Test.MyVal(x: value)

Class Test.MyVal has the following fields:
  int x

Second attempt at including extract from C# spec:

The following categories of variables are automatically initialized to their default values:

• Static variables.
• Instance variables of class instances.
• Array elements.

The default value of a variable depends on the type of the variable and is determined as follows:

• For a variable of a value-type, the default value is the same as the value computed by the value-types default constructor (11.1.1).
• For a variable of a reference-type, the default value is null.

Note: Initialization to default values is typically done by having the memory manager or garbage collector initialize memory to all-bits-zero before it is allocated for use. For this reason, it is convenient to use all-bits-zero to represent the null reference. end note

David: "can your compiler detect that it's uninitialized? I doubt it"
Were your doubts answered?

Just look at the comments by Charles Cook.

Class instance variables are auto initialized to default values. Theres a slew of bugs waiting to happen right there.

No, the doubts weren't answered.

Sean: "auto initialized to default values"
Charles Cook was writing about C#.
In the example I gave, instance variables were not auto-initialized.