Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
Foundations of Object-Oriented Languages: Types and Semantics
In recent years, object-oriented programming has emerged as the dominant computerprogramming style, and object-oriented languages such as C++ and Java enjoy wide use in academia andindustry. This text explores the formal underpinnings of object-oriented languages to help thereader understand the fundamental concepts of these languages and the design decisions behindthem.The text begins by analyzing existing object-oriented languages, paying special attention totheir type systems and impediments to expressiveness. It then examines two key features: subtypesand subclasses. After a brief introduction to the lambda calculus, it presents a prototypicalobject-oriented language, SOOL, with a simple type system similar to those of class-basedobject-oriented languages in common use. The text offers proof that the type system is sound byshowing that the semantics preserves typing information. It concludes with a discussion of desirablefeatures, such as parametric polymorphism and a MyType construct, that are not yet included in moststatically typed object-oriented languages.
- ISBN-10026202523X
- ISBN-13978-0262025232
- PublisherMit Pr
- Publication dateMarch 21, 2002
- LanguageEnglish
- Dimensions8.25 x 1.25 x 9.25 inches
- Print length404 pages
Frequently purchased items with fast delivery
- Programming Language PragmaticsPaperbackFREE Shipping by AmazonGet it as soon as Wednesday, Oct 7Only 1 left in stock - order soon.
- General System Theory: Foundations, Development, ApplicationsPaperbackFREE Shipping on orders over $35 shipped by AmazonGet it as soon as Wednesday, Oct 7
- Data Structures and Algorithms in JavaPaperbackFREE Shipping by AmazonGet it as soon as Wednesday, Oct 7Only 5 left in stock - order soon.
- C++ Software Design: Design Principles and Patterns for High-Quality SoftwarePaperbackFREE Shipping by AmazonGet it as soon as Wednesday, Oct 7
- Designing and Implementing Semantic Data LayersDave WellsPaperbackFREE Shipping by AmazonGet it as soon as Wednesday, Oct 7
Editorial Reviews
About the Author
Kim B. Bruce is Frederick Latimer Wells Professor of Computer Science at Williams College.
Product details
- Publisher : Mit Pr
- Publication date : March 21, 2002
- Language : English
- Print length : 404 pages
- ISBN-10 : 026202523X
- ISBN-13 : 978-0262025232
- Item Weight : 2.3 pounds
- Dimensions : 8.25 x 1.25 x 9.25 inches
- Best Sellers Rank: #3,192,538 in Books (See Top 100 in Books)
- #480 in Object-Oriented Software Design
- #945 in Object-Oriented Design
- #10,772 in Computer Software (Books)
- Customer Reviews:
About the author

