
	Where results make sense

Topic: Strong typing

Related Topics

strong nuclear force

strong interaction

Strong Bad

strong atheism

Caleb Strong

strong agnosticism

Sancho VII the Strong

Tom Strong

William Strong

strong force

strong verbs

strong AI

In the News (Thu 8 Jan 09)

Rod Blagojevich

Phil Schiller

Gaza City

Jermain Defoe

Lindsay Lohan

Bill Richardson

Kelly Preston

Leon Panetta

Mitchell Johnson

Darren Sproles

	Strongly-typed programming language - Wikipedia, the free encyclopedia
		Type safety; that is, the rejection (at either compile or run time) of operations or function calls which attempt to disregard data types.
		Types must be converted by an explicit notation such as a function that accepts one type and returns a different one.
		C-style casts, or the ability to use a pointer to one type as if it had contained a different type, are disallowed.
	en.wikipedia.org /wiki/Strongly-typed_programming_language (608 words)

	strong - definition by dict.die.net
		Moving with rapidity or force; violent; forcible; impetuous; as, a strong current of water or wind; the wind was strong from the northeast; a strong tide.
		Ardent; eager; zealous; earnestly engaged; as, a strong partisan; a strong Whig or Tory.
		Strong conjugation (Gram.), the conjugation of a strong verb; -- called also old, or irregular, conjugation, and distinguished from the weak, or regular, conjugation.
	dict.die.net /strong (554 words)

	ipedia.com: Datatype Article (Site not responding. Last check: 2007-11-07)
		Types are usually associated either with values in memory or with objectss such as variabless.
		For example, a datatype is a type of a value, A class is a type of an object and a kind is a type of a type.
		Duck typing is a humorous way of describing the (dynamic) typing typical of many scripting languages, where the language guesses at the type of a value.
	www.ipedia.com /datatype.html (2261 words)

	gotoAndPlay Flash Tutorials -- An ActionScript 2.0 Primer for ActionScript 1.0 Folk: Part One
		Strong typing helps to ensure that you are using good coding practices, and it helps to eliminate many mistakes that can arise from the loosely typed variables of ActionScript 1.0.
		Strong typing is a compile-time (meaning it does not verify data types at runtime) feature of ActionScript 2.0 in which you can declare a variable to be of a particular data type.
		The strong typing from the original variable will not be checked against the new variable in such a case and you will not receive any errors.
	www.gotoandplay.it /_articles/2003/09/as2_part1.php (1985 words)

	PC-lint/FlexeLint Strong Type Checking (Site not responding. Last check: 2007-11-07)
		User-defined types match only through the nominal type, not through the underlying type as is done with C. In other words, typedefs are ignored in C and C++ for the purpose of determining type compatibility.
		Being a parent to a child type is similar to being a base type to a derived type in an object-oriented system with one difference.
		Note that the type of a binary operator is the type of the most restrictive type of the type hierarchy (i.e., the child rather than the parent).
	www.gimpel.com /html/strong.htm (3961 words)

	Keith Devens - Weblog: GvR: Strong vs. Weak Typing - February 09, 2003
		Strong typing catches many bugs, but it also makes you focus too much on getting the types right and not enough on getting the rest of the program correct.
		Strong typing is one reason that languages like C++ and Java require more finger typing.
		And all the strong typing goes out the door the moment you say, "Well, we're just going to write a container of Objects, and you'll have to cast them back to whatever type they really are once you start using them." That means you have even more finger typing, because of all those casts.
	keithdevens.com /weblog/archive/2003/Feb/09/GvRStrongVs.WeakTyping (434 words)

	strong typing from FOLDOC (Site not responding. Last check: 2007-11-07)
		In a strongly typed language, conversion between types requires the use of explicit conversion functions as opposed to implicit type coercion.
		Typing strength is a continuum; ML is more strongly typed than Java, which is more strongly typed than C.
		Strong or weak typing is independent of the choice between static typing and dynamic typing.
	foldoc.doc.ic.ac.uk /foldoc/foldoc.cgi?strong+typing (132 words)

	TechnoTourette: JAVA: Strong typing vs. Unit testing
		Weak typing is a higher abstraction than Strong Typing (which is more explicit about implementation of typing) but Strong Typing is certainly a higher abstraction than unit testing for type problems.
		Strong typing imply define the type each type you work with it.
		The point is not to test an method's argument and return types in your unit tests, rather it is to provide unit tests to prove that a method performs as it should.
	www.depeupleur.com /blog/TT_blog/archives/000003.html (483 words)

	strong typing : Definition from the Online Dictionary at Datasegment.com (Site not responding. Last check: 2007-11-07)
		With variables that can store values of more than one type, incorrect type usage can be detected at run time.
		The languages Ada, Java, and Haskell are strongly typed.
		C and C++ are sometimes described as strongly typed, but are perhaps better described as weakly typed.
	onlinedictionary.datasegment.com /word/strong+typing (106 words)

	Strong Typing and Perl (Site not responding. Last check: 2007-11-07)
		Since type checking in C and Pascal is a failure (and I have a big fit about this and foam at the mouth so that nobody dares disagree) there are two directions to go.
		Finally, I talk about the possibility of adding good static type checking to Perl, and conclude that it's a lost cause because one of the essential features of Perl is that it automatically converts values from one type to another, which defeats the possibility of checking.
		Strong Typing in Pascal and C is a Failure
	perl.plover.com /yak/typing (380 words)

	The merits of strong typing (Loud Thinking)
		Strong typing is a communication tool for explicit statements of intent backed by the guard of compilation.
		Method signatures with strong typing tells you exactly what kind of input they expect and what kind of output they return.
		Weakly typing, on the other hand, requires you to be verbose about in- and output requirements in comments and vigilant about checking parameters manually.
	www.loudthinking.com /arc/000074.html (709 words)

	Define strong typing : powered by In Dictionary (InDicitonary.com) (Site not responding. Last check: 2007-11-07)
		Strict enforcement of type rules with no exceptions.
		All types are known at compile time, i.e.
		Strong typing catches more errors at compile time than weak typing, resulting in fewer run-time exceptions.
	www.indictionary.com /define/strong_typing (241 words)

	Typing: Strong vs. Weak, Static vs. Dynamic
		Before talking about what kind of type system a language supports, we should establish agreement about what a type is in the first place.
		TypeError: unsupported operand type(s) for +: 'int' and 'str' >>> 1 + 1 2 >>> "1" + "1" '11' >>> 1 + int("1") 2 >>> "1" + str(1) '11'
		Bruce Eckel equates "weak typing" with "latent typing", but that's at odds with historical usage, not to mention that it confuses the two axes of strong/weak and static/dynamic.
	www.artima.com /weblogs/viewpost.jsp?thread=7590 (793 words)

	Strong typing (Site not responding. Last check: 2007-11-07)
		Strong typing is not only needed for compilers it is also a useful debugging tool for finding spelling errors.
		Without strong typing a misspelled variable name will still evaluate to something meaningful but probably not what was wanted.
		Far from being a relique from the `middle ages' strong typing allows much more sophisticated programming because it permits procedure names to be overloaded.
	www.uni-koeln.de /REDUCE/reduce-forum/90/msg44.html (95 words)

	April 23, 2002 - JScript .NET's Strong Typing
		In previous versions, the loosely typed structure of JScript meant that variables assumed the type of the value assigned to them.
		In fact, there was no way to declare the data types of variables in previous versions.
		Strong typing in a programming language has several benefits, such as improved execution speed, type checking, and self-documenting code.
	www.webreference.com /js/tips/020423.html (224 words)

	Static and strong typing for extended Mathematica -- from Mathematica Information Center
		A static type system makes it possible to find type errors in the whole program before execution starts, in contrast to the standard dynamic type checking of Mathematica which only finds type errors in parts of the program during execution.
		The type system includes basic types, array types, record types, typed variables, typed functions and object oriented constructs.
		The syntax of the type extensions is standard Mathematica, and the implementation is entirely within Mathematica.
	library.wolfram.com /infocenter/Articles/3470 (123 words)

	Simon Willison: Strong Typing vs Strong Testing
		In Strong Typing vs. Strong Testing, Bruce Eckel reconsiders the old idea that languages without strong typing can't be relied on to create large programs:
		His conclusion is that type checking by the compiler does not garauntee the correctness of a program in the first place; it's just another test.
		This does mean that I am going to have to rewrite the bit our software project where I diss PHP as an implementation language for not having strong typing, as I no longer to believe that to be a problem.
	simon.incutio.com /archive/2003/05/04/strongTesting (428 words)

	[No title] (Site not responding. Last check: 2007-11-07)
		Slide 11: Static Typing in Pascal and C is a Failure
		As a larger and more general sort of argument to show that the type systems of C and Pascal are failures, I'm going to point out that each language has several mechanisms specifically designed for disabling or otherwise working around the brokenness of the type system.
		Union types were big trouble in Pascal and C, because they let us store a value of one type and read it back again as another type.
	perl.plover.com /yak/typing/notes.html (7073 words)

	Bruce Eckel's MindView, Inc: 5-2-03 Strong Typing vs. Strong Testing
		This shook my unquestioning acceptance of strong type checking (acquired when moving from C to C++, where the improvement was dramatic) enough that the next time I examined the issue of checked exceptions in Java, I asked "why"?
		At this point, a strong, statically-typed language would be sputtering with rage, insisting that this kind of sloppiness will cause disaster and mayhem.
		To claim that the strong, static type checking constraints in C++, Java, or C# will prevent you from writing broken programs is clearly an illusion (you know this from personal experience).
	mindview.net /WebLog/log-0025 (1886 words)

	Weak typing \| TutorGig.co.uk Encyclopedia (Site not responding. Last check: 2007-11-07)
		In computing, 'weak typing', when applied to a programming language, is used to describe how the language handles datatypes.
		Weak typing requires less effort of the programmer than strong typing, because the compiler or interpreter will implicitly perform certain value conversions.
		According to this definition, C and C++ are weakly typed, as they automatically coerce many types e.g.
	www.tutorgig.co.uk /ed/Weak_typing (377 words)

	Raw: Ok, You Can Take That Back (Site not responding. Last check: 2007-11-07)
		One of her lines is that strong typing is part of the solution to bugginess.
		The general idea with strong typing, that includes generics, is that the compiler should do as much as the work for you.
		Sure, but taking into account the whole picture (as Livschitz was doing) there are good arguments for Strong testing, not strong typing.
	dannyayers.com /archives/002288.html (356 words)

	ACM Digital Library: Strong typing of object-oriented languages revisited
		The type system of a language can be characterized as strong or weak and the type checking mechanism as static or dynamic.
		Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations.
		It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.
	www.cs.utk.edu /cs594ipm/cgi-bin/group11/crawl_collection/acm/pages/page527.html (236 words)

	Co-variance and Strong Typing (Site not responding. Last check: 2007-11-07)
		We have seen that co-variance is type unsafe.
		What are all the types which may ever be assigned to each variable.
		For each co-variant message sent to a specific variable, check that the co-variant conditions are satisfied if the variable assumes any of its essential types.
	www.cs.technion.ac.il /Courses/OOP/slides/export/236703/_/Conformance/sld016.htm (111 words)

	RE: Strong versus (weak
		Static Typing - Type of variables must be declared at compile time (e.g.
		C++) Dynamic Typing - Type of variables determined from usage at runtime (e.g.
		Subject: RE: Strong versus (weakruntime) typing Dare, I'm intrigued.
	www.stylusstudio.com /xmldev/200302/post30420.html (365 words)

	Ada '83 Rationale, Sec 7.3: Simple Strong Typing (Site not responding. Last check: 2007-11-07)
		The usual motivation for such type replication is to keep the two value spaces well separated and, thus, to achieve a simple form of strong typing.
		What this example illustrates is that we have provided type declarations that reflect the common-sense view that having one "centime" is not the same as having one "pfennig".
		Our last example of simple strong typing (due to Robert Firth) illustrates an ability similar to the Simula hierarchical type composition (although it is admittedly less powerful).
	archive.adaic.com /standards/83rat/html/ratl-07-03.html (2206 words)

	Benchmarking Results
		This test compares assignment statements, varying only the type declarations of the values or items involved.
		Thus, you should always assign local variable value types to the most specific type or the most specific class possible.
		The exception to this general rule is casting, described in Effect of Subclassing, Stability, and Casting on Array References.
	www.cs.fsu.edu /g2/g2doc/g2dvg/appendi6.htm (120 words)

	New February 2002 \| gone crazy, back later (Site not responding. Last check: 2007-11-07)
		Everything that is part of the unique individuality of man or thing is Apollonian in character; all types of form or structure are Apollonian, since form serves to define or individualize that which is formed; thus, sculpture is the most Apollonian of the arts, since it relies entirely on form for its effect.
		Strong typing is inherently anathema to generic programming style.
		Go to a zoo or a place with many types of life and communicate with each of them until you know the communication is received and, if possible, returned.
	www.treedragon.com /ged/map/ti/newFeb02.htm (15570 words)

	2.2. Declaring Functions
		A language in which types are fixed at compile time.
		A language in which types are discovered at execution time; the opposite of statically typed.
		A language in which types may be ignored; the opposite of strongly typed.
	diveintopython.org /getting_to_know_python/declaring_functions.html (384 words)

	ActionScript.org Forums - AS2.0 Strong Typing and Global variables
		This is required since typing is defined in conjunction with the var keyword.
		This pretty much prevents any typing for _global variables since the only way you can assign _global variables is directly through the _global object.
		To type global variables, first define them to any arbitrary value and then re-define them again in a with block using var and desired typing.
	www.actionscript.org /forums/printthread.php3?t=62691 (753 words)

Try your search on: Qwika (all wikis)