Smalltalk

Average customer rating:

The Bible of Object Orientation
One of the best book
Out of date but classic

Smalltalk 80: The Language (Addison-Wesley Series in Computer Science)
Adele Goldberg , and David Robson
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Squeak: Learn Programming with Robots (Technology in Action)
Squeak: Object-Oriented Design with Multimedia Applications
Smalltalk, Objects, and Design
Smalltalk Best Practice Patterns
Squeak: A Quick Trip to ObjectLand

ASIN: 0201136880

Customer Reviews:

The Bible of Object Orientation.......2006-08-22

This book contains all the theory of object orientation you will ever need. It clear, brilliantly ordered, and besides this, it's refined and exquisite to read. There is a high chance you will have a great time reading it, even if you have spent years programming in other object oriented languages but Smalltalk.
I think it's also a "must" if you work with any object oriented language.
The fact that it's been written 20 years ago it's unimportant for me, because this book addresses mostly theoretical issues regarding Object Orientation.
So my humble advice is, if you want to really understand objects, know what a meta-class inherits from or what is a Behavior, and have fun on the way, read this book.
Some old friends of mine used to say: "it is the only computing science book there is" :)

One of the best book.......2001-12-28

"Smalltalk/80 - The Languaje" is not only a clasical book, it's a very modern book. Most of the content is incredible actual and very funny to read.

You can't say "I know Smalltalk" if you don't read it.

Out of date but classic.......1999-11-09

I suppose everyone who uses Smalltalk should have a copy of this book, even if it's just to sit on the shelf, though you will of course get more repect if you have the older out-of-print version (S.80- The language and its implementation).

There are two problems with the book for a Smalltalk user of today:

1) The book was written a long time ago, and Smalltalk pioneered a lot of concepts in programming languages and IDEs, so very often the terms used for various things are not the terms we would use today; This makes for a confusing read at times.

2) The book is not very helpful from a practical point of view, if you are a new Smalltalk programmer struggling to get to grips with the class library because nearly every implementation these days has a plethora of non-standard extensions which obviously aren't covered, so what you are left with is a guide to the language syntax, which of course famously fits on one page of A4, and a brief look at some of the standard collection classes.

Customer Reviews:

If there was ever a book that needed to be brought back into print..........2007-03-23

If someone out there from Addison-Wesley is listening, hopefully they'll hear this plea to bring "Smalltalk-80: The Language and its Implementation" back into print. There is simply no better resource to completely cover this beautiful, unique system. Smalltalk is an extremely important language for both OOP and otherwise; there are volumes of concepts here that are remarkably relevant to this day, and yet we still have much to learn that our friends at Xerox PARC were able to accomplish 20+ years ago.

We like to think today that we know how to write books on programming, but I'll tell you, this is one of the most enjoyable books I've ever read on the subject. Surprisingly clear and thought-provoking, this book doesn't beat you over the head with the concept, but gives a basic idea and lets you use your own creativity in applying the material. Truly a book that appreciates the "programming is an art and a science" philosophy.

My copy of "Smalltalk-80: The Language" should arrive at my doorstep any day now :)

Average customer rating:

Great for understanding why smalltalk code is written like it is
The Zen of OO
Missable
Milestone for Your Programming Life
Real OO, not just for Smalltalkers

Smalltalk Best Practice Patterns
Kent Beck
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

The Design Patterns Smalltalk Companion (Software Patterns Series)
Smalltalk, Objects, and Design
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)
Smalltalk 80: The Language (Addison-Wesley Series in Computer Science)
Smalltalk With Style

ASIN: 013476904X

Book Description

This book presents a set of patterns that organize all the informal experience successful Smalltalk programmers have learned the hard way. Understand these patterns, and you can write much more effective code. Understand the concept of Smalltalk patterns and why they work. Then learn patterns for working with methods, messages, state, collections, classes and formatting. Walk through a development example utilizing patterns.Smalltalk programmers, project managers, teachers and students -- both new and experienced.

Customer Reviews:

Great for understanding why smalltalk code is written like it is.......2007-02-13

