Prefer Domain-Specific Types to Primitive Types - Revision history

Kevlin: Prefer definite types to primitive types moved to Prefer Domain-Specific Types to Primitive Types

2009-07-10T19:30:26Z

Prefer definite types to primitive types moved to Prefer Domain-Specific Types to Primitive Types

←Older revision

Revision as of 19:30, 10 July 2009

Kevlin at 19:30, 10 July 2009

2009-07-10T19:30:06Z

←Older revision		Revision as of 19:30, 10 July 2009
Line 1:		Line 1:
-	On 23rd September 1999 the $327.6 million Mars Climate Orbiter was lost while entering orbit due to a software error back on Earth. The error was later called the ''metric mix-up''. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the spacecraft's thrusters by a factor of 4.45.	+	On 23rd September 1999 the $327.6 million Mars Climate Orbiter was lost while entering orbit around Mars due to a software error back on Earth. The error was later called the ''metric mix-up''. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the spacecraft's thrusters by a factor of 4.45.

-	This is one of many examples of software failures that could have been prevented if stronger and more ~~definite~~ typing had been applied. It is also an example of the rationale behind many features in the Ada language, one of whose primary design goals was to implement embedded safety-critical software. Ada ~~supports~~ strong typing with static checking:	+	This is one of many examples of software failures that could have been prevented if stronger and more domain-specific typing had been applied. It is also an example of the rationale behind many features in the Ada language, one of whose primary design goals was to implement embedded safety-critical software. Ada has strong typing with static checking for both primitive types and user-defined types:

	subtype Velocity_In_Knots is Float range 0..500.00;		subtype Velocity_In_Knots is Float range 0..500.00;
Line 15:		Line 15:
	Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.		Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.

-	Developers in less demanding domains might also benefit from applying ~~definite~~ typing, where they might otherwise continue to use the primitive data types offered by the language and its libraries, such as ~~string~~ and floats. In Java, C++, Python, and other modern languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnots</code> and <code>DistanceInNauticalMiles</code> adds a lot of value with respect to code quality:	+	Developers in less demanding domains might also benefit from applying more domain-specific typing, where they might otherwise continue to use the primitive data types offered by the language and its libraries, such as strings and floats. In Java, C++, Python, and other modern languages the abstract data type is know as <code>class</code>. Using classes such as <code>VelocityInKnots</code> and <code>DistanceInNauticalMiles</code> adds a lot of value with respect to code quality:

	# The code becomes more readable as it expresses concepts of a domain, not just <code>Float</code> or <code>String</code>.		# The code becomes more readable as it expresses concepts of a domain, not just <code>Float</code> or <code>String</code>.

Elandre at 15:39, 10 July 2009

2009-07-10T15:39:17Z

←Older revision		Revision as of 15:39, 10 July 2009
Line 23:		Line 23:
	The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages are more likely to rely on their unit tests. The style of checking may be different, but the motivation and style of expression is not.		The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages are more likely to rely on their unit tests. The style of checking may be different, but the motivation and style of expression is not.

-	The moral is to start exploring ~~definite typing~~ for the purpose of developing quality software.	+	The moral is to start exploring domain-specific types for the purpose of developing quality software.

	By [[Einar Landre]]		By [[Einar Landre]]

Elandre: Prefer definite types over String moved to Prefer definite types to primitive types

2008-11-28T10:33:39Z

Prefer definite types over String moved to Prefer definite types to primitive types

←Older revision

Revision as of 10:33, 28 November 2008

Elandre at 10:30, 28 November 2008

2008-11-28T10:30:18Z

←Older revision		Revision as of 10:30, 28 November 2008
Line 15:		Line 15:
	Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.		Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.

-	Developers in less demanding domains might also benefit from applying definite typing, where they might otherwise continue to use the primitive data types offered by the language and its libraries, such as string and floats. In Java, C++, Python, and other modern languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnots</code> and <code>~~DistanceInNaticalMiles~~</code> adds a lot of value with respect to code quality:	+	Developers in less demanding domains might also benefit from applying definite typing, where they might otherwise continue to use the primitive data types offered by the language and its libraries, such as string and floats. In Java, C++, Python, and other modern languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnots</code> and <code>DistanceInNauticalMiles</code> adds a lot of value with respect to code quality:

	# The code becomes more readable as it expresses concepts of a domain, not just <code>Float</code> or <code>String</code>.		# The code becomes more readable as it expresses concepts of a domain, not just <code>Float</code> or <code>String</code>.

