
	Where results make sense

Topic: Weak typing

Related Topics

List of mountain types

S type asteroid

C type asteroid

Myers Briggs Type Indicator

spectral type

blood type

data types

Theory of Types

Type 42

Type VII U boat

abstract data types

movable type

In the News (Wed 15 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Datatype - Wikipedia, the free encyclopedia
		Types are usually associated either with values in memory or with objects such as variables.
		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 which guess the type of a value.
	en.wikipedia.org /wiki/Datatype (2464 words)

	Michael Rys : An Introduction to the XQuery (and XPath 2.0) Type System: The general concepts
		The inferred type of an expression is the type that a type inference system has inferred based on the types of the input arguments and the type rules of the operations forming the expression.
		In the XQuery type system, the type xdt:untypedAtomic, that is used to represent the type of atomic values that have not been associated a type through the validation process (an untyped atomic value), is a weak type.
		A strong type is a type that leads to a type error unless it is a subtype of the required type of the operation that is being applied to the value.
	sqljunkies.com /WebLog/mrys/archive/2004/05/13/2480.aspx (1368 words)

	PHP: Type Juggling - Manual
		PHP does not require (or support) explicit type definition in variable declaration; a variable's type is determined by the context in which that variable is used.
		Note that this does NOT change the types of the operands themselves; the only change is in how the operands are evaluated.
		Type casting in PHP works much as it does in C: the name of the desired type is written in parentheses before the variable which is to be cast.
	www.php.net /manual/en/language.types.type-juggling.php (946 words)

	Joshua Marinacci's Blog: Strong vs Weak Typing: Can't we have the best of both worlds? (Site not responding. Last check: 2007-10-15)
		Compile-time type checks are just a form of low-level unit tests, except you have to use them even when they aren't helping you.
		Common Lisp is usually written without typing its variables, but types can be declared when needed for performance reasons.
		Object CAML is a statically typed language, but has type inference so no variables need to have their types declared; the compiler determines the type of each variable automatically.
	weblogs.java.net /blog/joshy/archive/2003/08/strong_vs_weak.html (1704 words)

	Datatype - free-definition (Site not responding. Last check: 2007-10-15)
		In dynamic typing, type checking is often done at run-time because variables can be differently typed according to execution path.
		Advocates of languages such as ML and Haskell have suggested that almost all bugs can be considered type errors, if the types used in a program are sufficiently well declared by the programmer or inferred by the compiler.
		A strongly typed language does not allow an operation to succeed on arguments which are of the wrong type.
	www.free-definition.com /Datatype.html (2272 words)

	Bruce Eckel's MindView, Inc: 3-22-04 How to Argue about Typing
		The value of what I've been calling "weak typing," but which seems like it may be more predominantly called "latent typing," is fascinating, whatever we choose to call it.
		Of course Smalltalk used latent typing, and so did not require the casts, but when Java followed this prescription it had static typing, and so you had the benefit of containers built with a singly-rooted hierarchy, but now you had to cast everything up and down all the time.
		Static type checking is only one kind of testing, and very limited in its effect – as you move out in space time from the point of compilation, the "software uncertainty principle" adds more and more noise to the results.
	mindview.net /WebLog/log-0052 (4223 words)

	Smalltalk Tidbits, Industry Rants: Dynamic vs. Weak
		Dynamic typing does produce a gotcha now and then, but static typing is like trying to work while clamped tightly in a vise all the time (a state of gotcha).
		The inverse, "dynamic" or "weak" typing is where the type of entities changes frequently.
		Most of the fuss about the drawbacks of "static" typing is really about the drawbacks of "declarative" typing, because the vast majority of programmers do not write code where types intentionally change at runtime.
	www.cincomsmalltalk.com /blog/blogView?showComments=true&entry=3278167775 (1045 words)

	strong typing from FOLDOC (Site not responding. Last check: 2007-10-15)
		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.
	ftp.sunet.se /foldoc/foldoc.cgi?strong+typing (132 words)

	weak typing
		Weak typing is "friendlier" to the programmer than strong typing, but catches fewer errors at compile time.
		C and C++ are weakly typed, as they automatically coerce many types e.g.
		They also allow ignore typedefs for the purposes of type comparison; for example the following is allowed, which would probably be disallowed in a strongly typed language:
	www.linuxguruz.com /foldoc/foldoc.php?weak+typing (179 words)

	Keith Devens - Weblog: GvR: Strong vs. Weak Typing - February 09, 2003
		The one thing that troubles me is that all the focus is on the strong typing, as if once your program is type correct, it has no bugs left.
		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.
		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 (334 words)

	Type checking (Site not responding. Last check: 2007-10-15)
		Rather, it is in relation to the legal use of values as input to operators and functions.
		Type checking is the processes of identifying errors in a program based on explicitly or implicitly stated type information
		Types are associated with values (also called objects) rather than with variables.' In our categorization, Scheme is strongly typed and types are dealt with at run time (on values) as a contrast to compile time (on variables).
	www.cs.auc.dk /~normark/prog3-03/html/notes/fu-intr-1-note-types-and-check.html (178 words)

	weak - definition by dict.die.net
		(h) Lacking ability for an appropriate function or office; as, weak eyes; a weak stomach; a weak magistrate; a weak regiment, or army.
		(i) Lacking in elements of political strength; not wielding or having authority or energy; deficient in the resources that are essential to a ruler or nation; as, a weak monarch; a weak government or state.
		Note: Weak is often used in the formation of self-explaining compounds; as, weak-eyed, weak-handed, weak-hearted, weak-minded, weak-spirited, and the like.
	dict.die.net /weak (607 words)

	StrongVsWeakTyping - PythonInfo Wiki (Site not responding. Last check: 2007-10-15)
		Strong/weak typing is about how much you care of types at all - in php, its perfectly legal to add strings to numbers - the string simply gets converted to a number beforehand, that conversion yielding 0 when there is nothing useful and numberlike can be extracted from the string.
		So typing is weak, as it doesn't constrain the possible operations on variables with certain values.
		Strong types provide strong protection for data types as their abstraction; weak types allow you to operate on data "behind the wall of abstraction".
	wiki.python.org /moin/StrongVsWeakTyping (1900 words)

	Re: Strong versus (weak\|runtime) typing (Site not responding. Last check: 2007-10-15)
		Both Python and Java have typed objects - objects have some indication of their type attached to them - unlike (say) C where objects are just some bits interpreted according to the expression that refers to them.
		The only weak-typing constructs are pointer casts, function calls with the wrong argument types in old-fashioned C without prototypes, and maybe one or two others.
		And the incredible verbosity of common constructs like iteration in Java is largely due to static typing, and is a source of errors just by ensuring that your method doesn't fit on the screen.
	www.stylusstudio.com /xmldev/200302/post40430.html (378 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 (784 words)

	RE: Strong versus (weak\|runtime) typing (Site not responding. Last check: 2007-10-15)
		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.
		Sean At 12:05 12/02/2003 -0800, Dare Obasanjo wrote: >I'm impressed by the fact that neither the interviewer nor the >interviewer seem to be able to tell the difference between strong vs. >weak typing and static vs. dynamic typing.
	www.stylusstudio.com /xmldev/200302/post30420.html (366 words)

	CBBS: Should a reference laboratory discontinue testing for weak D for ALL patients? (Site not responding. Last check: 2007-10-15)
		According to the individual who referred this question, the Technical Manual states that weak D testing is only required for determining Rh labeling of donor units, and that the Standards do not require weak D typing for recipients of blood transfusions.
		I believe they said weak D testing should be done on pregnant women but I am not sure what they said about whether the weak D women should be called D+ or D-.
		If the mother is D negative and delivers a weak D positive infant then we consider her to be a candidate for RhIg since the baby is considered to posses the D antigen.
	www.cbbsweb.org /enf/weakd_testing.html (1437 words)

	dBforums - more on weak typing..
		A language in which types are fixed at compile time.
		figure out what type a variable is when you first assign it a value.
		A language in which types may be ignored; the opposite of strongly typed.
	www.dbforums.com /t511814.html (344 words)

	Python & Java: Side by Side Comparison (Site not responding. Last check: 2007-10-15)
		For those who wish to pursue the matter, Strong versus Weak Typing: A Conversation with Guido van Rossum, Part V is a good place to start.
		If a name is assigned to an object of one type, it may later be assigned to an object of a different type.
		Once a variable name has been bound to a type (that is, declared) it can be bound (via an assignment statement) only to objects of that type; it cannot ever be bound to an object of a different type.
	www.ferg.org /projects/python_java_side-by-side.html (2634 words)

	andrew cooke: an introduction to programming languages
		Lisp or Python have many different types, but when you look at a piece of code there is nothing that forces a variables to "be" (or to "point to") a piece of data of a particular type.
		Static types are good because they allow certain errors in programs to be detected earlier (a compiler for a statically typed language may also be able to make extra optimisations using the extra information available, but this depends on details of particular languages and compilers).
		For example, the types of a list of items are unimportant if we only want to know the length of the list, so in ML a function can have a type that indicates that it takes lists of "any" type and returns an integer.
	www.acooke.org /andrew/writing/lang.html (6766 words)

	[No title] (Site not responding. Last check: 2007-10-15)
		Strong vs Weak typing interview: First off, the premise is a lie: [Python indeed has strong typing], VERY STRONG, it simply has no way to protect the code. But even within the premise: C++ of course offers the option of weak typing (called "dynamic_cast") so as to have the worst of all worlds.
		The reason why so much bad C++ programs are written is that C++ gives you SO MUCH rope, and people generally apply too many too silly programmers to projects. As a person who turned prototypes into applications professionally for years, weak types are simply a non-starter as a problem.
		That complaint is a straw man. When you convert your weak types into stromg types, you just look at how each variable is used and pick a type for it.
	www.ceejbot.com /blog/rdf/comment-2003-02-10-3 (422 words)

	xml-dev - RE: [xml-dev] Strong versus (weak\|runtime) typing
		I'm impressed by the fact that neither the interviewer nor the interviewer seem to be able to tell the difference between strong vs. weak typing and static vs. dynamic typing.
		As for what this argument has to do with the XML arguments on strong vs. weak typing I'd assumed it was obvious.
		http://www.artima.com/intv/strongweak.html Is the strong/weak/runtime typing argument over XML any different from that debate in programming languages.
	lists.xml.org /archives/xml-dev/200302/msg00418.html (237 words)

	Radovan Janecek: Nothing Impersonal: Typing again
		I would argue weak typing is bad, and dynamic typing is what's needed.“
		At the same time, I think dynamic typing brings some level of weakness to a type system.
		And here I’m wondering whether mixing strong types with XML strings is that good.
	radovanjanecek.net /blog/archives/000005.html (326 words)

	~ryanlowe/blog: Strong vs Weak Typing
		Strongly typed languages direct you down an inflexible path: you may only assign a value of type A to a variable of type A or one of its superclasses or interfaces.
		Once you do that it may be painful to change the type later in the code because you have to edit all of the types.
		Dynamic languages don't require you to care about type as a formal concept unless you want to, so you're free to focus on more fundamental concepts (iteration, recursion, procedural abstraction) without getting into the nebulous and confusing world of types.
	www.ryanlowe.ca /blog/archives/000492_strong_vs_weak_typing.php (604 words)

	Ceejbot :: 2003-02-10 (Site not responding. Last check: 2007-10-15)
		I am not convinced that strong static typing would be easy or appropriate to add to Python, but I a convinced that if someone were to invent a language that combined the virtues of Pyton with strong static typing I would switch and never look back.
		Strong static typing is a boon to successful development and any good language will prefer it; if you also have a place for dynamic typing then certainly the language should support it as an option.
		An "implicit" type is where code in Module A requires objects defined in Module B to exhibit certain behaviors in order for the code in Module A to function correctly, but Module B nowhere promises to exhibit such behavior.
	www.ceejbot.com /blog/comments/2003-02-10 (4430 words)

	OSNews.com - Exploring the Future of Computing
		Boo is an excellent language for rapid application development, and is much more exciting than Python because I don't have to worry about the 'weak typing' found in the latter language.
		Any ignorant statements about "what strong typing means to me" would make an excellent addition to your own internal monologue.
		Since the original constructor hasn't necessarily been run and the object's dictionary doesn't necessarily have all of the members defined for the new type in its constructor, this will result in an runtime exception if any of these are visited.
	osnews.com /reply.php?news_id=11443&comment_id=13143 (1074 words)

	Smalltalk Tidbits, Industry Rants: Yet more typing confusion
		Joshua Marinacci confuses weak typing and dynamic typing.
		You can't get a type error of the sort you can see in a weakly typed language - like C++.
		With Casting, you get the worst of all possible worlds - the strictures of manifest typing, along with the runtime's utter inability to cope with a missent message.
	www.cincomsmalltalk.com /blog/blogView?showComments=true&entry=3238406989 (345 words)

	New Typing Instructor Deluxe Software Offers the Ability to Specifically Focus on Improving User's Weak Typing Areas \| ...
		Typing Instructor Deluxe continues to utilize a variety of proven typing instruction methods offered within a fun-filled environment that now takes them on three different travel themes.
		Typing Instructor Deluxe covers the entire keyboard, including the numeric keypad, on both the standard and split keyboards.
		Typing Instructor Deluxe can be purchased at major software retail stores throughout the United States and Canada or on the World Wide Web at www.individualsoftware.com, and carries a suggested retail price of $29.95 U.S./ $34.95 CDN.
	www.individualsoftware.com /new/company/pr/10_03.htm (1105 words)

	CBBS: Reconciling conflicting results for Rh typing using different test reagents (Site not responding. Last check: 2007-10-15)
		A colleague on the US East Coast reports that his laboratory is trying to resolve an interesting Rh typing problem in a female patient whose initial Rh(D) typing in June 2000 (as part of prenatal testing) was negative using a monoclonal/polyclonal blend anti-D typing reagent.
		In spite of her “weak Du” typing result at the other hospital, she was “treated” as an Rh negative individual, and would have received Rh Immune Globulin at the time of her delivery, if her baby had been Rh positive.
		As part of trying to resolve the discordant results from her initial Rh typing, a records review revealed that the two hospitals were using different manufacturers’ monoclonal/polyclonal blend anti-D typing reagents during 2000.
	www.cbbsweb.org /enf/rhtypeproblem.html (1017 words)

Try your search on: Qwika (all wikis)