Product Description
* Objects First Approach. Students learn to design with objects from the start. In more traditional approaches, students first learn "programming basics in the context of procedural programming in the small." Since this frame of reference is essentially useless when attacking large-scale problems, students must later "re-learn how to approach problems. Instructors can present material from a point of view that will "make sense" throughout the curriculum. Presentation and justification of programming principles and good techniques is easier.
* Emphasis on the distinction between class specification and implementation. Students learn to develop coherent class specifications early on, and to build components that conform to carefully defined, consistent specifications. The result is more main-tainable, error-free code.
* Early emphasis on testing and test-driven implementation. Students develop a habit of testing as part of the implementation process. Testing is essential to ensure quality programs.
* Current presentation of object-oriented design and Java. Students benefit from seeing general approaches to commonly occurring design patterns in a specific, well-defined context. This will also make it easier for students to "get the point" when such topics are introduced in upper-level design and software engineering courses. Other features include an emphasis on event-driven interfaces, rather than traditional procedural I/O; informal use of standard UML notation
* Optional interactive exercises are designed for use with the open-source DrJava integrated development environment (IDE) - a popular tool for compiling and testing programs ... Read more

Customer Reviews (10)

Good job!
The book is really heavy and big,and it arrive before due date.The book is perfact except some little problem,for example,the CD with the book can not work.

Could this book be better? I don't think so!!
Could this book be better? I don't think so (I didn't think I would say this about a book).

This book is the "living" proof that you can teach Object Oriented Programming (OOP), or more precisly Object Oriented Design (OOD), simply, clearly, and, more importantly, truthfully.

1) Simply: the authors use simple (but not too simple) and complete (but not too complex) examples. These examples illustrate perfectly all the aspects of the point being explained. You can tell the authors gave a lot of thought to design this examples, and it must have took lots of work to craft the material accompanying the book.
2) Clearly: the explanations are detailled enough to be (crystal) clear without being too wordy.
3) Truthfully: that is, the authors teach Object Oriented Programming for what it is, a Software Design Methodology (what they really do is teach the reader Object Oriented Design-- OOD). And they are not afraid to call a spade a spade, that is, they don't try to sugarcoat OOP, and yet the book don't loose an inch of clarity. When they introduce their own classification or vocabulary (for example, classifying methods as either queries or commands) they explicitly state it, and it's only to make the matter simpler and clearer.

One more thing: the DrJava exercises are a gift for those of us who study on their own.

In conclusion, the authors strike the perfect balance between simplicity, clarity and truthfulness.

(About me: before reading this book I knew a little about programming and a little about OOP, that is I was not a total beginner)

NOT for beginners!
If you already know quite a little about Java (I mean, you have finished reading at least one whole book about Java basics), maybe this is a good book to explore the OO aspects of Java. But this book is definitely NOT for the beginners. It is crazy to use it as a textbook in an intro CS class. If you happen to be a self-study guy, it would be a nightmare.

Java, UML and algorithms all in one
This is an ideal book for those that want to learn Java with a college textbook. Starting with the basics each chapter is well written and illustrated and has a series of questions at the end to help you test your knowledge of what you have just learned. UML is used throughout as the illustration language. Later chapters deal with algorithms (e.g. storage, sorting, searching, etc.)

All of the features of the Java language are covered. Swing is used to teach the basics of UI. There is nothing on web application work. Collections are taught using the new generics features of Tiger.

A good book for those looking to learn how to program, and who want to start with the Java language and object-oriented design.

A Great Introductory Book for Beginning Programmers
This book, in my opinion, is probably one of the few better introduction books that should be widely used in many intro computer courses.I have programmed for many years, and I have learned that I have made the same mistake in the past that I know many others have done, when they first started programming.The problem I am talking about is when some people program, they just go up to the keyboard and screen and just type, which I have learned from this book that it is very wrong to do.I have learned from this book that when one programs, he/she has to have some kind of design implementation (UML) set and ready before going to turn the designs to code.As an introductory book, this will teach beginner programmers the correct way to program, without the sloppy coding techniques.
The first two chapters are a good explanation to how computers process code and the meaning of object-orientation.The next couple of chapters gives a brief overview of what Java is and how Java ties in with object-oriented design.If one already has Java experience, I think he/she can just skip these chapters, because it may get repetitive to the eyes.For beginner Java-ers, the book gives excellent pure examples in Java, without any confusing documentation or coding.
Then comes Chapter 10 and on...These chapters covered are for Java programmers who have already passed the Beginner's stage, but feel they need to 'dip their feet' in Java water a little more before declaring themselves as proficient Java-ers.These chapters cover excellent computer terminology and basic computer aspects (lists, sorts, searches, abstractions) and classic algorithmic ideas.The last couple of chapters deal with introduction to Exceptions (Java) and GUI Applets, after dealing with TUI most of the book.
So in closing, a good book for introduction, but if you do have experience in Java, then you still would find the book useful, with a handful of excellent defined computer programming terminology and examples.Also, I took the class with one of the authors (Dr. Jaime Nino) and he is truly an exceptional professor at heart who loves his programming. ... Read more

Product Description
Harness the power of Python 3 objects

• Learn how to do Object Oriented Programming in Python using this step-by-step tutorial
• Design public interfaces using abstraction, encapsulation, and information hiding
• Turn your designs into working software by studying the Python syntax
• Raise, handle, define, and manipulate exceptions using special error objects
• Implement Object Oriented Programming in Python using practical examples

In Detail

Object Oriented Programming is a very important aspect of modern programming languages. The basic principles of Object Oriented Programming are relatively easy to learn. Putting them together into working designs can be challenging.

This book makes programming more of a pleasure than a chore using powerful Python 3 object-oriented features of Python 3. It clearly demonstrates the core OOP principles and how to correctly implement OOP in Python.

Object Oriented Programming ranks high in importance among the many models Python supports. Yet, many programmers never bother learning the powerful features that make this language object oriented.

The book teaches when and how OOP should be correctly applied. It emphasizes not only the simple syntax of OOP in Python, but also how to combine these objects into well-designed software.

This book will introduce you to the terminology of the object-oriented paradigm, focusing on object-oriented design with step-by-step examples. It will take you from simple inheritance, one of the most useful tools in the object-oriented programmer's toolbox, all the way through to cooperative inheritance, one of the most complicated. You will be able to raise, handle, define, and manipulate exceptions.

