Path: utzoo!attcan!uunet!wuarchive!zaphod.mps.ohio-state.edu!rpi!clarkson!news.clarkson.edu!cline From: cline@cheetah.ece.clarkson.edu (Marshall Cline) Newsgroups: comp.object Subject: Re: Do we really need types in OOPL's? Message-ID: Date: 4 Oct 90 15:13:29 GMT References: <0yw10qr@Unify.Com> <411@eiffel.UUCP> <736@tetrauk.UUCP> <1990Sep25.135145.3460@kth.se> <3832@osc.COM> <1990Oct2.170910.4805@eua.ericsson.se> Sender: news@news.clarkson.edu Reply-To: cline@sun.soe.clarkson.edu (Marshall Cline) Organization: (I don't speak for the) ECE Dept, Clarkson Univ, Potsdam, NY Lines: 48 In-Reply-To: euaabt@eua.ericsson.se's message of 2 Oct 90 17:09:10 GMT Nntp-Posting-Host: cheetah.ece.clarkson.edu In article <1990Oct2.170910.4805@eua.ericsson.se> euaabt@eua.ericsson.se (Anders.Bjornerstedt) writes: >Strong typing is not the same thing as static typing. From the rest of your remarks, I *think* we agree in concept, but the terminology you use is perhaps non-standard. Strong typing *DOES* mean static typing [ex: Booch OOD, Meyer OOSC, etc]. It does not necessitate static *binding*, as I and others have repeatedly said. >Magnus Ramstr|m talks >about strong typing and you then go on and talk about static typing. >An example: In Simula you have the notion of requalification, which is like >casting in C or C++ but causes a runtime check. [...] Although this is `type safe', it is not statically typed (strongly typed). Like pointer coersions in C++, this is a hole in Simula's strong type system (put there intentionally for very good pragmatic reasons; real life software engineering isn't always as pretty as Pascal). Pointer coersions in C++ aren't type *safe*, but neither they nor Simula's requalification is statically typable in general. Also in the above referenced message, tma@osc.COM (Tim Atkins) writes: >>In a dynamically typed language >>any message can be sent to any object. In a staticly typed language with >>a common base class only messages understood by the base class may be sent. You act like the ability to send *any* message to *any* object is a wonderful feature of weakly (dynamically) typed languages! In fact it pointedly shows that the compiler can't (and doesn't try to) statically verify that the message is ``safe'' (``safe'' meaning ``that object *IS* equipped to handle this message''). This very ``feature'' (``ability'' to send any message to any object without the compiler helping you statically determine if you'll crash and burn at runtime) makes dynamically typed languages the wrong choice for very large software systems. (Not that this is their goal in life -- they make *great* interactive rapid prototyping environments -- but they don't scale -- which is ok so long as both tools are used for what they are designed). Marshall Cline -- PS: If your company is interested in on-site C++/OOD training, drop me a line! PPS: Career search in progress; ECE faculty; research oriented; will send vita. -- Marshall Cline / Asst.Prof / ECE Dept / Clarkson Univ / Potsdam, NY 13676 cline@sun.soe.clarkson.edu / Bitnet:BH0W@CLUTX / uunet!clutx.clarkson.edu!bh0w Voice: 315-268-3868 / Secretary: 315-268-6511 / FAX: 315-268-7600