Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP Posting-Version: version B 2.10.2 9/18/84; site aurora.UUCP Path: utzoo!watmath!clyde!burl!ulysses!mhuxr!mhuxn!ihnp4!qantel!hplabs!ames!aurora!al From: al@aurora.UUCP (Al Globus) Newsgroups: net.lang.c Subject: Object Programing and Objective C Message-ID: <401@aurora.UUCP> Date: Thu, 3-Oct-85 20:53:44 EDT Article-I.D.: aurora.401 Posted: Thu Oct 3 20:53:44 1985 Date-Received: Sat, 12-Oct-85 17:36:45 EDT Distribution: net Organization: NASA Ames Research Center, Mtn. View, CA Lines: 158 My earlier posting regarding Objective C elicited a number of responses, many of whom wished to know more. The following is much of my knowledge and experience with object programming and Objective C. For the purpose of this piece, object programming refers to a programming methodology limited to a single process, on a single processor, within a single address space. No parallelism is implied by the term message (see below). There are other meanings for object programming, but they are not addressed here. Objective C was developed and is marketed by PPI, 27 Glen Road, Sandy Hook, CT 06482 (203) 426-1875. The primary advantages of object programming and Objective C are improved modularity, reduced code bulk (lines of code), and a better mapping between many problems and the software. I was originally attracted to object programming because it could have solved some of the problems I ran into developing a dynamic display editor (completed in C a year and a half ago). Specifically, I think that using Objective C I could have built the editor in 4-5,000 lines of code rather than the 20,000 or so it actually took. The result would have had better modularity and taken perhaps 35% less time to complete. Powerful incentives. I have used Objective C to implement a prototype of a simulation. This simulates the activities of the crew on-board NASA's space station which is to be launched in the early 1990's. The prototype went well and we are now a few weeks away from finishing the first beta test version. This work has also gone well, somewhat better than expected actually. All told I have written about 1500 lines of Objective C. Objective C is a preprocessor for the C language. It adds SMALLTALK-like messaging, objects, classes, and inheritance to C. The preprocessor runs after the C preprocessor and outputs C source code. Normal C code is passed through unchanged, so you keep all of C. Essentially, Objective C adds syntax to declare classes and messages; and a new expression, messaging. The messaging expression has all of the properties of any C expression, i.e., it evaluates to a value and can be used anywhere a normal C expression can be used. Object programing software consist of objects that exchange messages. Think of objects as synthetic machines or people that remember information, do particular things, and interact by sending each other messages. Since the real world consists of objects that interact, object programs frequently reflect the problem domain better than convential techniques (i.e., operators that work on operands). Objects contain both code and data. The data is private and can (normally) only be accessed directly by the object's code (as usual in C, there are ways to get around this). Every object is a member of a class. Each class consists of one FACTORY object and zero or more INSTANCE objects. The factory object is usually used only to create instance objects. Every instance object in a single class has the same data structure, although values may vary, and the same code. This code is called the object's METHODs. Each method corresponds to a message that the object understands. Programming in Objective C is mostly a matter of writing classes. Each class goes in a separate file. In summary, objects are chunks of code and data with a single pointer to the whole mess, rather than a pointer to the data and a pointer to each function that works on the data as in conventional data hiding approaches in C. This improves modularity at a very fundimental level. Messages are somewhat equivalent to function calls. Messages cause a piece of code to be executed, can have arguments, and return a value. The difference is that the code executed and the data worked on depends on the object the messages is sent to. Messages give several advantages. One is that you can add new sorts of things (classes of objects) to a system without modifing the code that tweeks these objects, causing them to save to disk for instance. Another is that the name space of messages is partitioned between classes so name collisions are infrequent; thus the practice of prepending names with characters to identify different parts of a large system becomes unnecessary and names like IPDJMOVE disappear. Also, when you change graphic libraries you don't get the name collisions that have cost me several days of frustrating debuging. Finally, the giant switch statements common to programs that must deal with many different kinds of data disappear. These switch statements usually switch on a field that tells the type of the data and the code (semantics) for each type goes into the case portion. With Objective C the semantics go into each separate class. This gives better modularity and reduces code bulk a bit. The last major property of object programming is inheritance. Classes are arranged into a heirarchy (a tree) with the Object class at the top (root). Each sub-class inherits all of the data structures (INSTANCE VARIABLES) and methods of its superclass. In general, sub-classes are specializations of their super-class, with the Object class being the most general of all. Inheritance saves large amounts of code since sub-classes need only add the new methods and data they need and over-ride any methods that are inappropriate. In addition, new data and/or methods can be given to all objects in a system simply by modifying the Object class. Inheritance, then, can reduce code bulk substantially. Reduction in code bulk can save enormous amounts of money in large systems. According to Putnam, a software metrician, life cycle software cost is proportional to the cube of code bulk. Since theoretical consideration and some empirical evidence suggest that object programming can reduce code bulk by a factor of 2 to 10, in principle cost should be reduced by a factor of 8 to 1000. I don't know if the savings are that large, but they may be substantial. Objective C has got some additional nice stuff for the working programmer. First, there are two messages defined by the Object class, storeOn: and readFrom:. storeOn: will save any instance object and all the objects it references recursively to disk in a readable ascii file. readFrom: will read a file created by storeOn: and recreate the same graph of objects. I.e., with one line of code you can save or retrieve ANY data structure created out of objects - or send it around the world on the net! Second, all messages go through the messaging function. There is a global flag, msgFlag, that, when set, will print out a trace of all messages. This is incredibly useful for debugging. When you get bus error - core dumped, just run the program again with msgFlag set (I set it from the command line) and the trace will tell you right where the crash occured. Third, if an object receives a message it can't understand you get an error message and a stack trace leading you directly to the problem. Lastly, PPI provides a number of classes with the compiler. I have found these to be extremely useful. Objective C isn't perfect of course. Here are the main disadvantages I've found: Too expensive. I wish they'd cut the cost and sell thousands of copies. It may be worth the current price, but that doesn't mean enough people will buy it. Its got a few bugs. None of them have hurt too badly but the system is not as mature as it could be. PPI's support has been excellent and I think this problem will eventually be ironed out. Compile time is long. Objective C does a full parse of C and then spits out a complete C program which must be parsed by the local compiler. PPI is working on an interpreter call VICI that may solve this problem. Classes are divided into groups called phyla. I still don't understand phyla and have had problems as a result. Phlya are used to optimize message passing and are a pain in the .... Object programming is not appropriate for all problems. It has been used for compilers, operating systems, simulations, and user interfaces at least. I'm not sure exactly what the boundaries of usefulness are. Its not available on the MacIntosh. Speaking of availablility, Objective C is available on a lot of UNIX systems and the IBM PC. PPI is working on MacIntosh and VMS versions. The bottom line: I love it. I hope I never have to go back to functions and data structures, objects are for me. I also convinced NASA (I'm a contractor) to spend almost $20,000 on object programming software, and we're real short of money these days.