You will be able to integrate the object-oriented and the not-so-object-oriented aspects of Python. You will also be able to create maintainable applications by studying higher level design patterns. You'll learn the complexities of string and file manipulation, and how Python distinguishes between binary and textual data. Not one, but two very powerful automated testing systems will be introduced to you. You'll understand the joy of unit testing and just how easy they are to create. You'll even study higher level libraries such as database connectors and GUI toolkits and how they apply object-oriented principles.

Harness the power of Python 3 objects; it's not just a scripting language

What you will learn from this book

• Implement objects in Python by creating classes and defining methods
• Separate different objects into a taxonomy of classes, and describe the properties and behaviors of those objects via the class interface
• Design public interfaces using abstraction, encapsulation, and information hiding
• Turn your designs into working software by learning the Python syntax
• Share implementation using inheritance
• Add functionality to the existing classes and built-ins using inheritance
• Share similar code between classes by abstracting it into a parent class
• Raise, handle, define, and manipulate exceptions using special error objects
• Understand when to use object-oriented features, and more importantly when not to
• Learn what design patterns are, and why they are different in Python
• Uncover the simplicity of unit testing and why it's so important in Python
• Utilize common Python 3 modules, libraries, and frameworks

Approach

The book begins with the very foundations of OOP and then uses practical examples to show how to correctly implement Object Oriented Programming in Python. Many examples are taken from real-world projects. The book focuses on high-level design as well as the gritty details of the Python syntax. The provided exercises inspire the reader to think about his or her own code, rather than providing solved problems.

Who this book is written for

If you're new to Object Oriented Programming techniques, or if you have basic Python skills and wish to learn in depth how and when to correctly apply Object Oriented Programming in Python, this is the book for you.

If you are an object-oriented programmer for other languages, you too will find this book a useful introduction to Python, as it uses terminology you are already familiar with.

Python 2 programmers seeking a leg up in the new world of Python 3 will also find the book beneficial, and you need not necessarily know Python 2. ... Read more

Customer Reviews (3)

Best Python 3 Book I've Read
Disclaimer: I helped edit this book.

Packt tends to make low-quality Python books, so when they approached me to be an unpaid technical editor for this one, I thought it would be worthwhile to help them put out something that was good. I also thought it was time for me to start getting familiar with the new Python version. Fortunately, the author of the book has put together a really good tome. He covers when you'd want to use OOP, various programming patterns, the basics of Python 3 syntax, and gives the reader a taste of a set of 3rd party Python 3 packages. You can read my full review here: [...].

Excellent introduction to OOP in Python 3
Disclaimer: I received a review copy of this book from the publisher, Packt Publishing.

Prior to reading this book I was already familiar with basic OOP concepts and Python 2 in particular. I expected the book to enforce my thinking and help me to understand new features provided by Python 3 as compared to version 2. I think the book managed to do this in an excellent manner.

I think the approach used by the book is well suited for a wide range of readers. It explains enough theory and provides useful examples that help to understand how to apply OOP in practice. People new to Python and/or OOP have a lot to gain from the book. More experienced users of the language may find the book ideal as reference material.

It's important to note that the book focuses on OOP particularly in the context of Python. Don't expect any history lessons or theory on various OOP approaches (prototypes vs. classes, ie.) beyond the one (class based approach) used in Python. Despite this the book provides excellent value. I do recommend checking out several other languages (Java, Lua, JavaScript, Smalltalk) and paradigms (AOP, traits) for further inspiration.

Great OOP for Python developers
I can't claim to have looked hard for a Python book on object oriented programming (OOP) but I was immediately attracted to the title of this book. Sure, you can find small tutorials here and there about some specific facet of OOP but I don't recall ever reading something that covers designing public interfaces using abstraction, encapsulation, etc, etc with good and practical examples! If you have, please drop me a link in the comments.
Python 3 Object Oriented Programming by Dusty Phillips does a very decent job of not only introducing the reader to the terminology and the object oriented paradigm (something that is not too complicated to understand) but also offers a comprehensive step-by-step guide that will take you from theory to a real world project. I've always felt that anyone can pick up a book about programming and learn its syntax by heart. But putting it all together and designing something that will actually work is something that you usually learn by reading other people's code or, if you're lucky enough, from a mentor.
Overall I felt that the book was well written with a great selection of sample code. Whether you already know how to do object oriented programming for other languages or are new to the whole concept and want to learn everything about it, I definitely recommend this book! ... Read more

Product Description
Not only explains the essence of the object oriented paradigm, but also places it in the context of real-world application development, so you can reap the concrete benefits of programming with objects. Softcover. ... Read more

Customer Reviews (6)

An excellent book to grasp the essence of OO, JAVA and UML
I have gone through your book entitled "The essence of
object-oriented programming with java and UML" and I
must say that you wrote a very fine book.

To explain my point and let you know what is good
about it from my own perspective, I find it not quite
advanced in its treatment of the JAVA language but at
the same time it gives you a sense of knowing right
from the beginning the very essence of the language.
In addition,introducing in parallel the UML
methodology helps a lot to understand the software
"production" requirements.

I have gone through several books for the last 5
months. Each pretending to explain once and for all
JAVA or UML. But your book is the only one I found so
complete in its treatment of both OO, JAVA and UML
(even though it is only 290 pages long !).

Again, thanks for such a fine book and my best wishes
for all your future endeavors.

The emphasis is on object-oriented principles, not Java
The world of programming is changing, and in my opinion, the change is welcome. The Unified Modeling Language or UML used to be reserved for advanced programmers in large projects. However, the basics of the UML are easy to understand and provides an excellent way to represent classes and their interactions. Therefore, more authors of introductory programming texts are using the UML in their books. This is a welcome addition, and I am now puzzled when I see a book where it is not used. I do not understand why anyone would use the standard bubble tree diagram to describe inheritance when a UML diagram could be used.
The next question to settle then becomes how well the UML is used and integrated into the presentation of the principles of object-oriented programming. My response to that question is also an affirmative. Wampler uses the combination of UML and Java to explain the fundamentals of object-oriented programming in a way that anyone with programming experience can follow. He also does not commit the error of using too much code in the book. Code is used only when necessary and only enough to make the crucial point. If there is a flaw, it is that there is not enough code in the book. There are times when I thought that an extra example would have been beneficial. However, that is a debatable point and not a serious flaw.
If I were teaching an introductory course in object-oriented programming, this is the text I would use. The emphasis in such courses should be on the principles of object-oriented programming and not the features of a language. In my experience, students quickly learn the syntax of a language, but the organizational strategies used to make programs comes much more slowly. Wampler takes the right approach and I recommend this book to anyone who wants to learn object-oriented programming.