I have just recently started looking at smalltalk and like many people (being used to c++), when starting out in smalltalk, just going through the code didn't actually tell me much about anything, it's hard to find where anything is actually being done. After reading this book this task was significantly easier, the reason is simple, after going through this book one gets a much deeper understanding about why the code is split the way it is and gains a real insight into why this is a better approach than the usual C++ style with 100-200 lines of code methods. Kent Beck's writting makes the book a very nice read, must admit i was actually sorry when i finished it.

The Zen of OO.......2006-02-17

I wish more Java/C#/C++ programmers would read this (and maybe even learn Smalltalk) so that they can appreciate the weaknesses in those languages and possibly in their practices that they might not even realize today. I certainly did. While Robert Martin and others have offered up some of the canon of good design for contemporary developers, this little gem really reveals the "feel" of good OO.

Missable.......2005-08-01

I'm always looking for ways to make coding work better, at any level from nanosecond arithmetic operations to decade-long enterprise operations. I didn't find much of use here, but there were a few good points here (very few). Let me start with those.

The "Execute Around Method" pattern is good idea, applicable far beyond this Smalltalk context. The Beta language has "inner" inheritance, which makes the idea easy, but most other languages lack a good mechanism for undefined logic between matched operation pairs (open/close, setup/cleanup, etc.) "Enumeration" is another good one, enshrined as "Visitor" in the Gang of Four book.

Most of what's left is either trivial or Smalltalk-specific and face it, Smalltalk is mostly a cult language with nearly no commercial significance. The Smalltalk pretty-printing and variable-naming rules, fatuous at best, are just not applicable to most langages. Some of Beck's "practices" are language features (like 'super'). Other "practices", like the long chapter on Collections, seem to describe standard library classes and messages. Yet others (e.g. Type Suggesting Parameter Name) correct language defects - Smalltalk chose to give up the error detection capability offered by variable typing. Beck tries to sneak it back in with variable naming conventions sort of like Microsoft's old Hungarian naming. Some of his suggestions are just dangerous, like that one that says a constructor should "half-way construct an object in one place, then pass it off to another to finish construction. (p.23)" This distributes an object's setup responsibility across its client classes, leaves unusable and incomplete objects floating around, and causes subtle exposures in multithreaded systems - I'd rip out any code I saw built this way.

The good news is that no new trees died to make my copy of this book - I got it used, and it's returning to the used market. At least my conscience is clean on that account, no matter what I'm doing to the poor guy who buys this book next.

//wiredweird

Milestone for Your Programming Life.......2002-07-31

SBPP has changed me. Kent Beck has changed me.

SBPP shed a new light on my previous knowledge of "patterns" in computer programming. I was deep in the DP tar pit. SBPP saved me. SBPP changed almost all my thoughts on programming. It has changed what I value, and how I pursue it.

Kent Beck says that he is not a great programmer but just a pretty good programmer with great habits. Build great habits with this book. Read and reread this book every morn.

If you have studied DP, this book will open your eyes to the wider world of patterns. You will think about DPs quite differently after this book. You will be able to escape from the bad effects of DP abuse.

If DPs were nouns, verbs and adverbs/adjectives, SBPP are articles and auxiliary verbs. SBPP are used much more frequently than DPs. When you learn a language it is very important to learn more frequently used words first. It could be less efficient(or even dangerous) to learn "appreciate" before "thank (you)".

--JuneKim

Real OO, not just for Smalltalkers.......2002-04-29

I wish I had read this book when I started getting into OO programming. This is OO to the max, at maximum granularity.

Customer Reviews:

Excellent book for beginners, provides for fun baby steps........2005-07-15

I will be subjective on this: If you are a beginner on Smalltalk/Squeak and want to wet your feet in an amicable way, this is a great book. In contrast to other more advanced books, this one includes a CD which has the Squeak 3.0 image, somewhat dated but follows exactly what the book is talking about. Anyway, you can always download the latest and greatest Squeak form http://squeak.org.

Call me lame but when I am learning something from scratch I need guidance and I like to make fun baby steps which take me in the right direction with the least bore or frustration. You will be pleasantly surprised that this book also covers a lot of ground.

I am giving this book 5 stars :-).

