
	Where results make sense

Topic: Strongly typed languages

Related Topics

Ada programming language

Mercury programming language

Ravenscar Profile

Jean Ichbiah

GNU Compiler Collection

Concurrent Versions System

Free software

Gnat

Mac OS X

Apple Darwin

	Programming language - Wikipedia, the free encyclopedia
		Most languages that are widely used, or have been used for a considerable period of time, have standardization bodies that meet regularly to create and publish formal definitions of the language, and discuss extending or supplementing the already extant definitions.
		Strongly typed languages do not permit the usage of values as different types; they are rigorous about detecting incorrect type usage, either at runtime for dynamically typed languages, or at compile time for statically typed languages.
		Functional languages often restrict names to denoting run-time computed values directly, instead of naming memory locations where values may be stored, and in some cases refuse to allow the value denoted by a name to be modified at all.
	en.wikipedia.org /wiki/Programming_language (1840 words)

	Datatype - Wikipedia, the free encyclopedia
		Programming languages implicitly or explicitly support one or more datatypes; these types may act as a statically or dynamically checked constraint on the programs that are valid in a given language.
		The implementation of a dynamically typed language will catch errors related to the misuse of values - "type errors" - at the time the erroneous statement or expression is computed.
		Advocates of strongly typed 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.
	en.wikipedia.org /wiki/Datatype (2482 words)

	Programming language
		A primary purpose of programming languages is to enable programmers to express their intent for a computation more easily than they could with a lower-level language or machine code.
		There are many special purpose languages, for use in special situations: PHP is a scripting language that is especially suited for Web development; Perl is suitable for text manipulation; the C language has been widely used for development of operating systems and compilers (so-called system programming).
		Type-inferred languages superficially treat all data as not having a type, but actually do sophisticated analysis of the way the program uses the data to determine which elementary operations are performed on the data, and therefore deduce what type the variables have at compile-time.
	www.brainyencyclopedia.com /encyclopedia/p/pr/programming_language.html (2286 words)

	Programming language Article, Programminglanguage Information (Site not responding. Last check: 2007-10-29)
		Most languages that are widely used, or have been used for a considerable period of time, have standardization bodies thatmeet regularly to create and publish formal definitions of the language, and discuss extending or supplementing the alreadyextant definitions.
		Strongly typed languages do not permit the usage of values as different types; they are rigorous about detecting incorrecttype usage, either at runtime for dynamically typed languages, or at compile time for statically typed languages.
		Languages that use garbage collection are free to allowarbitrarily complex data structures as both expressed and denoted values.
	www.anoca.org /languages/typed/programming_language.html (1514 words)

	All Language Is Figurative (Site not responding. Last check: 2007-10-29)
		This implies that language is not a matter of symbols and referents--we don't use language to point.
		The adherent of the symbol-referent school of language is challenged to find a consistent scheme for identifying the referents of the words in that sentence that reveal it's meaning.
		Anyway, even in strongly, statically typed languages it is quite possible to "transcend the concept-space imposed by the original designers of the language" (nice phrase).
	clublet.com /why?page=AllLanguageIsFigurative (580 words)

	Smalltalk Tidbits, Industry Rants: Comments Entry
		Allen, the only problem I see with your remarks is that the type theory community has co-opted the term ``strongly typed'' to mean ``statically typed.'' I believe the term they use to refer to the notion you (and I) call ``strongly typed'' is ``type safe.'' So, ST is a dynamically typed type-safe language.
		I don't think the "language" life works on is strongly typed because it would force the being's workings to make all the decisions correctly when they're being done at random.
		Strongly typed languages, or languages where you have to explicitly declare the type of every distinction, are good for commandment tables.
	www.cincomsmalltalk.com /blog/blogComments?entry=3279605645 (1662 words)

	[No title] (Site not responding. Last check: 2007-10-29)
		Unfortunately, it is an observable fact that programmers, both students and professionals, who do not have significant experience with strongly typed languages show the lowest level of this very discipline.
		Modula-3 is an object-oriented language that is not only strongly-typed, but for what it does, it is relatively simple.
		The purpose of CS 410 is to expose you to different programming language "paradigms", specifically, the object-oriented and the functional paradigm.
	www.cs.wichita.edu /~rodney/cs410/sp2003/whyM3andML (728 words)

	Research Overview: David Walker
		Among other theoretical results, we have proven that it is possible to compile high-level type-safe languages to an abstract typed assembly language and that a significant subset of the features that we have implemented are sound.
		We purposely chose a wide-spread, commercial machine architecture to show that the concept of a typed assembly language is not only theoretically feasible, but also quite practical and applicable to even the most complex real-world instruction sets.
		Development of a practical source-level language will require new techniques in program analysis and type inference as well as careful consideration of syntax, language design and the organization of the run-time system in order to succeed.
	www.cs.cmu.edu /~dpw/research.html (1382 words)

	The Wayward WebLog : Language Inferencing
		Local variables defined within a body of code generally obtain their 'type' at runtime as a side-effect of an assignment, and its possible that an assignment two statements later re-assigns the variable to an instance of another type.
		The language syntax ought to be smart enough to determine the end of an expression without me slamming these silly 'tweeners' in there.
		Joe coders are fighting their holy wars about which language is better and why curlies make you grow your pubic hair thicker.
	blogs.msdn.com /mattwar/archive/2004/02/12/72134.aspx (1370 words)

	To type or not to type
		My current language of choice is Java, which has lots of compile time checking but which also has a dynamic aspect (which I tend to use a lot) that sometimes makes it seem like a loosely-typed language.
		We use language for ceremony ("How are you" is not necessarily a request for information), we sometimes use language to do things (when the minister utters "I now pronounce you man and wife", something is done, not claimed to be true or false).
		If you are used to a strongly typed language, then you think that way even when you are doing rapid prototyping or small projects, and the extra overhead is negligible.
	www.artima.com /weblogs/viewpost.jsp?thread=36525 (1207 words)

	VisualWorks: ParcPlace Type-Safety Discussion (Site not responding. Last check: 2007-10-29)
		Their goal was to create "strongly typed" languages where an error is automatically detected if an operator or function is applied to the wrong type of data.
		Dynamically typed languages refuse to allow an operation to be performed upon an inappropriate data value and typically report a runtime error if such an operation is attempted.
		Namely, dynamically typed languages are more truly object-oriented and that the vast majority of true bugs which pass through the static filter are caught more effectively by our dynamic one.
	wiki.cs.uiuc.edu /VisualWorks/ParcPlace+Type-Safety+Discussion (5447 words)

	~ryanlowe/blog: Strong vs Weak Typing
		Paul Vick makes a good point when he says that generics make strongly typed languages even stronger, and this seems to go straight against the new wave of weakly typed languages like Python and older ones like Smalltalk.
		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.
		Ryan, Python and Smalltalk are strongly, dynamically typed languaged - if you call a method on an object which doesn't implement that method, you get a specific behaviour (which is usually to raise an exception).
	www.ryanlowe.ca /blog/archives/000492_strong_vs_weak_typing.php (604 words)

	TAL Overview
		Statically typed intermediate languages are effective tools for staging the compilation of high-level languages.
		The assembly language type system is powerful enough to express high-level abstractions such as closures and abstract datatypes and yet flexible enough to permit traditional low-level optimizations such as loop invariant removal, strength reduction, and redundant move elimination.
		Furthermore, because TAL is assembly language, there is no interpretation overhead during this process and no just-in-time compiler to run or trust.
	www.cs.cornell.edu /talc/overview.html (391 words)

	David Walker
		More specifically, I investigate strongly typed languages such as Java and the Java virtual machine and their application in compilation and security.
		The type systems of these languages are powerful enough to encode high-level abstractions such as function closures and abstract data types, but flexible enough to admit most conventional compiler backend optimizations.
		Under the guidance of Greg Morrisett, I have investigated the type-directed compilation of advanced languages such as ML and a type-safe variant of C. I have helped design strongly-typed compiler intermediate languages and a type-safe assembly language based on the Intel pentium architecture for the TALC compiler project at Cornell.
	www.cs.cornell.edu /home/walker/cv.html (673 words)

	Codefez > Home > Thinking about dynamically-typed languages (Site not responding. Last check: 2007-10-29)
		They have a constant battle about which language is better, on which language Microsoft should be spending more time, and, let's not forget, in which language the.NET Framework should be developed.
		In these languages (C++, Delphi, Java, C#), strong typing is the way you save yourself from shooting yourself (and innocent bystanders) in the foot.
		Writing code in these languages is just easier; you don't have to explicitly declare variables, you don't have to up- or downcast (or worry about the difference).
	www.codefez.com /Home/tabid/36/articleType/ArticleView/articleId/62/Thinkingaboutdynamicallytypedlanguages.aspx (1508 words)

	[No title]
		But languages with nearly an order of magnitude bigger reference manuals are even an order of magnitude more difficult to understand.
		The changes you will encounter with each new language will be a mixture, ranging from slightly different syntax for the same familiar concepts, through substantively different treatments of familiar ideas, to fundamentally new concepts.
		Because of your better understanding of their language design flaws and pitfalls, you will be much better able to avoid being bogged down by them.
	www.cs.wichita.edu /~rodney/cs810/fl2004/whym3 (913 words)

	[No title] (Site not responding. Last check: 2007-10-29)
		I have been a huge advocate of strongly typed languages, and not confusing scripting with a real application development platform.
		I think that scripting and many dynamic languages are in the same camp.
		Regardless of the limitations, our singular focus on strongly typed compiled languages has blinded us to the amazing productivity and approachability of dynamic scripting langauges like Python and Ruby.
	www.simplegeek.com /permalink.aspx/c50879a2-0ec7-45fe-b79d-371856d17b65 (309 words)

	Jikes RVM (Jalapeño) Publications
		The system is written completely in the Java programming language, applying the described techniques not only to application code and standard libraries, but also to the virtual machine itself.
		We present a simple, unified approach for the analysis and optimization of object field and array element accesses in strongly typed languages, that works in the presence of object references/pointers.
		Dynamic class loading during program execution in the JavaTM Programming Language is an impediment for generating code that is as efficient as code generated using static whole-program analysis and optimization.
	www.research.ibm.com /jalapeno/publication.html (3682 words)

	Is your programming language "safe" ? - Python Programming Portal
		When we talk about the safe programming language then it depends on what are you trying to protect and from whom.
		Do you think that Java is the first language to have most of them, The answer is no, LISP had most of them in 1960.
		While it is true that C is a very permissive language (it makes no assumptions about programmer's intentions) it also the most compact and powerful language widely used for commercial purposes.
	www.pythonthreads.com /articles/python/is-your-programming-language-safe-.html (807 words)

	BadreNarayanan.V's Radio Weblog
		I submit as an example my belief in the superiority of strongly typed languages.
		In the spirit of Sam Gentile's recent public retraction on his strongly worded statement about COM interop being fundamentally broken, I would like to say that I now realize how wrong I was to believe that strongly typed languages were inherently superior.
		I had exactly the same beliefs as John as to strongly typed languages.
	radio.weblogs.com /0116112/2003/01/06.html (162 words)

	Weblogs Forum - Humble Beginnings
		My answer is that strongly typed languages (e.g., java) are good for generating output (be conservative in what you generate), and scripting languages (e.g., python) are good at handling input (be liberal in what you accept).
		And partly it's that, for many different reasons, most developers never really learn very many languages during their careers -- especially languages that are distinctly different from the first one or two that they learned.
		I've found that more problems come up the more disjoint the languages are (in terms of their fundamental notions of how to get things done).
	www.artima.com /forums/flat.jsp?forum=106&thread=4969 (1353 words)

	ITworld.com - Dynamically typed languages are no cure-all
		When he spoke in ITworld.com's interview forum, Robert Martin expressed the opinion that dynamically (though strongly) typed languages like Python and Smalltalk would be the mainstream languages of the future, rather than languages like C++ and Java.
		The argument is that, if you are using a dynamically (but strongly) typed, higher-level language, you'll typically need to write less code.
		Untyped or dynamically typed languages are OK for throwaway code, although in my experience with developing such code I have every single time wished in retrospect (even when I was initially happy with an untyped approach) that I had the benefit of static typing.
	www.itworld.com /AppDev/1032/ITF010402meyerpromo (997 words)

	The Nimble Type Inferencer for Common Lisp-84
		Type inferencing is a technique by which the interpreted languages move towards the goal of achieving the safety and execution speed of traditional compiled languages, while preserving the flexibility of runtime data typing.
		Their algorithm is optimum, in that for a class of languages and programs that he characterizes, it provides the best possible information on the range of types that a variable can assume.
		Ada is a strongly typed language which has a substantial amount of machinery for declaring and manipulating variables subject to range constraints.
	home.pipeline.com /~hbaker1/TInference.html (16984 words)

	Something of Nothing (Site not responding. Last check: 2007-10-29)
		Since type safe languages have more ritual, the VI user gets all the downside of the type safe language and none of the advantage.
		When I talk about programmers being more proficient with a strongly typed language, I was referring to ‘average’ programmers.
		The learning curve with such languages is not as steep because the languages are somewhat self-documenting.
	www.scruffles.net /blog/archive/000032.html (691 words)

	The Desktop Fishbowl
		It'd be really cool if 1.5 had 500 classes, and a bunch of optional modules.
		3:59:09 PM Don Box writes an emotive plea in favour of WSDL, from the point of view of a programmer in strongly typed languages trying to interface with weakly-typed scripts.
		As nifty as scripting languages are, I'm still of the opinion that strongly typed languages scale better (in terms of development, not runtime) than weakly typed languages.
	radio.weblogs.com /0100190/2002/02/07.html (326 words)

	strongly-typed vs. weakly-typed languages (Site not responding. Last check: 2007-10-29)
		My own experience is that for quick hacks and small projects, weakly-typed languages are slightly more productive, because there is less set-up required to get something going (no need to declare your variables, for example).
		For larger projects, strongly-typed languages are dramatically more productive, because many errors are caught at compile time rather than at run time (or worse, after your project has shipped).
		And as the complexity of a project increases, the likelihood of committing such errors goes up, because it gets harder and harder to keep all the relevant details in your mind at once.
	support.realsoftware.com /listarchives/cgi-bin/mesg.cgi?a=realbasic-nug&i=a05300b2abb0e840f2988@[10.10.13.2] (250 words)

Try your search on: Qwika (all wikis)