|
| |
| | Datatype - Wikipedia, the free encyclopedia |
 | | Types usually have associations either with values in memory or with objects such as variables. | | | In computer science, a datatype (often simply a type) is a name or label for a set of values and some operations which one can perform on that set of values. | | | Static typing allows construction of libraries which are less likely to be accidentally misused by their users. |
|
http://en.wikipedia.org/wiki/Static_typing
(2469 words)
|
|
| |
| | Static - Wikipedia, the free encyclopedia |
| | Static code analysis is a set of methods for analyzing code without running it | | | Static variables may be constants, local function variables, or class variables depending on the context | | | Statics, a branch of physics concerned with physical systems in equilibrium |
|
http://en.wikipedia.org/wiki/Static
(256 words)
|
|
| |
| | Static typing and other mysteries of life |
| | The policy known as static typing, which I will argue is the only reasonable one for professional software development, states that we should answer the "when" part of the question by "before we ever think of running the system", and the "how" part by "through mere examination of the software text". | | | The concept of static typing is very simple -- a consequence of the simplicity of the object-oriented model of computation. | | | Typing, as noted, determines when to check that the requested routine will be applicable to the requested object; binding determines what version of the feature to apply if there is more than one candidate. |
|
http://archive.eiffel.com/doc/manuals/technology/typing/paper/page.html
(4425 words)
|
|
| |
| | Static Code Analysis |
| | Type inference isn't thant new - several Lisp implementations use it to optimize their code. | | | After a refactoring the wrapper class to use B instead of A you might be putting a type B into the collection and incorrectly casting it to the old A in a wrapper class method | | | Maybe a more appropriate goal would be to watch the code as it runs (particularly unit tests) and view types there; then while you wouldn't be absolutely guarenteed that you have correct type information, you'd usually have good information for analysis. |
|
http://blog.ianbicking.org/static-code-analysis.html
(1584 words)
|
|
| |
| | Bruce Eckel's MindView, Inc: 11-16-04 Static vs. Dynamic |
| | In this regard, their typing system is far safer than a language where dynamic checks are required (Java) or where users can coerce the type system into errors (C/C++). | | | There is an illusion that static type checking can solve all of your problems, followed by the conclusion that more static type checking is always better. | | | But I resist any implications that "all static checking is good, so more is always better." If you think about this you can easily imagine it taken to extremes, and I think that in a number of cases Java has done exactly that, without doing a cost-benefit analysis of the results. |
|
http://mindview.net/WebLog/log-0066
(3108 words)
|
|
| |
| | Static typing |
| | But static typing a la C++ is too constraining for realistic software development. | | | Assignment attempt x ?= y achieves this: it looks at the actual object type, performs the assignment if that type is compatible with that of x, and otherwise assigns to x a void value (which you can then test for). | | | Finally, of course, one should never forget the main argument for static typing: the resulting increase in the safety of the software. |
|
http://archive.eiffel.com/doc/manuals/technology/typing/intro.html
(754 words)
|
|
| |
| | Typing: Strong vs. Weak, Static vs. Dynamic |
| | TypeError: unsupported operand type(s) for +: 'int' and 'str' >>> 1 + 1 2 >>> "1" + "1" '11' >>> 1 + int("1") 2 >>> "1" + str(1) '11' | | | My definition is that a type is metadata about a chunk of memory that classifies the kind of data stored there. | | | This classification usually implicitly specifies what kinds of operations may be performed on the data. |
|
http://www.artima.com/weblogs/viewpost.jsp?thread=7590
(793 words)
|
|
| |
| | KenKinder.com -- Interfaces and Static Typing in Python |
| | The problem is that static can, and will, kill you and your computer dead as a doornail. | | | Guido did say that he would keep the current philosophy that if a class implements all the requisite methods needed for a specific type, it would not have to explicitly inherit from it to be compatible. | | | Of course it would, because static typing only limits what you can do -- all code that works with static typing will naturally work without it -- although perhaps faster. |
|
http://www.kenkinder.com/blog?postid=143
(883 words)
|
|
| |
| | Only Python: Python as pseudo-code and Optional Static Typing |
| | However, given that the optional static typing proposal is new, it should be looked at objectively, without rejecting off-hand proposals that were rejected in a different context. | | | Yet, one of the strength of Python is its syntax, and many objections (NIMPY as GvR described it) to the proposed addition(s) to the language came from an unease with the suggested syntax. | | | Before proceeding further, it might be argued that this is a case of premature optimization: Python does not currently have (optional) static typing so the concept should be discussed first, before implementation details and syntax can be looked at objectively. |
|
http://aroberge.blogspot.com/2005/01/python-as-pseudo-code-and-optional.html
(961 words)
|
|
| |
| | Static typing disciplines |
| | More sophisticated type systems rule out more errors at the cost of complicating the definition of what constitutes a legal program. | | | Greg, >And of course any static typing discipline will be >incomplete. | | | If static typing disciplines are incomplete, then Well-typed programs CAN go wrong! |
|
http://www.seas.upenn.edu/~sweirich/types/archive/1999-2003/msg00291.html
(173 words)
|
|
| |
| | Smalltalk.org™ articles article_20041002_a1.html |
| | It's not possible in Smalltalk to apply an "illegal" operation to the wrong "object type" as a "does not understand" error is generated in the case of an object receiving a message it doesn't have a method for. | | | Advocates of "static type safety" in computer languages must realize and acknowledge that their "type safety solution" didn't prevent this error from occuring. | | | The fact that the ranges of numbers are so tightly constrained by unnecessary "static types" in the vast majority of computer langauges is a serious issue to reliability and fault tollerance and in some cases life and limb. |
|
http://www.smalltalk.org/articles/article_20041002_a1.html
(1823 words)
|
|
| |
| | Ruby: DynamicVsStaticTyping |
| | Types are fundamental aspects of programming languages and type errors are common. | | | To be maximally reusable the types used should be as high up the inheritance tree (nearer the Base Object) as possible, whereas programmers usually, out of laziness, declare parameter types as the most concrete type. | | | With static types we can prove there will be no type errors so one source of errors is eliminated. |
|
http://www.rubygarden.org/ruby?DynamicVsStaticTyping
(1958 words)
|
|
| |
| | Negative results about the power of static typing |
| | On the other hand, we can easily augment our programming language with a type system so that every program with a type will have this property. | | | Say that a program p has type t iff the root of t is p. | | | On the other hand, if our programs take in inputs from some infinite set, then we can use diagonalization to show that there is no effective type system for our language that guarantees termination with an answer. |
|
http://www.seas.upenn.edu/~sweirich/types/archive/1999-2003/msg00327.html
(329 words)
|
|
| |
| | Modern Static Typing: Less Code, Better Code |
| | This is one of the most important points about static typing - solving the problem within the system, or by moving to a new system, is usually preferable to throwing out static typing altogether. | | | 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"? | | | The other 95% of your program that doesn't need to do strange and magical things gets the benefit of type checking, which means you can concentrate your attention on the interesting part. |
|
http://www.xoltar.org/misc/static_typing_eckel.html
(2541 words)
|
|
| |
| | Re: Optional Static Typing |
| | We can come to some consensus on interfaces, and we never will with type declarations; I don't think that's a sign of a structural problem in the Python community, but rather a sign that type declaration doesn't have a well-defined problem or solution. | | | More specifically, I think the problem is that static type declarations aren't closed conceptually. | | | But we don't need that level of static analysis to support source checkers (like PyChecker or PyLint) or to allow auto-completion in IDEs. |
|
http://blog.ianbicking.org/reoptionalstatictyping.html
(770 words)
|
|
| |
| | Pensieri di un lunatico minore » More static typing nonsense |
| | Indirectly, optimization is also served: the best way to optimize code is probably to use type inference, and type declarations can sometimes help the type inferencing algorithm overcome dark spots. | | | But if it indeed can provide type inference algorithms what they need, when used moderately, it might be a worthy addition. | | | But what the Lisp programmer will use in the cases where he targets optimal performance is: optional type informations. |
|
http://blog.amber.org/2005/01/05/more-static-typing-nonsense
(2064 words)
|
|
| |
| | Adding Optional Static Typing to Python |
| | Purely based on the type system, those types are fine: the % operator on two strings does string formatting (e.g. | | | I think I would like to do this using a mechanism separate from inheritance, since I really don't think that it is a good idea to require that int is a subclass of float and float a subclass of complex. | | | While there are third-party program checkers that find a lot of problems without type declarations, e.g. |
|
http://www.artima.com/weblogs/viewpost.jsp?thread=85551
(1970 words)
|
|
| |
| | Python & Java: Side by Side Comparison |
| | Names are bound to objects at execution time by means of assignment statements, and it is possible to bind a name to objects of different types during the execution of the program. | | | strong typing versus weak typing — in programming languages. | | | The binding to an object is optional — if a name is not bound to an object, the name is said to be null. |
|
http://www.ferg.org/projects/python_java_side-by-side.html
(2634 words)
|
|
| |
| | The Fishbowl: Type Inference and Java |
| | As long as the computers do not do the boring task of reading code I like explicit (and static) types. | | | Since methods can't be overloaded based on return type, this kind of inference is easy. | | | It could even detect when you were moving incompatible objects in and out of a collection without any tedious mucking around with expressly declared generics. |
|
http://fishbowl.pastiche.org/2004/05/18/type_inference_and_java
(1613 words)
|
|
| |
| | MF Bliki: DynamicTyping |
| | Another area where static typing is useful is that it allows programming environments to be much more helpful. | | | Somehow things just seem to flow better when you're programming in that environment, even when I'm doing my Ruby in emacs instead of IntelliJ. | | | Despite this, there's still something particularly satisfying about programming in languages like Smalltalk and Ruby - and I think it has a great deal to do with the dynamic typing. |
|
http://martinfowler.com/bliki/DynamicTyping.html
(636 words)
|
|
| |
| | Adding static typing to Python |
| | This is, however, a minor problem if > everyone on the team agrees to document parameter types in the doc > string. | | | I have been writing stuff that cares more about the capability of an object to act in a certain way. | | | That's not > a big problem for small programs but if I have many classes that use > inheritance, it's really not easy to figure out what interface a > parameter actually supports. |
|
http://mail.python.org/pipermail/python-list/2002-February/088288.html
(950 words)
|
|
| |
| | Gail Murphy: On the Use of Static Typing to Support Operations on Frameworks |
| | We found that both conservative contravariant and covariant static typing policies were effec tive in supporting the operations of framework instantiation and framework extension. | | | On the Use of Static Typing to Support Operations on Frameworks | | | This result pro vides a basis for defining and building tools to support the effective use and evolution of frameworks in software engineering environments. |
|
http://www.cs.ubc.ca/~murphy/papers/typing/oos.html
(210 words)
|
|
| |
| | Potential Differences |
| | My last entry on this topic discussed the idea of using the ‘safe’ aspects of static typing for writing robust system facilities, while using the ‘easy’ aspects of dynamic typing for business logic that will probably need to change over time. | | | In writing this MBean, the static typing of Java helped make it robust. | | | Unchecked exceptions help make the code more fungible around business logic, which checked exceptions help make the code more robust around system facilities. |
|
http://gigavolt.net/blog/2003/05/22
(695 words)
|
|
| |
| | Strong Typing and Perl |
| | 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. | | | I explain what typing is about, and why you might want it. | | | Types are deduced automatically by the compiler, so you don't need to declare them. |
|
http://perl.plover.com/yak/typing
(380 words)
|
|
| |
| | Conventions and static typing |
| | After writing and executing a couple of tests, that idea was crushed, as I realized that static typing is as marginally useful and incomplete for error removal, as DTD:s are for validating the contents of an XML doc (an old pet peeve of mine). | | | A nice feature is that they have conventions for exposing interface definitions that enable tools to interface to them without knowing about them in advance. | | | But I know of at least one area where static typing is of great help, and that is development tools. |
|
http://mail.python.org/pipermail/python-list/2003-May/161316.html
(554 words)
|
|
| |
| | static typing : Java Glossary |
| | The identity of all types and constraints is exhaustively computable at compile-time. | | | The types of variables are fixed at compile time, or more precisely are constrained to some set of types. | | | You are here : home : Java Glossary : S words : static typing. |
|
http://mindprod.com/jgloss/statictyping.html
(105 words)
|
|
| |
| | static typing - OneLook Dictionary Search |
| | static typing : Free On-line Dictionary of Computing [home, info] | | | Tip: Click on the first link on a line below to go directly to a page where "static typing" is defined. | | | We found 2 dictionaries with English definitions that include the word static typing: |
|
http://www.onelook.com/cgi-bin/cgiwrap/bware/dofind.cgi?word=static+typing
(81 words)
|
|
| |
| | RE: The Airplane Example (static typing permathread?) |
| | On Wed, 2005-01-05 at 13:05 -0500, Vladimir Gapeyev wrote: > Perhaps it is useless to > spend your energy on discussions like this -- static typing enthusiasts > are as convinced in their point as you are in yours. | | | Previous by thread: RE: The Airplane Example (static typing permathread?) | | | Subject: RE: The Airplane Example (static typing permathread?) |
|
http://www.stylusstudio.com/xmldev/200501/post00140.html
(190 words)
|
|
| |
| | Re: OT: Static/dynamic typing |
| | Since maintenance lasts longer than initial > development this would seem like a clear win for static type-checking > except that it can often bloat and complicate the code and thus provide > more opportunities for bugs to creep in. | | | Compilers dealing with static types (whether or not they're safe) can do all sorts of pedal-to-the-metal tricks that are not available in a dynamically typed environment. | | | Paul Prescod wrote: > When I am creating new code, dynamic type checking almost always allows > me to be more productive than static type checking. |
|
http://www.stylusstudio.com/xmldev/200205/post40710.html
(234 words)
|
|
| |
| | static typing |
| | Static typing catches more errors at compile time than dynamic typing. | | | Ada, C, C++, Haskell, Java, and ML are examples of statically typed languages. | | | Nearby terms: static RAM « static random access memory « static scope « static typing » Station Management » Statistical Analysis System » Statistical Package for the Social Sciences |
|
http://www.linuxguruz.com/foldoc/foldoc.php?static+typing
(88 words)
|
|
| |
| | [E-Lang] static typing |
| | Note that I *like* static typing (or better still, type inference), and have always found programs to be better in essentially every dimension if they were compatible with static typing (simpler, cleaner, more efficient, more maintainable, more robust...). | | | It is a fine tool in my toolbox for making better programs, it's just not the magic bullet that some people claim, and in particular provides no actual guarantees. | | | At least, if 3 or 4 days of E programming does not make them >advocates, we have a bigger problem than the discussion of typing in Walnut >:-) Yup. |
|
http://www.eros-os.org/pipermail/e-lang/2001-June/005336.html
(243 words)
|
|
| |
| | J5’s Blog » Static Typing for all |
| | Static typing for python has been discussed a bit around Red Hat as something that would make developing larger scaled projects in Python a dream. | | | While this doesn’t mean we will get static typing anytime soon, since Guido is pushing it has a good chance of getting into the language. | | | Adding Optional Static Typing to Python — Part II |
|
http://www.martianrock.com/?p=25
(101 words)
|
|
| |
| | Andrew Channels Dexter Pinion: Static Typing in Python |
| | Wherein I write some stuff that you may like to read. | | | I would have thought that decorators (introduced in Python 2.4) would have been sufficient for this. | | | Guido (all hail the BDFL) is talking about adding static typing to Python. |
|
http://www.halfcooked.com/mt/archives/000913.html
(105 words)
|
|
|
