Path: utzoo!attcan!uunet!mcsun!ukc!stl!tom From: tom@stl.stc.co.uk (Tom Thomson) Newsgroups: comp.software-eng Subject: Re: OOP and estimating Message-ID: <3169@stl.stc.co.uk> Date: 27 Jun 90 18:22:03 GMT References: <25062@mimsy.umd.edu> <5253@stpstn.UUCP> <31116@cup.portal.com> <26855613.749b@petunia.CalPoly.EDU> Sender: news@stl.stc.co.uk Reply-To: "Tom Thomson" Organization: STC Technology Limited, London Road, Harlow, Essex, UK Lines: 33 In article <26855613.749b@petunia.CalPoly.EDU> jdudeck@polyslo.CalPoly.EDU (John R. Dudeck) writes: > >A lot of what is gained in OOD is in the de-sequentializing of our problems. >Objects can be considered as independently executing processes. Because of >the extreme decoupling between objects, the problem is broken down into >more manageable pieces. This seems to me that it should make the problem Every OO language I have seen makes this claim. However, every OO language that I've seen (with one experimental exception, a laboratory toy language) insists that the messages are SYNCHRONOUS, that the channels between the processes are UNBUFFERED (and blocking), that every message has a REPLY whose sending is implicit (in result delivery). In other words, the languages require sequential execution, there is no de-sequentialising at all, programs written in OO languages would cease to work if the compiler and/or the execution system stopped enforcing sequential semantics. Claiming OOD provides a lot of gain in de-sequentialising our problems is pure bunkum. The things that OOD really has got going for it are Abstraction with strong encapsulation Inheritance mechanisms to facilitate re-use A reasonably expressive type system (sometimes) all of which are principles that were well understood and practised by competent software engineers (and language designers) long before the wonderful phrase "OO" appeared and became the flavour of the month. The only class of languages which generally provide an escape from sequentiality are the functional languages (logic languages like prolog have sequential semantics; languages like parlog, with moded arguments, may avoid sequentiality so there's a subclass of logic languages that provide the escape too). It's a pity that they don't provide decent abstraction and inheritance mechanisms too - maybe a functional OO language (a contradiction in terms?) would be the answer to our dreams? Tom Thomson [tom@nw.stl.stc.co.uk