The emphasis is on object-oriented principles, not Java
The world of programming is changing, and in my opinion, the change is welcome. The Unified Modeling Language or UML used to be reserved for advanced programmers in large projects. However, the basics of the UML are easy to understand and provides an excellent way to represent classes and their interactions. Therefore, more authors of introductory programming texts are using the UML in their books. This is a welcome addition, and I am now puzzled when I see a book where it is not used. I do not understand why anyone would use the standard bubble tree diagram to describe inheritance when a UML diagram could be used.
The next question to settle then becomes how well the UML is used and integrated into the presentation of the principles of object-oriented programming. My response to that question is also an affirmative. Wampler uses the combination of UML and Java to explain the fundamentals of object-oriented programming in a way that anyone with programming experience can follow. He also does not commit the error of using too much code in the book. Code is used only when necessary and only enough to make the crucial point. If there is a flaw, it is that there is not enough code in the book. There are times when I thought that an extra example would have been beneficial. However, that is a debatable point and not a serious flaw.
If I were teaching an introductory course in object-oriented programming, this is the text I would use. The emphasis in such courses should be on the principles of object-oriented programming and not the features of a language. In my experience, students quickly learn the syntax of a language, but the organizational strategies used to make programs comes much more slowly. Wampler takes the right approach and I recommend this book to anyone who wants to learn object-oriented programming.

Useful for Flash MX Developers
Learn the basics of MVC and UML in a movie catalog application. Clear representation of fundamentals of OOP.

Good Introduction
I really enjoyed this book. It was a fairly swift read and a good introduction to object-oriented programming and methodologies. It could have been better, imo. I recommend it, in spite of the criticisms below :).

I wish the author had spent more time explaining how the example programs integrate with the MVC framework which he provided. Unfortunately he doesn't even provide that information with UML diagrams, much less discuss it in the text. It would also have been nice to have some discussion of how to extend the framework.

In chapter 6, it was a bit confusing when he used the class MovieModel to model not a movie but rather an application to catalog movies.

The included CD-ROM was missing the source code file for Listing 5.10, so I had to type in in by hand. Unfortunately the listing in the book has a couple of mistakes. The author's web site does not have the code available.Here's the corrected code:

I apologise for the lack of formatting. Space constraints.

/*
* WmvcChkMenuItemCtl - implements JCheckBoxMenuItem controller
* (c) 2001, Bruce E. Wampler
*/
import java.awt.*;import java.awt.event.*;
import javax.swing.*;import javax.swing.event.*;
public class WmvcChkMenuItemCtl extends WmvcController {
private JMenu myMenu; private JCheckBoxMenuItem checkBoxItem;
// Constructor for JMenu item: JCheckBoxMenuItem
//public WmvcController( JMenu menu,
public WmvcChkMenuItemCtl(JMenu menu,String text,String icon,
char mnemonic,String accel,boolean checked,WmvcExecutor wExec )
{super((JComponent)new JCheckBoxMenuItem(), null, wExec); myMenu = menu;
//checkBoxMenuItem = (JCheckBoxMenuItem)myComponent;
checkBoxItem = (JCheckBoxMenuItem)myComponent;
if (text != null)checkBoxItem.setText(text);
if (mnemonic != ' ' && mnemonic != 0)checkBoxItem.setMnemonic(mnemonic);
if (accel != null){KeyStroke ks = KeyStroke.getKeyStroke(accel);
checkBoxItem.setAccelerator(ks);}
if (icon != null){Icon theIcon = new ImageIcon(icon);
checkBoxItem.setIcon(theIcon);}
checkBoxItem.setState(checked); checkBoxItem.addActionListener(this);
checkBoxItem.addItemListener(this); myMenu.add(checkBoxItem);}
public boolean getState(){return checkBoxItem.getState();}
public void setState(boolean checked){checkBoxItem.setState(checked);}
public void setEnabled(boolean enable){checkBoxItem.setEnabled(enable);}
public JMenu getJMenu(){return myMenu;}
public JCheckBoxMenuItem getJCheckBoxMenuItem(){return checkBoxItem;}} ... Read more

Product Description
This book has a strong focus on object-oriented design and gives readers a realistic experience of writing programs that are systems of cooperating objects. Programming fundamentals are learned through visually appealing graphics applications in all examples and exercises. Introduction of object-oriented concepts from the beginning including objects, classes, polymorphism, inheritance, and interfaces. It fully embraces Java 5.0 topics including the standard scanner class and makes extensive use of graphical user-interfaces and real graphics applications. This book is appropriate for beginning programmers who want to learn to program with Java as well as experienced programmers who want to add Java to their skill-set. ... Read more

Product Description

Object-Oriented Programming with ActionScript takes you beyond the level of "neat" code tricks and teaches you how to architect and implement true Macromedia Flash MX applications. You will also learn the programming theory needed to take full advantage of the object-oriented nature of ActionScript.

Customer Reviews (36)

Outdated
This book is well written, and explains some concepts of ActionScript and OOP that will stand the test of time, but for the most part it is outdated.I should have taken a closer look at the review dates before making this purchase.

I browsed through this book for a couple of days wondering why the heck I hadn't read any of this material in my other sources, before finally making a trip to my local bookstore to do a little research.And lo and behold I found my suspicions to be correct.Do not buy this book if you are using Flash 8.

Fantastic book for OOP concepts in ActionScript.
I've worked with Flash for many years. I've also been programming in Pascal, C, C++ for many years.This book helped me for the first time tie the OOP concept to Flash movie clips, frames, sound objects, and timelines.

I didn't need a book with pages of code examples.I just needed to have a good explaination and short examples of how the components work or how to manipulate the XML object.

In a way, this book serves as a refresh course for people who are familiar with tools such as Visual Basic and have always thought Flash is just for animations.

This book is for Flash 6, the concept is still the same with Flash 7 and ActionScript 2.0

Where's The Beef? (or, more correctly, "Where's The OOP?")
Why does a book entitled "Object-Oriented Programming with ActionScript" only include 3 chapters (plus one "real-world" example chapter) on OOP? With 16 chapters and 400 pages, this is all the OOP we get?

