Smalltalk, Objects, and Design
ASIN: 1583484906
Average Customer Review: 4.5, based on 15 reviews.
Customer reviews (5 of 15)
Elegant, 2006-12-20, Rating: 5.
If Chamond Liu's code writing is as good as his writing in this book...it must be elegant.
Not what I was looking for, 2005-07-29, Rating: 3.
I wanted a book I could pick up, read fast, and get a quick, passable knowledge of Smalltalk from. This was not the book, but perhaps it never meant to be.
It meant to be used by someone sitting down at a keyboard with a Smalltalk compiler in hand (i.e., not me). The book starts gently, with a few simple expressions to type at the interpreter's command line. Before it even gives the syntax for a Smalltalk function, though, it gives a comparison if the different syntaxes used for inheritance in seven languages, four obscure or obsolete (p.23). The next sections explain simple language elements, unfortunately in terms of GUI-based tools that the reader may not have at hand.
The next few sections wander back and forth between language features, OO design topics, a deeper look under the compiler covers than any beginner really needs, and a shallower look at the libraries than anyone could get by on. This last is especially frustrating in a "small" language, where so much of the capability is built up in the libraries. Instead, we just see a keyword here and there, with no attempt to bind them into a coherent whole. This organization could possibly have made sense if the book were a text for a semester course. If so, it's true to its breed: I generally find them to be poor self-study guides, especially for experienced programmers.
Perhaps this book is good for some purposes, just not for mine.
//wiredweird
It meant to be used by someone sitting down at a keyboard with a Smalltalk compiler in hand (i.e., not me). The book starts gently, with a few simple expressions to type at the interpreter's command line. Before it even gives the syntax for a Smalltalk function, though, it gives a comparison if the different syntaxes used for inheritance in seven languages, four obscure or obsolete (p.23). The next sections explain simple language elements, unfortunately in terms of GUI-based tools that the reader may not have at hand.
The next few sections wander back and forth between language features, OO design topics, a deeper look under the compiler covers than any beginner really needs, and a shallower look at the libraries than anyone could get by on. This last is especially frustrating in a "small" language, where so much of the capability is built up in the libraries. Instead, we just see a keyword here and there, with no attempt to bind them into a coherent whole. This organization could possibly have made sense if the book were a text for a semester course. If so, it's true to its breed: I generally find them to be poor self-study guides, especially for experienced programmers.
Perhaps this book is good for some purposes, just not for mine.
//wiredweird
Great book for beginners and no-longer-beginners alike, 2005-01-17, Rating: 5.
When I first looked into this book I thought "Oh well, this is just another book for Smalltalk and OOP beginners". Well I was wrong.
This book starts indeed from the fundamentals (objects and messages) and warns against certain pitfalls that beginners are prone to. It covers a few aspects of the class library, especially container classes as well as the MVC paradigm.
This book strongly focuses on design questions, i.e. "When to buy and when to inherit". It has a great chapter on "Specificaton inheritance" vs. "Implementation inheritance" and a chapter explaining the concept of design patterns as well as giving some example patterns for Smalltalk.
While a Smalltalk beginner might need more books to give a more complete introduction into the class library, this is a good book to expose beginners to the nuances of Smalltalk and OOP. The more advanced will appreciate the nuances in the design discussions especially in the 2nd half of the book.
In summary I can highly recommend this book for beginners and no-longer-beginners alike.
This book starts indeed from the fundamentals (objects and messages) and warns against certain pitfalls that beginners are prone to. It covers a few aspects of the class library, especially container classes as well as the MVC paradigm.
This book strongly focuses on design questions, i.e. "When to buy and when to inherit". It has a great chapter on "Specificaton inheritance" vs. "Implementation inheritance" and a chapter explaining the concept of design patterns as well as giving some example patterns for Smalltalk.
While a Smalltalk beginner might need more books to give a more complete introduction into the class library, this is a good book to expose beginners to the nuances of Smalltalk and OOP. The more advanced will appreciate the nuances in the design discussions especially in the 2nd half of the book.
In summary I can highly recommend this book for beginners and no-longer-beginners alike.
Like the title, this book is pure distilled information, 2004-08-29, Rating: 5.
"Smalltalk, Objects, and Design" is such a simple and unexciting title, and yet that's what this book is, in its entirety. This book will teach you about Smalltalk, it will teach you about objects (using Smalltalk as the medium, but you will learn much about Object Oriented programming that is applicable in any language), and it will teach you about good design principles.
It is written in clear, straightforward prose. In each chapter, the author presents a new idea, discusses the reason for that idea and its implementations (and often discusses several alternative solutions to a given problem that have been adopted historically or in other languages, as well), then gives some concrete examples, some exercises to reinforce the point, and then summarizes. I learned a lot of things in this book that I only vaguely understood before. How garbage collection works. How Smalltalk really accomplishes "everything is an object." What "weak references" are and how to use them. How the Model-View-Controller framework works. There are good discussions about inheritance and how to avoid overusing it, implementation of polymorphism, reifying methods, and so on. Good, meaty stuff especially for the beginning OO programmer.
This book talks about Smalltalk from a design perspective, so while there is an introduction to Smalltalk and a lot of examples to help you learn, it really isn't intended to teach the language. If you have no Smalltalk experience at all, the book will teach you enough to follow along, but you'll want another book to go further in the language. It is fairly implementation-neutral; the author uses IBM's VisualAge for his examples, but he provides tables and footnotes when it's necessary to point out the differences with other Smalltalk implementations such as VisualWorks, and as a VisualWorks user myself, nothing in this book threw me off.
Objects are explained in great detail, starting with the hierarchy (in Smalltalk), what classes really are, how inheritance really works, "buying" vs. "inheriting" (i.e., "has-a" vs. "is-a"), abstract classes, Containers, polymorphism, and many other crucial OO concepts. Again, it's focused on Smalltalk but if you do OO-programming in Java or C++ or some other language, there is a lot here that will be useful to learn (and the author even adds footnotes here and there commenting on how certain things are done in C++ or other languages).
The design chapters are good, though not as thorough, as software design is really a vast subject requiring many books in its own right. The author gives brief treatment of a lot of practices covered in much more detail in other books; for example, there is a chapter on design patterns, much of which is adapted from the famous "Gang of Four" book "Design Patterns" (Gamma, Helm, Johnson, and Vlissides). The author talks about CRC cards, UI design, software engineering practices, frameworks, and other topics that can't really be done justice in a chapter each.
If I were teaching a class in Object-Oriented Programming, I would use Smalltalk as the language to teach basic OO concepts, and I would use this book as the text. Even if I had to use Java as the teaching language, I would find a good Java-based book on OO-programming, and supplement it with this one.
The final chapter, "Why Developing Software is Still Hard," was the author's opportunity to digress, and is worthwhile for all new programmers to read. Basically, there is a lot of Object-Oriented Kool-Aid out there, and if you take this chapter to heart, you'll avoid drinking some of it.
It is written in clear, straightforward prose. In each chapter, the author presents a new idea, discusses the reason for that idea and its implementations (and often discusses several alternative solutions to a given problem that have been adopted historically or in other languages, as well), then gives some concrete examples, some exercises to reinforce the point, and then summarizes. I learned a lot of things in this book that I only vaguely understood before. How garbage collection works. How Smalltalk really accomplishes "everything is an object." What "weak references" are and how to use them. How the Model-View-Controller framework works. There are good discussions about inheritance and how to avoid overusing it, implementation of polymorphism, reifying methods, and so on. Good, meaty stuff especially for the beginning OO programmer.
This book talks about Smalltalk from a design perspective, so while there is an introduction to Smalltalk and a lot of examples to help you learn, it really isn't intended to teach the language. If you have no Smalltalk experience at all, the book will teach you enough to follow along, but you'll want another book to go further in the language. It is fairly implementation-neutral; the author uses IBM's VisualAge for his examples, but he provides tables and footnotes when it's necessary to point out the differences with other Smalltalk implementations such as VisualWorks, and as a VisualWorks user myself, nothing in this book threw me off.
Objects are explained in great detail, starting with the hierarchy (in Smalltalk), what classes really are, how inheritance really works, "buying" vs. "inheriting" (i.e., "has-a" vs. "is-a"), abstract classes, Containers, polymorphism, and many other crucial OO concepts. Again, it's focused on Smalltalk but if you do OO-programming in Java or C++ or some other language, there is a lot here that will be useful to learn (and the author even adds footnotes here and there commenting on how certain things are done in C++ or other languages).
The design chapters are good, though not as thorough, as software design is really a vast subject requiring many books in its own right. The author gives brief treatment of a lot of practices covered in much more detail in other books; for example, there is a chapter on design patterns, much of which is adapted from the famous "Gang of Four" book "Design Patterns" (Gamma, Helm, Johnson, and Vlissides). The author talks about CRC cards, UI design, software engineering practices, frameworks, and other topics that can't really be done justice in a chapter each.
If I were teaching a class in Object-Oriented Programming, I would use Smalltalk as the language to teach basic OO concepts, and I would use this book as the text. Even if I had to use Java as the teaching language, I would find a good Java-based book on OO-programming, and supplement it with this one.
The final chapter, "Why Developing Software is Still Hard," was the author's opportunity to digress, and is worthwhile for all new programmers to read. Basically, there is a lot of Object-Oriented Kool-Aid out there, and if you take this chapter to heart, you'll avoid drinking some of it.
One of The Very Best, 2004-04-26, Rating: 5.
I have always been reading reviews before buying a book from Amazon, and those reviews helped me greatly. I have long been thinking that I should give some back to my fellow readers by contributing to reviews on the site, yet I was busy and lazy, until one book knocked off my feet. "Smalltalk, Object and Design" is this book! It is worthy the praise of being a classic. As an OOP programmer, I am always aware of smalltalk but never actually used it. Yet smalltalk has such a venerable status in OOP language evolution, and I almost felt that without having at least some idea about that language, one can not fully understand all other OOP languages at work and put them in perspective. That is the reason that I started to search for a smalltalk introductory book, even though I don't plan to study smalltalk for living. Liu's book came on top, and I couldn't be happier after reading it. The book does contain a very concise introduction about smalltalk, yet the gem of the book is really about OO design and practise. It touches the OO topics and philosophy in such a deepth and breadth that is rarely seen in other publications, not to mention the pleasant wonder from author's lucid writing style that put all that invaluable insight in just about 300 pages. As a programmer, you owe yourself a chance to read this invaluable work, and we all owe author for writing such an excellent text.
Projects