An unstructured introduction to Smalltalk, not for everyone.......2003-01-20

Smalltalk is a language that I have played with on and off over the years, but have never approached with a great deal of seriousness. This spring, I will be teaching a course in programming language concepts for the first time. Therefore, when I received this book, I was happy for the chance to refresh my knowledge of the language. Squeak is an open source implementation of Smalltalk and it is very easy to use. The CD with the book contains an implementation of Squeak and it is possible to download it from the website ...BR> Written in the style of a chat between the user and a Smalltalk objective wizard, the conversation steps you through the basics of object-oriented programming, as implemented in Smalltalk. It is not a typical book on how to program, to get up to full speed in Smalltalk, you will have to find some additional material to work through. Nevertheless, it works very well as an introduction to the structure of the Smalltalk language.
To people who are accustomed to reading traditional introductory programming books, this one may turn them off. While there is some of the traditional sequence that starts with a "Hello World" program and goes through variables, conditional expressions and loops; file I/O and user-defined data types, it lacks much of the standard structure. The authors rely on the chat method sending messages to shift the knowledge from source object to target object.
If you are interested in a basic introduction to the Smalltalk language and can tolerate a conversational approach to learning, then this book will work for you. However, if your interest is in learning more than the basics or you prefer a structured approach to learning, then this book will probably not serve your needs.

Nice introduction to squeak.......2002-10-08

As an object-oriented programmer, I found this to be an excellent book despite some obvious deficiencies. As a C++ and Java programmer accustomed to using VI, I found this book helpful in that it contains a very nice introduction to the Squeak environment, in which all squeak code is written and run. The book covers Smalltalk syntax and basic OO design. It is written in an enlightened manner as a dialog between two objects (a teacher and a student) who pass messages back and forth. In this manner, the object-oriented paradigm is used even in so far as the gramatical style of the book. It is a quick and fun read but at times trite. A few obvious typographical errors exist. Unfortunately, the arrangement of topics in the book is awkward and prevents anyone from experimenting with any substantial code until they have finished 3/4 of the book. It is essential that anyone new to Smalltalk works the exercises as they appear in the text inorder to develop some experience with the environment. Anyone wishing to use Smalltalk to solve real problems must obtain further language references, as this book is only a brief introduction.

Buy "Smalltalk 80 The Language" instead........2002-05-29

This book stands out for all the wrong reasons. I've got quite a few books in my little CS library and this is the only book I've regreted buying. Squeak is a Smalltalk-80 system with extra libraries for multimedia and communications. For the same price as this book you can learn about Smalltalk from the "Smalltalk 80 The Language" book. This book is more detailed, has extensive example code for the presented techniques, has an entire example system, and it actually challenges the reader instead of insulting his intelligence. The Squeak book falls flat on these points. I think it was Alan Perlis who said that a language which didn't change the way you thought about programming wasn't worth knowing. Smalltalk is one of those languages worth knowing. The Squeak book doesn't get this message across. This book is not about enlightenment. You will never find yourself closing this book then sitting back inorder to give yourself a chance to try to inernalise some idea which you suspect you only half understood. The reason why is not because of fantastically clear writing but because you never get past the "point the mouse at this..... now click and type the name of the class" stage.

If you want to learn about Squeak and you realise understanding requires effort, then don't buy this book.

An excellent introduction to Squeak and smalltalk........2002-04-16