I guess the New Riders marketing folks decided the Flash book market needed a book with OOP in its title (whether they had enough OOP material to fill a book or not).

To make matters worse, the OOP chapters in this book assume you are already intimately familier with OOP and just need an overview of how it works (or doesn't work) in AS. This is certainly not a book for Actionscripters who want to learn OOP!

The authors are clearly experts in their field but alas, an expert does not always a writer make! I often found Mr. Hall's writing to be obtuse and overly verbose. Some of his "explanations" had me more confused than when I started!

Now with that all said you may think I hated the book but actually I found quite a few useful nuggets...

- chapter 1 has some very good advice on optimizing your setup of the Flash environment
- chapters 6-10 provide useful information on components -- both their useage and creation
- chapter 11 provides some nice debugging tips
- the remaining chapters provide a variety of useful techniques for the AS programmer

Bottom line, I bought a used copy of the book and felt it was worth the price; had I paid a higher price I would not have been happy with it.

The book for OO Actionscript
By far the best book/resource/must have on OO in ActionScript.This books is still based on the 1.0 standard, I am hoping they will write a 2.0 version as well.I bought it based on the reviews and have to say it was hands down the best book on software I have bought in years.This is a must have.

Now for programmers!
I have always felt that Flash was a designer-only tool, inaccessible to the likes of programmers.This book tries to change all that by making Flash development accessible to programmers.I believe the book is also designed for designers who want to understand OOP in ActionScript.

After a brief introduction to OOP (which is all done through UML) and ActionScript syntax, the reader is presented with constructing an application from start to finish.I was particularly pleased that this example uses the famous MVC (Model-View-Controller) pattern, familiar to many OOP programmers.After completing this chapter, the reader will have a good understanding of the basics of OOP in ActionScript.

The next section of the book discusses many of the tiny details in the previous chapter in much more depth.There is discussion on using pre-built Flash components in your application as well as building your own components.Each of these topics are covered in sufficient depth to satisfy the reader.

The final section of the book seems to be "everything else you need to know about Flash and ActionScript".This section includes a discussion on debugging your application, useful tips and tricks, and even an introduction to Flash remoting. ... Read more

Product Description
The author describes his book as a "unique blend of market and technology coverage, broad and fair coverage of current technologies and a deep discussion of real problems with their solutions where known".The first edition won the "Jolt Award" became the leading book on the market to combine explanations of what the key technologies are, how to use them and why they are important in the software market-place, and look at these in terms of both the technical and business issues. The book was also the first to define components and clarify the key questions surrounding them, show how they are key to software design and offer a historical overview of their development. ... Read more

Customer Reviews (14)

What we really wanted was software components -- read about it here
I searched for a book that would fill in the details about what I already felt, and was learning from a colleague: that to create software components you don't need classes. My efforts were rewarded when I saw the titles of chapters 1 and 7:

1.1 Components are for composition
7. Object versus class composition, or how to avoid inheritance

and further,

7.1 Inheritance -- the soup of the day?

Component Software: Beyond Object-Oriented Programming goes back to first principles and requirements -- what we really want from software development, how such design methods would look, and then, in the later chapters that I only skimmed, how it might be done in current languages and frameworks. Bonus of understanding: why what's popularly known as "Object-Oriented" programming is really only "Inheritance-Based" programming. For software architects, and for developers who are early adopters, risk-takers, or inventors of better ways to code, well worth checking out this book.

--
Full disclosure: I only had time to read the first third of the book before I had to move on to other topics.

Absolutely must read for any serious Software Engineer
Very well written and informative. I 've read a few book that tend to be either very verbose or written for novices. This one hits the spot.
The best part is that reading this book makes you think.

Best conceptual foundation around
Szyperski has written a truly outstanding introduction to component software systems. This is the most complete, clearest introduction to the basic problems and practice of component software development that I've seen.

After the introductory chapter, about the first third of the book discusses object oriented development. That's no contradiction: OO technology is usually the implementation vehicle for component systems. Szyperski adds (or at least collects) real content about OO technique, including the problematic relationship between 'contracts' and callbacks, language features for containment and control, and the many needs that current OO languages don't meet. Lots of the discussion sounds like 'the loyal opposition' - he supports OO practice, even demands it, but is harshly critical of the OO techniques that cause real problems.

The remainder of the book describes requirements of a workable component system and a workable component industry. If done right, component software really could solve a lot of problems: squabbling in multi-vendor environments, maintenance across multiple generations of releases, and more. The theoretical discussion is backed up with case studies, including JavaBeans, CORBA, and OpenDoc.

The would-be component user won't find a lot here; this book is really for the component or component framework developer. Developers, however, should not expect a lot of direct, technical detail. This discusses principles, not implementation. That's my one real disappointment in this book: the lack of detail. Even the case studies are brief and somewhat shallow. Those problems are easy to fix, however, with other books on specific APIs, systems, and development techniques.

If you are planning a component-based system, whether as a component user or a component developer, this book may be essential. It gives a complete, critical view of what components can do and what they should but cannot yet do. As you go through development, you'll come back to this book (or at least to its issues) again and again.

A 'must read'.
Clemens Szyperski's ability to describe and explain complex systems is almost unparalleled in software literature. If you need to understand software componentry, you must read this book.

Highly recommended SW Components book
When I started SW Engineering the SW functional decomposition methods were in fashion. People became relatively quickly familiar with them, and we developed our SW on Intel's 8086 based chip sets, with a few Ks of memory. The programming practices were reinforced by our peers and the Management.

Then came the buzz-word SW Object Orientation. I first heard it in the mid 80s. To be frank about it, it had taken me about three years to get to the bottom of it. In my experience about 95% of the people who talked about it were either clueless or those who only wanted to jump on the fast track wagon.

In my view, the OO in its pure form is a little bit complex concept. Lets face it, when you start with a mean set of customer requirements and you have your boss breathing down your neck in some cases for no good reason, you are not going to be in the best frame of mind to look for SW objects in a bubble pool of analysis. OOD requires all kind of disciplines. Even the best OO design may not be supported by your target language and it may not be the best approach to your problem, what I'm mean that is like trying to dig your garden with a eating fork which may look like a garden fork !

Here comes the SW component part. Why not group the requirements into a set of likely entities ? Once the requirements are grouped in such fashion the SW Analysis elements are easily mapped onto what is called 'SW Components' which are well described in this book. The author is very descriptive about the idea and he is able to convey it in a simple manner. This book is not only about SW components it also covers other serious technologies such as SW Standards, differences in Components and Objects, SW design architecture, parallel and concurrency.

My comments here are related to SW System Developments, NOT System programming which requires different set of rules and support.

This book is for those who wish to learn about new technologies, the SW Components. It may not necessarily solve your current problems. At the end of the day there is never an optimal SW Technology which has all the best solutions for all the SW cases. ... Read more

Product Description
A comprehensive, entertaining guide to learning the techniques of object-oriented programming discusses such topics as input, variables, structures, loops, arrays, and virtual functions. Original. ... Read more

Customer Reviews (1)

Marvelous
This is the best book on oop using c++ out there.I mean it is writen in simple and easy to understand way but it has the most comprehensive information than any other book i have picked up. I am an advance VBprogrammer and when I was reading this book I was learning how to do somestuff with VB on top of C++... I mean there are so much things includedthat you will ask yourself:"How come noone else mentioned it?".This is DA book. ... Read more

Product Description
This book takes an object-oriented approach to introduce Visual Basic .NET.The author begins by covering object-oriented analysis, design, and modeling using UML.He then moves into a detailed discussion of objects and clasess, after which, readers begin develoing their own short programs.Advanced topics such as data structures, components, and distributed/Internet programming are also covered.Programmers interested in learning the Visual Basic .NET programming language. ... Read more

Customer Reviews (3)

a good, good book...
I strongly disagree with the previous reader. This book was an easy read, one of the books I've read from cover to cover. I've had some difficulty finding an introductory book on .net object oriented methodologies, and fortunately I found this gem. Nevermind those small typos,the main thing is you get to learn and dig how classes and objects work in VB. If you have background in Java like me, this will be a breeze, but nevertheless, Alistair has that teaching method that will make you really interested on the topic and you will read more and more until you finish this great book. Highly recommended to all beginners in vb.net oop!

In serious need of proof reading
Of some use for learning OOP, but an amazing amount of errors in both the text and code examples.Perhaps the teaching method Mr. McMonnies employs is to present code with errors and have the student discover the errors, but the code is presented as working code and the student has no reason to suspect that there are errors - in fact a good 50% of the code examples do in fact work, so it is terribly inconsistent.

From what I can make of Mr. McMonnies website, this text originated from the materials for a course he teaches.The materials were evidently compiled from several different versions, an unedited hodgepodge of which went into this text.

Errors I've found:

Chapter 1:Euclid's Algorithm is stated incorrectly - step 4 should be "Let n = remainder" not "Let n = quotient"

Chapter 3:Activity 5 builds on Activities 1-4, but starts using variables that were never declared.It seems obvious that pre-publication version of Activity 3 declared the variables but they were later omitted to simplify the example.The problem is they were left in the publication version of activity 5.An obvious and easy enough to deal with error, but shows the lack of care taken in preparing book for publication.

Chapter 4:Listing 4.13 attempts to use variable "mvarBalance", but variable was never declared.A variable named "Balance" is declared and used elsewhere.Also declares a "CurrentBalance" property that is never used and uses a "GetBalance" property that is never declared.

Chapter 5:Solution to Exercise 5.4 does not work.The for loop used to calculate a factorial is wrong both logically and syntactically.

Chapter 7:Listing 7.7 demonstrates the use of access specifiers in inherited classes.In this listing a Parent class is defined with variable "MyString" declared as private.A child class is then defined with a constructor that attempts to change MyString - which it of course cannot see, but the listing presents it as though it could.

Perhaps I would be somewhat more forgiving of the errors if, on his website, Mr. McMonnies had not said in a review of another book "I did find a couple of annoying errors in it (the same topics in my own book use properly working code)".

This book is simply EXCELLENT!
Alistair McMonnies's website sucks:

http://cis.paisley.ac.uk/mcmo-ci0/

But this book is simply excellent! Alistair explains OOP in VB.net better than any other book I've ever read. Everything seems so simple when Alistair explains. I guess this is because he is "teaching" this stuff for a living. The authors of other books (I've purchased more than 25 books) "do" this for a living and therefore cannot explain well. They are so into the stuff (OOP) that they cannot perceive that the reader may not know what they are talking about.