Kevlin at 21:37, 27 November 2008

2008-11-27T21:37:25Z

←Older revision		Revision as of 21:37, 27 November 2008
Line 1:		Line 1:
-	~~At 23 of~~ September 1999, the $327.6 million Mars Climate Orbiter was lost while entering orbit due to a software error back at Earth. The error was later called the metric mix-up. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the ~~spacecrafts~~ thrusters ~~with~~ a factor of 4.45.	+	On 23rd September 1999 the $327.6 million Mars Climate Orbiter was lost while entering orbit due to a software error back on Earth. The error was later called the ''metric mix-up''. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the spacecraft's thrusters by a factor of 4.45.

-	This is one of many examples of software failures that could have been prevented if ~~strong or~~ definite typing ~~was~~ applied. It also an example of the rationale behind the Ada language, ~~primarily designed~~ to implement embedded safety critical software. Ada ~~support~~ strong typing ~~to the extreme, as illustrated in the example below.~~	+	This is one of many examples of software failures that could have been prevented if stronger and more definite typing had been applied. It is also an example of the rationale behind many features in the Ada language, one of whose primary design goals was to implement embedded safety-critical software. Ada supports strong typing with static checking:

-	subtype ~~Velocity_In_Knot~~ is Float range 0..500.00;	+	subtype Velocity_In_Knots is Float range 0..500.00;

	subtype Distance_In_Nautical_Miles is Float range 0..3000.00;		subtype Distance_In_Nautical_Miles is Float range 0..3000.00;

-	Velocity: ~~Velocity_In_Knot~~;	+	Velocity: Velocity_In_Knots;

	Distance: Distance_In_Nautical_Miles;		Distance: Distance_In_Nautical_Miles;
Line 15:		Line 15:
	Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.		Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.

-	Developers in less demanding domains might also benefit from applying definite typing, ~~especially those working in languages with abstract~~ data types such as Java, C++ and ~~Phyton. In these~~ languages the abstract data type is know as <code>class</code>. Using classes such as <code> ~~VelocityInKnot~~</code> and <code>DistanceInNaticalMiles</code> adds a lot of value with respect to code quality:	+	Developers in less demanding domains might also benefit from applying definite typing, where they might otherwise continue to use the primitive data types offered by the language and its libraries, such as string and floats. In Java, C++, Python, and other modern languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnots</code> and <code>DistanceInNaticalMiles</code> adds a lot of value with respect to code quality:

-	1. The code ~~become~~ more readable as it expresses concepts of a domain, not ~~only~~ Float or ~~Strings~~.	+	# The code becomes more readable as it expresses concepts of a domain, not just <code>Float</code> or <code>String</code>.
-	2. The code ~~become~~ more testable as the code ~~encapsulate~~ behavior that is easily testable.	+	# The code becomes more testable as the code encapsulates behavior that is easily testable.
-	3. The code ~~facilitate re-use~~ across applications and systems.	+	# The code facilitates reuse across applications and systems.
-	The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages need to rely on their unit tests alone.	+

-	The ~~morale~~ is to start exploring ~~definit~~ typing for the purpose of developing quality software.	+	The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages are more likely to rely on their unit tests. The style of checking may be different, but the motivation and style of expression is not.
		+
		+	The moral is to start exploring definite typing for the purpose of developing quality software.

	By [[Einar Landre]]		By [[Einar Landre]]

Elandre at 20:55, 27 November 2008

2008-11-27T20:55:49Z

←Older revision		Revision as of 20:55, 27 November 2008
Line 1:		Line 1:
	At 23 of September 1999, the $327.6 million Mars Climate Orbiter was lost while entering orbit due to a software error back at Earth. The error was later called the metric mix-up. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the spacecrafts thrusters with a factor of 4.45.		At 23 of September 1999, the $327.6 million Mars Climate Orbiter was lost while entering orbit due to a software error back at Earth. The error was later called the metric mix-up. The ground station software was working in pounds while the spacecraft expected newtons, leading the ground station to underestimate the power of the spacecrafts thrusters with a factor of 4.45.