Kim Bruce is the Reuben C. and Eleanor Winslow Professor of Computer Science at Pomona College, where he helped found and served as the first chair of the new Computer Science Department. He is the Frederick Latimer Wells Professor of Computer Science emeritus at Williams College, where he taught for 28 years. His first position out of graduate school was as an instructor in Mathematics at Princeton University from 1975 to 1977.
He has also served as a visiting professor or scientist at the University of California at Santa Cruz, Princeton University, the Newton Institute at Cambridge University, the Ecole Normale Superieure in Paris, Stanford University, University of Pisa, and M.I.T. He has served as a consultant for Prime Computer, Digital Equipment Company (DEC), NEC Research Institute, and EcoNovo.
He received a B.A. from Pomona College in 1970, and M.A. (1972) and Ph.D. (1975) degrees from the University of Wisconsin at Madison, all in Mathematics with a specialty in mathematical logic and a minor field of Computer Science. Five years after receiving his Ph.D., he spent a year on leave at M.I.T. where he studied and began research in Computer Science. In 2004-2005, he spent a year at the University of California at Santa Cruz where he started studying a new field once again, this time linguistics.
His research program was originally in the model theory of languages with generalized quantifiers, but his interests turned to programming languages after his stay at M.I.T. His research focus evolved from models of the polymorphic lambda calculus to the study of semantics and type theory, as well as language design, especially of object-oriented languages. His research in computer science has been supported by many NSF (and other) research grants, and has resulted in many published papers in conferences and journals as well as numerous invited talks at conferences. He also co-founded and obtained NSF funding to establish the series of International Workshops on Foundations of Object-Oriented Languages (FOOL), and served as its steering committee chair until 2001. He is currently working on research in linguistics to develop formal models of the context of a continuing dialog, with special interest in the interactions between participants and how the context is built as a conversation progresses.
He has a long-standing interest in Computer Science education. He played a major role in setting up the Computer Science major at Williams College and was the founding chair of the Computer Science Department there. He was one of the founding members of the Liberal Arts Computer Science Consortium, and has contributed to each of their three model curricula for liberal arts colleges. He was a member of the joint ACM - IEEE CS Joint Curriculum Task Force responsible for Curricula 1991 and contributed to Curricula 2001. He has also served on several ACM and IEEE task forces, most recently the ACM Java Task Force responsible for creating a Java library to be used in CS 1 courses. He has also served several times on the organizing committee for the series of workshops on Pedagogies and Tools for the Teaching and Learning of Object-Oriented Concepts. He has served on visiting committees for the computer science and/or math departments of more than 15 liberal arts colleges. In recognition of his work in Computer Science education, he was given the ACM SIGCSE 2005 award for Outstanding Contributions to Computer Science Education.
Customer reviews
- 5 star4 star3 star2 star1 star5 star0%70%30%0%0%0%
- 5 star4 star3 star2 star1 star2 star0%70%30%0%0%0%
- 5 star4 star3 star2 star1 star1 star0%70%30%0%0%0%
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonTop reviews from the United States
- 4 out of 5 stars
Typing skills for computer scientists
Reviewed in the United States on August 19, 2004This is a useful introduction to the theory behind data types in object oriented (OO) languages. It starts at a very readable pace. The first section (about 100 pages) covers the basics of OO languages and OO features, and establishes a working vocabulary. For example, it introduces the very distinct notions of subclass and subtype early on. That is important, if only because words like "subtype" have different meanings when used by different authors. Barbara Liskov, for example, used a semantic definition for "subtype" in her famous substitutability principle, a definition that can not be checked by automatic tools. Here, the definition talks only about the information you might find in a Java interface or C++ abstract class, and can be checked automatically. This early discussion also defines the problem to be solved: creating programming languages that are richly expressive, that compile to efficient code, and that are rigorously type safe, goals that often conflict. The clear statement of the problem is very informative, by itself, and casual readers might stop at this point.
The next brief section defines a mathematical notation, a lambda calculus, for discussing types. In this calculus, a "record" or "struct" keyword is an operator that aggregates other types together into a new unit, and C++ templates are functions that generate new types. This calculus feeds into a formal logic that proves statements about types the same way standard arithmetic proves statements about numbers.
This isn't nearly as daunting as a normal proof of program correctness, by the way. Behavioral correctness deals with a program's changes of state over time; this treats the program as a static, compile-time entity. Also, for better or worse, it skips the most of the category theory that often accompanies type formalisms.
The remaining 200 pages or so constitute the real meat of the discussion. Bruce takes the first section's intuitive ideas about types and languages, phrases them in the second section's formalism, and uses that language to analyze several small, purpose-built OO languages with different type systems. Along the way, Bruce makes a few remarkable claims. One is that, although multiple inheritance can cause pragmatic problems for developers, it's no big deal for the mathematical tools. The real problem is deciding what you mean by multiple inheritance, where C++ and Eiffel provide only two of the possible answers. (Agreed - coming up with something useful to say is often harder than saying it.) Another is that classes really aren't necessary for strong OO typing. Classes are just names for collections of features, and it's the features in the collections that matter. (I see the theory, but I'm not sure that this leads to practical improvements in language design.) Many of these results are quite clear even if you, like me, skip some of the hairier proofs.
This is certainly not a book for a beginner to programming or to OO. It's really about the theory of how languages work. It will be of use to developers who create new languages, compilers, or language-smart CASE tools. I doubt that most others will find information relevant to their work. If you really care about the fussy bits of an OO language's type system, though, this book will be very helpful.
//wiredweird
37 people found this helpfulSending feedback...Sending feedback...HelpfulThank you for your feedback.Sorry, we failed to record your vote. Please try againThanks, we'll investigate in the next few days.Sorry, We failed to report this review. Please try againWe'll check if this review meets our community guidelinesOpens in a new tab. If it doesn't, we'll remove it.
CancelReport - 3 out of 5 stars
Three Stars
Reviewed in the United States on July 30, 2014While more practical than some books, this is still a lot of theory and notation.
One person found this helpfulSending feedback...Sending feedback...HelpfulThank you for your feedback.Sorry, we failed to record your vote. Please try againThanks, we'll investigate in the next few days.Sorry, We failed to report this review. Please try againWe'll check if this review meets our community guidelinesOpens in a new tab. If it doesn't, we'll remove it.
CancelReport











![OAE Foundations of Reading (190) Study Cards: OAE Foundations of Reading Exam Prep and Practice Test Questions for the Ohio Assessments for Educators [Full Color Cards]](https://m.media-amazon.com/images/I/41zL1YpR3-L._AC_SR100,100_QL65_.jpg)