The core of programming in .NET is centered on OOP. And this is the best book to learn .NET!

Thanks Alistair! You should go around the world presenting Seminars! You would be a success!
... Read more

Product Description
Introduces the reader to programming in C++ step by step from the C++ programs, through features such as classes and templates to name spaces. Revised and expanded. Softcover. ... Read more

Customer Reviews (3)

Good book for scientific C++
Despite its title, this book makes a great introduction to C++ for scientists and engineers who routinely deal with advanced mathematics. Development of the matrix and vector classes are a highlight of the book. As noted in other reviews, the author can take a basic idea for a class and embellish it, adding features and alternative implementations as he goes. At first this is disconcerting, but for readers desiring an in-depth look at various aspects of C++ user-defined classes, it is invaluable.

The author also defines his own complex number class. Although users of Visual Studio C++ can get by with the standard template implementation of 'complex', the development of a complex number class is a valuable scientific learning exercise.

I came to this text as a moderately experienced scientific programmer, and benefited from many aspects of the presentation. I was attracted to the mathematical developments described above and have used several of them in my own code. Readers who are scientifically inclined and frustrated with the mundane code examples in many introductory texts will take delight in this treatment. It is also a good companion to 'guru' texts such as Stroustrup's, which lay out the theoretical framework of C++ but are short on worked examples.

I'm sympathetic to readers who bought this text as an introduction and felt a bit bewildered. I agree, it's not well-suited to most novice programmers. To reach its ideal audience it needs to be retitled and marketed differently.

This is a bad introductory C++ book
This is a bad introductory C++ book. It does NOT have much
to do with Computer Graphics. Don't buy it either for computer
graphics or for learning C++ if you are a totally beginner.

Don't buy it for the graphics
The book is very good for learning C++. One drawback though is that he bases many examples on earlier examples. That way it's hard to grab the book and open it up in the middle. Don't expect to learn much aboutgraphics and absolutely don't buy the book for it. I haven't yet been ableto understand that chapter. He introduce windows programming for thegraphics without laying much of a foundation behind it.

But if you don'tcare about the graphics the book is great. ... Read more