-	This is one of many examples of software failures that could have been prevented if strong typing was applied. It also an example of the rationale behind the Ada language, primarily designed to implement embedded safety critical software. Ada support strong typing to the extreme, as illustrated in the example below.	+	This is one of many examples of software failures that could have been prevented if strong or definite typing was applied. It also an example of the rationale behind the Ada language, primarily designed to implement embedded safety critical software. Ada support strong typing to the extreme, as illustrated in the example below.

	subtype Velocity_In_Knot is Float range 0..500.00;		subtype Velocity_In_Knot is Float range 0..500.00;
Line 15:		Line 15:
	Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.		Some_Number:= Distance + Velocity; -- Will be caught by the compiler as a type error.

-	Developers in less demanding domains might also benefit from applying ~~strong~~ typing, especially those working in languages with abstract data types such as Java, C++ and Phyton. In these languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnot</code> and <code>DistanceInNaticalMiles</code> adds a lot of value with respect to code quality:	+	Developers in less demanding domains might also benefit from applying definite typing, especially those working in languages with abstract data types such as Java, C++ and Phyton. In these languages the abstract data type is know as <code>class</code>. Using classes such as <code> VelocityInKnot</code> and <code>DistanceInNaticalMiles</code> adds a lot of value with respect to code quality:

	1. The code become more readable as it expresses concepts of a domain, not only Float or Strings.		1. The code become more readable as it expresses concepts of a domain, not only Float or Strings.
Line 22:		Line 22:
	The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages need to rely on their unit tests alone.		The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages need to rely on their unit tests alone.

-	The morale is to start exploring ~~strong~~ typing for the purpose of developing quality software.	+	The morale is to start exploring definit typing for the purpose of developing quality software.

	By [[Einar Landre]]		By [[Einar Landre]]

Elandre: Prefer strong typing over String moved to Prefer definite types over String

2008-11-27T20:52:20Z

Prefer strong typing over String moved to Prefer definite types over String

←Older revision

Revision as of 20:52, 27 November 2008

Elandre at 20:50, 27 November 2008

2008-11-27T20:50:16Z

←Older revision		Revision as of 20:50, 27 November 2008
Line 20:		Line 20:
	2. The code become more testable as the code encapsulate behavior that is easily testable.		2. The code become more testable as the code encapsulate behavior that is easily testable.
	3. The code facilitate re-use across applications and systems.		3. The code facilitate re-use across applications and systems.
-	The approach is valid for ~~statical~~ and ~~dynamical~~ typed languages. The only difference is that developers using ~~statical~~ typed languages get some help from the compiler while those embracing ~~dynamical~~ typed languages need to rely on their unit tests alone.	+	The approach is equally valid for users of both statically and dynamically typed languages. The only difference is that developers using statically typed languages get some help from the compiler while those embracing dynamically typed languages need to rely on their unit tests alone.

	The morale is to start exploring strong typing for the purpose of developing quality software.		The morale is to start exploring strong typing for the purpose of developing quality software.

Elandre at 20:45, 27 November 2008

2008-11-27T20:45:45Z

←Older revision		Revision as of 20:45, 27 November 2008
Line 19:		Line 19:
	1. The code become more readable as it expresses concepts of a domain, not only Float or Strings.		1. The code become more readable as it expresses concepts of a domain, not only Float or Strings.
	2. The code become more testable as the code encapsulate behavior that is easily testable.		2. The code become more testable as the code encapsulate behavior that is easily testable.
-	3. The code facilitate re-use across applications and systems.	+	3. The code facilitate re-use across applications and systems.
-		+
	The approach is valid for statical and dynamical typed languages. The only difference is that developers using statical typed languages get some help from the compiler while those embracing dynamical typed languages need to rely on their unit tests alone.		The approach is valid for statical and dynamical typed languages. The only difference is that developers using statical typed languages get some help from the compiler while those embracing dynamical typed languages need to rely on their unit tests alone.