Even though I was familiar with both the smalltalk computer language and the Squeak smalltalk environment, I bought this book because I was intrigued by its structure, which is basically an extended dialogue between a naive user named "Jim" and virtual guides called the "Objective Wizard" and the "Objective Librarian". I was hoping to see a smalltalk equivalent to Friedman and Felleisen's magnificent book "The Little Schemer", which used a similar format to introduce the scheme programming language. Well, almost any book would be a disappointment after TLS, and this book certainly isn't in the same league (but it doesn't try to be). As an introduction to object-oriented programming concepts, to the smalltalk programming language, and to the Squeak implementation of smalltalk, this book is first-rate and well worth buying, especially for those who have never programmed in smalltalk before. It is quite elementary and should be graspable by almost anyone with a basic understanding of computer concepts (including people who have never programmed before). If you're coming to this book with no experience in smalltalk but with experience in another object-oriented programming language (e.g. C++ or java), be warned: smalltalk is probably the most extreme example of an OO language in that _everything_ is an object (even simple data types like integers and booleans, and even blocks of code). This imposes a conceptual barrier that the authors do an exceptionally good job of helping the reader through (or at least so it seemed to me, but then, I already knew all this material). The book is quite limited in its scope, and you'll need to read at least another book or two before you really understand smalltalk (Mark Guzdial's books are good next choices if you're using Squeak). Also, the book has a cutesy style which is occasionally irritating, especially when the "Jim" character tries to hit on the "Objective Librarian". This is supposed to humanize the book, but goes a bit far for my taste. However, this is only a tiny blemish on an otherwise excellent book.

Average customer rating:

Elegant
Not what I was looking for
Great book for beginners and no-longer-beginners alike
Like the title, this book is pure distilled information
One of The Very Best

Smalltalk, Objects, and Design
Chamond Liu
Manufacturer: iUniverse
ProductGroup: Book
Binding: Paperback

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Smalltalk Best Practice Patterns
Smalltalk With Style
The Design Patterns Smalltalk Companion (Software Patterns Series)
Smalltalk 80: The Language (Addison-Wesley Series in Computer Science)
Squeak: A Quick Trip to ObjectLand

ASIN: 1583484906

Book Description

This reference and text treats the Smalltalk programming system and the web of object-oriented ideas within and around it. Thus it is more than a guide to the language; it also examines Smalltalk in its technical and historical setting, and along the way addresses the questions that every Smalltalk developer sooner or later naturally wonders about. Assuming nothing more than general programming experience, it begins with what objects and classes are, and eventually progresses to subtle matters such as the distinction between types and classes. Going beyond typical programming language books, it also covers the most important design patterns and how to write them in Smalltalk. The thrust then is not merely programming in Smalltalk with objects, but thinking and designing effectively with objects.

This edition is a reprint of the original 1996 edition. Although the intervening years have brought the accustomed rapid changes in the computing industry, the principles presented here remain as relevant now as then.

"Three of my favorite topics are Smalltalk, objects, and design. Chamond Liu's book is the perfect blend of these topics. I heartily recommend this book to practitioners who don't want to read a dry treatment on design methodology or yet another programming book. You will be treated to elements of good design, a historical perspective, design patterns demystified and coded in Smalltalk, and just the right mix of Smalltalk programming and object concepts."—Rebecca Wirfs-Brock, author of Designing Object-Oriented Software

"Well-written and well-thought-out. . . . The chapter on design patterns especially is first-rate."—Doug Lea, author of Concurrent Programming in Java, and Object-Oriented System Development

"One of those rare books that rewards both beginners and experts with insights appropriate to their levels. In addition, the writing style—combining incisiveness and grace—makes it a real pleasure to read."—Dave Collins, author of Designing Object-Oriented User Interfaces

"Best book on Smalltalk I've seen!"—Sherman Alpert, author of The Design Patterns Smalltalk Companion

". . . approachable, literate, fun, accurate and different . . . the writing is of the highest calibre."—Ralph Johnson, author of Design Patterns: Elements of Reusable OO Software

"I am very impressed with it. . . . Unlike all of the other books, it covers all of the important issues relevant to effective understanding of the language under one cover."—Ed Klimas, author of Smalltalk with Style

"What I liked most about this book was the confidence with which Liu presents a wide range of topics: objects, architecture, gui, frameworks, design, patterns—all the right stuff. If a bright developer from some other branch of our discipline were to use his book as his only source of information, he would come off as savvy and well connected, even at a Smalltalk conference. And he would enjoy the experience too, since Liu never talks down to his readers."—Ward Cunningham, CRC Card inventor

"A very solid and entertaining book by an expert communicator . . .. Beginners and old hands alike will find useful ideas, entertaining writing and thought-provoking allusions to broader technical, literary and philosophical topics."—Martin Nally, chief architect of IBM Smalltalk and VisualAge

". . . the scope and level very interesting . . . a very useful collection of things which are spread around and hard to find . . ."—Tom Morgan, Manager of Technology Development, Brooklyn Union Gas

"A very well written book; a pleasure to read cover to cover. Good chapters on design patterns, metaclasses and garbage collection, etc. You can tell by the writing style that the author is also a teacher—conveys information gracefully and effectively. Highly recommended."—Paul Jasek, Chubb & Son, Inc.</p>

Customer Reviews:

Elegant.......2006-12-20

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-30

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

Great book for beginners and no-longer-beginners alike.......2005-01-17

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.

Like the title, this book is pure distilled information.......2004-08-29

"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.

One of The Very Best.......2004-04-26

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.

Squeak: Open Personal Computing and Multimedia

Average customer rating:

A vision emerging.

Squeak: Open Personal Computing and Multimedia
Mark J. Guzdial , and Kimberly M. Rose
Manufacturer: Prentice Hall
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Graphic Design | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Hardware | Computers & Internet | Subjects | Books

General | Computer Science | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Squeak: Object-Oriented Design with Multimedia Applications
Squeak: Learn Programming with Robots (Technology in Action)
Squeak: A Quick Trip to ObjectLand
Smalltalk 80: The Language (Addison-Wesley Series in Computer Science)
The Design Patterns Smalltalk Companion (Software Patterns Series)

ASIN: 0130280917

Customer Reviews:

A vision emerging........2003-01-15

This book was an ambitious attempt to describe both a vision of what personal computing could be and to provide a much needed technical overview of Squeak. Although largely successful, the buyer should be warned that some chapters in this book refer to online software that has yet to be written or is not currently available online. In particular, Alan Kay provides an unintended joke with his forward to the book. He states that Squeak is a "dynamic medium for creative thought" and that the foreward to the book should be an online active essay in Squeak. Unfortunately, the essay, "It Should Be Active, But Where (and When) Will It Be?" does not yet exist!

Amazon.com

Didier Besset's Object-Oriented Implementation of Numerical Methods offers a wide-ranging set of objects for common numerical algorithms. Written for the math-literate Java and Smalltalk programmer, this volume demonstrates that both languages can be used to tackle common numerical calculations with ease.

This title bridges the gap between pure algorithms and object design. By tackling issues like class design, interfaces, and overcoming floating-point rounding errors in both Java and Smalltalk, the code can be used as-is or as a model for your own custom numerical classes.

The range of recipes, or sample numerical classes, all coded in both OOPLs, is rich. For anyone who's taken a few undergraduate math courses (like calculus, linear algebra, or statistics), plenty of the material will be familiar. After presenting some basic algorithm and mathematical principles, the book shows you the code that gets the job done (first in Smalltalk and then in Java). There's no room for demo code that shows how to use all this. The emphasis is on a good cross-section of common numerical calculations. The tour begins with calculus and moves through linear algebra, with plenty of material on matrices. Later sections on statistics cover familiar terms and calculations such as linear regression and calculations useful for establishing correlations between one or more independent variables. Sections on data mining examine the mathematical rules for finding patterns in large amounts of data. (There's also a nifty set of classes for implementing genetic algorithms.) Throughout, you get advice on choosing the right algorithm for the job. (There are class diagrams that map out how this class library is organized.)

Of course, it will help to know some of the underlying math to get the most out of this intelligent and wide-ranging book, but the writing is remarkably clear and the source code is a model of intelligibility, so even readers who are averse to equations will find Object-Oriented Implementation of Numerical Methods readable. In general, any competent Java or Smalltalk programmer will be able to tap into solid mathematical code by reading it, without having to reinvent the proverbial wheel. --Richard Dragan

<B>Topics covered:</B> <ul>

Introduction to numerical methods and objects in Java and Smalltalk

Numerical precision and rounding errors

Comparing floating-point numbers

Functions in Smalltalk and Java

Evaluating polynomials

The error, gamma, and beta functions

Interpolation algorithms (Lagrange, Newton, Neville, Burlirsch-Stoer, and cubic spline interpolations)

Choosing the right interpolation method

Iterative algorithms

Finding the zeroes of functions (the bisection method, Newton's method, roots of polynomials)

Integration of functions (trapeze integration method and Simpson and Romberg integration algorithms)

Open integrals

Choosing the right integration method

Infinite series

Continued fractions

Incomplete gamma and beta functions

Algorithms for linear algebra

Vectors and matrices

Linear equations (backward substitution, Gaussian elimination, LUP decomposition)

Matrix determinants and inversion

Eigenvalues and eigenvectors of nonsymmetrical and symmetrical matrices

Statistical moments

Histograms

Probability distributions (normal, gamma, and experimental distributions)

The F-test

The t-test

The chi-squared test

Least-fit square algorithms

Optimization algorithms

Extended Newton algorithms

Hill-climbing algorithms

Powell's algorithm

Simplex algorithm

The genetic algorithm

Data mining

Covariance

Multidimensional probability distribution

The Mahalanobis Distance

Cluster analysis and variance</ul>

Book Description

Numerical methods naturally lend themselves to an object-oriented approach. Mathematics builds high- level ideas on top of previously described, simpler ones. Once a property is demonstrated for a given concept, it can be applied to any new concept sharing the same premise as the original one, similar to the ideas of reuse and inheritance in object-oriented (OO) methodology.

Few books on numerical methods teach developers much about designing and building good code. Good computing routines are problem-specific. Insight and understanding are what is needed, rather than just recipes and black box routines. Developers need the ability to construct new programs for different applications.

Object-Oriented Implementation of Numerical Methods reveals a complete OO design methodology in a clear and systematic way. Each method is presented in a consistent format, beginning with a short explanation and following with a description of the general OO architecture for the algorithm. Next, the code implementations are discussed and presented along with real-world examples that the author, an experienced software engineer, has used in a variety of commercial applications.

On the enclosed CD-ROM, you'll find files containing tested source code implementations of all the algorithms discussed in the book in both Java and Smalltalk. This includes repository files for VisualAge for Java and VisualAge for Smalltalk under ENVY.

* Reveals the design methodology behind the code, including design patterns where appropriate, rather than just presenting canned solutions.
* Implements all methods side by side in both Java and Smalltalk. This contrast can significantly enhance your understanding of the nature of OO programming languages.
* Provides a step-by-step pathway to new object-oriented techniques for programmers familiar with using procedural languages such as C or Fortran for numerical methods.
* Includes a chapter on data mining, a key application of numerical methods.

Customer Reviews:

Disappointing Introduction to the Implementation of Numerical Methods.......2005-09-01

As a mathematically oriented programmer I found no interesting ideas in this book. The content and treatment of the material is a bit too simplistic and, when viewed as an introduction, it looks unattractive.

Also, as a Smalltalk programmer, I was disappointed with the way algorithms are implemented. The author makes no attempt to take advantage of the wonderful expressiveness of the Smalltalk language. Classes and methods have been given awkward names; the source code is not elegant; basic objects such as matrices and polynomials are insufficiently modeled and treated as mere data structures; algorithms are not viewed as objects but as conventional procedures. Because of the flatness of the approach the resulting programming style is ugly when compared to Smalltalk standards. The eloquence and richness of pure object orientation is not achieved or suggested. SUnit tests, which would have fitted perfectly in all chapters, have been ignored everywhere.

Excellent book.......2001-01-10

The author is clearly very familiar with the theory and practice of numerical computations in OO languages. For me, the main contributions of the book are an expert formulation of some of the basic numerical techniques and concepts in OO terms (a subject rarely approached in the numerous existing books on OO technology), and examples that can be followed to implement other NM techniques and concepts.

The inclusion of very readable Smalltalk and Java source code is very useful.

For use in a course, I would like to see the material complemented by exercises.

Reconciling Numerical Methods and Object-Orientation.......2000-12-24

I really enjoyed this book because it shows that a high level language such as Smalltalk can efficiently model a complex domain like numerical methods. Besset presents a conceptual framework where the concepts are extended and reused, showing the power of OO programming. I also liked the structure of examples followed by a formal foundation, implementation, and implementation discussion.

Reconciling Numerical Methods and Object-Orientation.......2000-12-24

Oh man, is this book neat!.......2000-12-08

Dr. Besset has written an uncommonly great book where he has given us important tools while teaching object-oriented analysis and design. Having both Smalltalk and Java code included is a gift. As a smalltalker, I greatly appreciate the inclusion of the Smalltalk code. The book is well organized, very readable and provides the basis for individuals to extend the classes provides as well as build applications with the included code. The code also provides solid examples of object-oriented programming style that will aid the newer programmers in developing effective use of both Java and Smalltalk.

Average customer rating:

history of smalltalk systems
All the complexities of Smalltalk amazingly simplified!

Art and Science of Smalltalk, The
Simon Lewis
Manufacturer: Prentice Hall
ProductGroup: Book
Binding: Textbook Binding

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Smalltalk With Style
Smalltalk: An Introduction to Application Development Using VisualWorks
Squeak: Object-Oriented Design with Multimedia Applications
Smalltalk Best Practice Patterns
The Smalltalk Developer's Guide to VisualWorks With diskette (SIGS: Advances in Object Technology)

ASIN: 0133713458

Customer Reviews:

history of smalltalk systems.......1999-08-03

history of smalltalk system

All the complexities of Smalltalk amazingly simplified!.......1997-01-16

Simon Lewis's book "The Art and Science of Smalltalk" has to be one of the best books on Smalltalk programming I have ever read. After spending months reading many other books on the subject and still not getting a clear, concise description of some important Smalltalk constructs, I could not believe how incredibly readable this book was. Lewis has managed to explain in a few pages what took other authors multiple chapters.

In addition, diagrams and figures are only used when they will actually help the reader to understand a concept. Unlike other texts references to figures and diagrams occur in close proximity to them rather than twenty pages before or after.

The book is divided into two parts which address different but equally important aspects of programming in Smalltalk. The first section deals with the "science" of Smalltak and covers the development environment, class library, and dependency mechanisms (Model-View-Controller Architecture). The second section gives sage advice on the "art" of Smalltalk. This includes sections on how to best utilize Smalltalk in an environment of extensive reuse, management of Smalltalk projects, and debugging techniques.

Customer Reviews:

Nice Explanations of Difficult concepts.......2004-03-25

I find computer programmers are obscure writers. They don't seem able to express what they mean well. But this is not so for Mr Sharp. I've read online articles on OOP and other books on topics such as encapsulation, polymorphism, and messages and methods, and somehow the ideas just didn't gel. But with Mr Sharp's lovely concrete examples, I finally saw the light. Even if you want to programme in another OOP language I would recommend reading the early parts of this book to understand these concepts clearly.

Excellent.......1999-05-22

This is the one Smalltalk book that I carry with my laptop. If there's a Smalltalk feature that I haven't dealt with in some time then I'll take a peek at it here before I do anything else. It's great for Smalltalkers who are just about to ascend the steep portion of the language's learning curve - this book will drag you right up to the top!

Relatively very good........1999-04-20

This book very readable and informative if you are working with the VisualWorks SmallTalk interpreter. Most books on Smalltalk are quite useless. Maybe because there are various SmallTalk interpreters with their own basic class structures. I'm still looking for a book like this but twice the size, so that it includes comprehensive GUI analysis, garbage collection, IO handling, etc. However, for what this book sets out to do, it does it very well.

One of the best books on Smalltalk.......1998-03-13

This book is fun to read and to learn from. It teaches so many advanced Smalltalk programming techniques. Those that make the difference between an expert and a beginner. It is a quantum jump for the reader. Wisdom and pleasure in doing it better awaits you here. Unique, motivating appreciation for the beauty of this language.

The Design Patterns Smalltalk Companion (Software Patterns Series)

Average customer rating:

The essential GOF companion
Useful for Java Programmers too.
Easier to understand than the original GoF
More than a GOF Companion.
More than a GOF Companion.

The Design Patterns Smalltalk Companion (Software Patterns Series)
Sherman R. Alpert , Kyle Brown , and Bobby Woolf
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Qualifying Textbooks - Spring 2007 | Stores | Books

General | Software Books | Custom Stores | Stores | Software
Similar Items:

Smalltalk Best Practice Patterns
Smalltalk, Objects, and Design
Smalltalk With Style
Kent Beck's Guide to Better Smalltalk: A Sorted Collection (SIGS Reference Library)
On to Smalltalk

ASIN: 0201184621

Book Description

When the classic book Design Patterns was first published in 1994, the landscape of object-oriented software engineering was forever changed. The 23 patterns contained in the seminal work vastly improved the discipline of object-oriented software design. That book, and the concepts it presented, allowed software professionals to solve specific design problems by reusing successful designs. Design Patterns was a gift to the world of software development, yet Smalltalk programmers could not take full advantage of the book's popular ideas because most of the original patterns were presented from a C++ perspective. In The Design Patterns Smalltalk Companion, the classic work has been tailored and enhanced to address the specific needs of the Smalltalk programmer. The catalog of simple and succinct solutions has been written in Smalltalk code, and the material is discussed from the perspective of the Smalltalk programmer. The full source code that supports the 23 patterns is also available via the Addison-Wesley Web site. Assembled and written in close conjunction with the authors of Design Patterns, this is the definitive patterns reference for those programming in Smalltalk. This book provides efficient solutions to your Smalltalk design problems, ultimately helping you become a better software designer.

Customer Reviews:

The essential GOF companion.......2004-04-19

This isn't a Smalltalk translation of "Design Patterns." Instead, it's a companion to that book. You'll need to read the first one to get the most out of this one. If you have read the first one, you'll find this one is better written and really casts essential light on some of the GOF material. The Smalltalk aspects of this book are really a non-issue (except perhaps showing static-typers how many hoops you don't have to use in Smalltalk). This is required patterns reading.

Useful for Java Programmers too........2001-08-05

I bought this book because of the unresolved questions I had after spending so many hours exploring the GoF original book. I am an experience C, C++, and Objective C programmer, not a Smalltalk guru at all. And I found the GoF very confusing and intimidating. My current projects these days are written in Java (I miss Objective C). I looked for a book that would cover the pattern catalog in Java because I was really questioning the purpose of some of them in that language. Creating some mechanism to overcome the C++ language is somewhat understandable, but why bother with Java. Take the prototype pattern for example: "...It's (the prototype pattern) less important (to use it) in languages like Smalltalk or Objective C that provides what amounts to a prototype..." (page 121) Sure, ok, but what about Java? Can you give me an example on how it would benefit a language that doesn't really require it like Obj C, or even Smalltalk? Then the sample code refers to the maze example but not much material is given here. I bought several books with Java and Design Patterns in the title but was very disappointed with the beginner level these books approach this problem. The titles are seductive but the content is not that great. I don't need another ADOO (I've read Larman's book already. Get it if you are new to OO BTW.) So I ended up getting that book as a last resort. And you know what? It's great. I program in Java all day (and sometimes all night, sigh...) and this book spends more time on my desk than the GoF original one. So, if this comments remind you some of your experience, you should give this book a try. And this book lighted up another bulb in my brain: I ended up downloading Squeak and prototyping in Smalltalk some of my projects just for the fun of it, but that's a side effect I guess ;-)

Easier to understand than the original GoF.......2000-02-04

This book gives you a better understanding of the patterns than in its original version (the GoF one). I am not a SmallTalk programmer but a 9 years C++ one. At work I had to use the GoF book and never liked reading it. In contrast to this, the SmallTalk companion is easy to read and you can understand the patterns within the first few lines of their description. Take the Bridge pattern and compare their discussions in the two books. If you really like the Gof one then buy it. But according to me, it would be a big mistake buying the GoF in favour of the SmallTalk companion. Trust a C++ programmer :-)

More than a GOF Companion........1999-09-09

I found this an exellent book. The original design patterns book drew its examples from C++ applications. I could see a use for the patterns in C++, but I thought most of them would not have been necessary if the code had been written in Smalltalk.

This book did an excellent job of showing how and where the patterns could be used in Smalltalk applications. The authors also extended and clarified many of the pattern so that they were simplier to understand. The book is more than a companion to the GOF book; it is an enhancement of it.

More than a GOF Companion........1999-09-09

Programming Book:

Programming Book

Programming Book