Product Description
Writing technical applications in a modern object-oriented approach, using Fortran 90 or 95, can be problematic. This book teaches how to employ the principles of object-oriented programming to produce clear, highly efficient executable codes (rather than focusing on the traditional procedural abilities of Fortran). This text is an excellent harbinger to all the features of the finalized, fully object-oriented Fortran 200X. In addition to covering the OOP methodologies, the basic foundation of the language and solid programming skills are reviewed, making the book valuable also as a good migration tool for experienced Fortran programmers that want to smoothly pick up the OOP paradigm.The author highlights common themes by using comparisons with Matlab® and C++ and uses numerous cross-referenced examples to convey all concepts quickly and clearly. Complete code for the examples is included on the accompanying CD. ... Read more

Customer Reviews (3)

book contains lots of resources, but its usefulness is limited
This book is quite nice for the spoiled programmer who has been using a modern OO language such as C++ or python, and demonstrates methods to implement OO concepts as classes, overloading and polymorphism in Fortran 90/95 (F9X in the remainder of this review)

This however is also its main weakness: Even though F9X can be forced into these concepts, using those concepts, especially the proposed polymorphism method, is a tedious task, and makes a lot of the magic of OO programming disappear.

What is lacking in this book is an explicit overview of concepts which cannot be implemented easily in F9X, such as destructors, interfaces and inheritance, as that might be reason enough to forget about trying to implement your program in F9X.

My main conclusion after reading this is that trying to do OO in F9X is incomplete and way too much trouble, and thus the need for this book is rather limited.

Limited Usefulness
This book requires that the reader already knows about object-oriented programming.It gives little information on the subject.Instead, it gives details about how to use Fortran to implement those concepts.The details it gives will already be familiar to Fortran users, though not for that purpose.I was hoping for a book for the many scientists and engineers who have learned and used Fortran well, but who have not learned about object-oriented methods.This book isn't it.The only audience for which it is useful is the opposite: an experienced object-oriented programmer who wishes to switch from another language to Fortran.

The above occupies about a third of the book.Another third consists of elementary material that is not particularly relevant even to that audience, such as memory management, linked lists, and linear algebra.Object orientation is mentioned only peripherally in that material.

The last third consists of appendices that are mostly padding.There are language tables that are available in the manual with any compiler, and source code which repeats with variations examples in the main text.

This Book Breathes New Life Into Fortran
This is a great book for any Fortran programmer (new and old).The author does a fantastic job of introducing OOP for Fortran 90/95.I had no idea that all kinds of neat OO concepts could be implemented in Fortran.I almost want to go back and rewrite my big FEA code using these concepts.

What I like most is that the author contrasts implementation details between Fortran, C++, and MATLAB to futher enrich the topics being discussed.Obviously, with this style, the author knows his audience (engineers and scientists).

I HIGHLY RECOMMEND THIS BOOK! ... Read more

Product Description
This book constitutes the refereed proceedings of the 10th European Conference on Object-Oriented Programming, ECOOP '96, held in Linz, Austria, in July 1996. The 21 full papers included in revised version were selected from a total of 173 submissions, based on technical quality and originality criteria. The papers reflect the most advanced issues in the field of object-oriented programming and cover a wide range of current topics, including applications, programming languages, implementation, specification, distribution, databases, and design. ... Read more

Product Description
ECOOP '91 is the fifth annual European Conference on Object-Oriented Programming. From their beginning, the ECOOP conferences have been very successful as a forum of high scientific quality where the newest devel- opments connected to object-oriented programming and related areas could be presented and discussed. Over the last few years object-oriented technology has gained widespread use and considerable popularity. In parallel with this, the field has matured scientifically, but there is still a lot of room for new ideas and for hot debates over fundamental issues, as these proceedings show. The 22 papers in this volume were selected by the programme committee from 129 submissions. Important issues discussed in the contributions are language design, specification, databases, concurrency types and software development. ... Read more

Product Description
To date, books on object-oriented programming have focused either on the methodology of the object-oriented paradigm or on teaching the details of a particular programming language. This collection takes a different approach, examining one object-oriented programming language - the Common-Lisp Object System (CLOS) - as a modern programming tool. The fourteen contributions examine CLOS from a variety of angles, revealing the thoughts behind the design of the language, its intended use, its impact on object-oriented design and programming, and its place in the context of other object-oriented programming languages.

Chapter 1 provides enough detail about the language for the remaining material to be understood by readers unfamiliar with CLOS, and it concentrates on the unusual aspects of the language. CLOS is placed into historical perspective in Chapter 2, which describes the sources and evolution of ideas embodied in the language. Further chapters discuss the metaobject protocol, compare CLOS with other object-oriented languages, and discuss applications of the language and aspects of its implementation. ... Read more

Product Description
This volume constitutes the proceedings of the sixthEuropean Conference on Object-Oriented Programming (ECOOP),held in Utrecht, The Netherlands, June 29 - July 3, 1992.Since the "French initiative" to organize thefirstconference in Paris, ECOOP has been a very successful forumfor discussing the state of the art of object orientation.ECOOP has been ableto attract papers of a high scientificquality as well as high qualityexperience papers describingthe pros and cons of using object orientationin practice.This duality between theory and practice withinobjectorientation makes a good example of experimental computerscience.The volume contains 24 papers, including two invitedpapersand 22 papers selected by the programme committee from 124submissions. Each submitted paper was reviewed by 3-4people, and the selection of papers was based only on thequality of the papers themselves. ... Read more

Customer Reviews (9)

A must read for programmers
Robert Lafore's OOP in C++ is an excellent book.I read it from cover to cover.I also did all the examples in the book.I got so used to this book that once I lost it,I could not satisfy my doubts in C++ with any other book.Lafore deeply explains the complexities of this language in a simple easy way.Great for beginners also.Although,I read many other books on this subject,no other book explains things so vividly and clearly as in this.

Learned how to program with this book!
I stumbled onto this book in 8th grade at a local Bookstar bookstore back in 1992.After thumbing through a few pages, I found that I could understand it pretty easily.

It was an amazingly well-written book.As a 14-year old kid I was able to write some pretty fancy object-oriented programs.Later in college, I found myself using Mr. Lafore's book more often than I used my C++ text by Stroustrup.

At some point while moving back and forth between school and home, I lost my copy.But I found that this book is STILL available in what is essentially its 4th edition under the title "Object-Oriented Programming in C++" to this day.Long live this book!It's wonderful!

Yes !
I rarely give 5 stars to anything. This book is in the top 2 or 3 computer books I've ever read. The author uses a +5 pronged approach to teach. Most books don't even use 3! He explains the general concept very well, then providesrelevent small examples, questions (with answers) at the end of chapters, then a magna cum example in a separate chapter, and what's more he uses diagrams very generously.
I agree with the other reviewers - FANTASTIC!
If anyone knows of a better beginner-intermediate C++ book, please send me an e-mail, titled "BETTER C++".

A Great Teacher!
Robert Lafore Once again writing an outstanding book.It is a compulsory for any C++ developer.

Awesome!
This book is a definate must for the new C++ student.Easy to read and many examples with precise explanation of the example codes. Great book and a definate must have. ... Read more

Product Description
In his newest programming book, Paul Wang provides complete coverage of Java programming, from basic concepts and procedures to advanced topics. This is one of the first Java books that is written as a text, not just as a professional reference, making it much more logical and readable than most trade books. Designed for readers with prior programming experience, the book introduces OOP, graphical user interfaces, networking, multithreading, and event-driven programming. These concepts and techniques are applied to the development of interesting programs and Java applets, with the careful attention to practical implementation details that has marked Wang's popular books on C, C++, and UNIX. Concepts and techniques are illustrated with complete, ready-to-run examples. This book makes an excellent choice for courses in Web programming or software engineering, as well as junior, senior or graduate-level Java courses and professional reference. ... Read more

Customer Reviews (2)

Info from the Author
This book has a website with a rich
collection of supplemental materials:
sofpower.com/java

Surprisingly rich and readable for such a thing book
Java books nowadays tend to be mammoths.You nearly break your arm lifting them off the shelf.But Paul Wang's rather slender book still packs a wallop and delivers excellent content in tons of very readableexamples.You'll learn about neat, arcane topics like using Java to writeCGI server programs and all sorts of things about network sockets.Thereare very few errors and the typefonts are especially large and readable. The only detraction, which isn't Dr. Wang's fault, is that the cover is toothin and flexible.This wonderful book deserves a hardcover! ... Read more

Customer Reviews (6)

THE book on object-oriented programming in Common Lisp
Sonya Keene is one of the very best technical writers in the entire computer industry, and she was one of the inner circle of experts who designed and standardized the Common Lisp Object System.This book is crystal clear, accurate, and comprehensive.

Really great book on CLOS
This is a great book. It shows everything about CLOS (except the metaobject protocol, which is just mentioned but not explained in detail). The explanations are very clear and the author does every possible thing to make you understand all details (a bit too much for me, but that's a matter of taste).

For anyone interested in OO programming in Common Lisp, this is an essential book.
Even if you are interested in OO programming in general, this book covers a different approach, so it is nice for a comparison (in CLOS, methods do not belong to classes, and there are lots of interesting tricks that you can do that are not possible in other languages).

Concise, clear and readable, an excellent introduction
Lisp is kinda hot again, Perl 6 will have multiple dispatch, Ruby's getting before and after methods, and Aspect Oriented Programming is still bubbling under in Java, so what better time to revisit the Common Lisp Object System and this slim volume from 1989? Unsurprisingly, objects in Lisp are implemented differently to the well-known object systems, even Smalltalk, so if you're into OO (and in particular AOP), check out CLOS.

And this book is an excellent way to get acquainted with the features of CLOS. While the introduction suggests non-Lispniks can benefit from reading this book, I would strongly suggest you can read Lisp to make sure you understand what's going on. It's a quick read (about 220 pages, excluding the appendices), the language is unfussy and clear, and the concepts are simply explained.

The hoary old shape example is used briefly (perhaps it wasn't as tired in 1989), but the two main examples used in the book is a simple locking mechanism for concurrency, and multiple inheritance based disk and tape stream classes. Both example do the job well of highlighting the unique flavour of CLOS. The metaobject protocol is touched upon only briefly, but there's more than enough of the standard object protocol described for you to be getting your money's worth.

Other introductory books do cover CLOS (Practical Common Lisp has a good chapter), but this is a very nice standalone volume devoted to CLOS only. Well worth reading, object (and Lisp) fans.

A good way to understand "why CLOS?"
This is a nice "tutorial style" walk through much of the functionality of CLOS.

It doesn't get into examples that are of _spectacular_ complexity, either in size or in difficulty of concept, but that strikes me as being just fine.The dialect of CLOS in use predates the final version that was released, so a few examples require a little modification to work with modern Lisp releases.

If you're looking to get into the sophistication of redefining your own metaobject protocols, the MOP book is surely more suitable.But for most of us who just need to figure out what CLOS is good for, this book provides a very nice presentation of that.

The cover says it all
You are going to get precisely what is advertised: a good guide to object-oriented programming in Common Lisp, no less, no more. ... Read more

Product Description
Symbolic C++: An Introduction to Computer Algebra Using Object-Oriented Programming provides a concise introduction to C++ and object-oriented programming, using a step-by-step construction of a new object-oriented designed computer algebra system - Symbolic C++. It shows how object-oriented programming can be used to implement a symbolic algebra system and how this can then be applied to different areas in mathematics and physics. This second revised edition: - Explains the new powerful classes that have been added to Symbolic C++ - Includes the Standard Template Library - Extends the Java section - Contains useful classes in scientific computation - Contains extended coverage of Maple, Mathematica, Reduce and MuPAD Updated and extended code is available at http://issc. rau. ac. za . ... Read more

Customer Reviews (2)

a great object-oriented application
You will find this book fascinating if you are a computer science student intrigued by symbolic calculation systems such as Mathematica and Maple, and if you would like to see how such systems would be implemented in C++ (Mathematica and Maple are actually implemented in plain old C).

The C++ level required is just after CS2, the second C++ class that comprises data structures. If I were a CS2 instructor, I guess I would require students to read some parts of this book since it is a great means of reinforcing about all the concepts learned in C++, while building a nontrivial application; although some examples are taken from physics, physics knowledge is by no means required and the general math level called for reading this book remains comfortably low, and one can always skip the things one does not know or does not care about (such as quaternions, but hey, some people might be turned on by that stuff...).

It shows how to build classes that actually perform calculations using integers of arbitrary length, rational numbers of the a/b form, vectors, matrices, quaternions, symbolic variables, differentiation, integration, etc.

The system described in the book, SymbolicC++, can be used as a FREE alternative to Mathematica or Maple, less of course the graphing capabilities these great software products offer (less also zillions of functions available). SymbolicC++ may nevertheless be connected to Gnuplot to produce graphs. SymbolicC++ may also be of interest to the professional developer having to struggle with complex calculations, since its classes can be included in any C++ environment.

So in short, this book is great if you have the right background and the right interests.

I should also point out that Dr Steeb has written another great book that shows the system at work in problems from the physical sciences and finance ("The Nonlinear Workbook")

Eclectic but rich
A mixture of C++, group theory, and mathematical physics. Far from a polished treatment, but maybe worth perusing if these are topics of interest to you. ... Read more

Product Description
Follow your own path to expertise with this self-guided tour of the Java programming language. Written by two members of the JavaSoft team at Sun Microsystems, the book employs a hands-on interactive approach to teaching Java basics, object-oriented concepts, applet programming, and everything else you need to know to become a proficient Java programmer.

Through a task-oriented, example-driven approach, The Java Tutorial introduces you to fundamental concepts and applications. Designed so that you can customize your own path through the specific information you need, the book explains the nuts and bolts of the language, applet construction, and the fundamental Java classes. You will also learn about more advanced topics such as creating a graphical user interface (GUI), using multiple threads, and working with Java's networking capabilities.

This Second Edition has been extensively updated to cover API changes in Java 1.1 regarding UI, networking, and I/O, and to include the latest Javalanguage developments. New and updated material includes:

*broadcasting to other applications via a multicast socket *new I/O features, including character streams and object serialization *the latest developments in applet tags *using the 1.1 AWT event system *new language features, such as nested classes *tips for writing 100% Pure Java programs *updating 1.0 programs to use the 1.1 API

In addition, the Second Edition has been revised and reorganized to offer a stronger and more cohesive presentation, making this best-selling and award-winning book even better. The Tutorial now starts with a new lesson that introduces you to the Java phenomenon and provides a foundation for understanding the rest of the book.

The accompanying CD-ROM contains the Tutorialand all its code samples, versions of the Java Development Kit (JDK) and the JDK documentation for each major platform, a 1.1-compatible version of the Swing/JFC package of GUI components, and the HotJava Browser. The CD version of the Tutorial is a browser-friendly version that includes information not found in this book, such as draft lessons on internationalizing Java programs, calling non-Java libraries from Java programs, using the security API, developing JavaBeans components, and using the GUI components in the Swing/JFC package.Amazon.com Review
Some of the best sources for learning Java are online. TheJava Tutorial, Second Edition is an updated compilation of onlineresources from the JavaSoft Web site, edited for clarity. This guidegives you the advantage of having all you need to learn Java in onebook (and includes a CD-ROM).

The authors organize the book'ssections around lessons and "trails" (which correspond toonline tutorials). Beginners will find the sections on running simpleJava applications and applets and on the nuts and bolts of the Javaprogramming language especially useful. However, there is plenty ofexpertise here for the Java expert. (Because this is all"official" JavaSoft material, it gives excellent perspectiveon the ideal use of Java--100 percent pure programming that runs onall hardware platforms.) For example, the sections on using theJavaStream classes present some hard-to-find material on memorystreams and pipes.

Additional topics discuss how to get around thebasics of creating user interfaces with AWT classes (though this isless useful because most programmers will use a Java compiler thathandles the details of inner classes and adapters for them). Chapterson graphics programming benefit both beginners and experts and includea great explanation of image filters and animation techniques.

Someof the niftiest stuff in The Java Tutorial is presented in thesections on network programming in Java, with a clear explanation ofreading and writing to URLs and working with sockets. (Thesecapabilities are all built in to Java, and this tutorial shows you howto execute them.) The book finishes up with a discussion of newfeatures in JDK 1.2--still under development--and with the printedsource code for all the examples in the book. This book makes a goodargument that print still has its advantages. You'd spend hoursdigging up the relevant tutorials online. --Richard V. Dragan ... Read more

Customer Reviews (40)

Fair and not a tutorial
This book is not a tutorial; it is not even really introductory.
It does have some good explanations though. i bought thisd book because I have been trying to learn Java for the past 9 months. It isn't that the language is hard its the way it is taught!

I will rate this book 3 stars; 3 stars for some good explanation. But the rest of the book is dumb examples and demonstrations, you will have to look up stuff at the Java web site to find out what exactly the methods mean. Also this book assumes you already know some basic java or whatever.

If you have read some other java books fine buy this book, if not, beware; this book is only demonstrations without proper explanations.

The purpose of a Java book should be to get the person reading it to apply what they study and I have yet to read such a book.

DON'T BUY THIS!!!!
Not that its bad.It like most Sun books is very good, but the Third edition is out.Buy that to get the latest on learning JAVA(tm).

NOT for BEGINNERS
This was my textbook for a introductory college class for Java, and I never refer to it that much. Not too many examples to take a look at. It is good for a reference when you are more knowledgeable about Java. But don't think this is a handholding sort of book for the neophyte in Java. I wish there were more example for applets in the book.Anybody wants to buy my copy? The college bookstore is not buying it back, and I wonder just why.

Excellent Book on Java
This is perhaps one of the most well written technical books I have come across in a long time. It helps to have OOP background, to understand the way java works. The book is not a tutorial in the sense that some would expect, but it explains the fundamentals and attributes of the language in a very clear way. I have had this book for several years now and still refer to it (as a programmer) every now and then to review the fundamentals of how some things really work, so in that sense it is still valuable, especially due to the technical details. If users want to learn how to implement specifics on awt etc..., then they should buy a book that focuses on that, but this book does accomplish the objective of introducing java very well. This has been the source and perhaps a reference referred to by many when first introducing people to java. Problem is, the book is now probably well out dated, and the reader is adviced to buy newer editions, but this is still a great reference book on the fundamentals and mechanics of the language. Bottom line, I have no regrets for purchasing this book.

This edition covers JDK 1.0 only
This first edtion of the Java Tutorial in print covers the JDK 1.0, meaning the older event model and AWT components. I saw some editorial reviews up above that seem to gloss over this fact. Be aware that thisexcellent book is now outdated, and you ought to get the 2nd edition if youare new to Java programming. I just recently (June 2000) saw a print ad fora 3rd edition as well. ... Read more