Beginner Java @ Java Programming
Programming Network : The Programmer Store & Resources
An Introduction to Software Construction with Java
by Jaime Nino, Frederick A. Hosch, F. Hosch
Paperback: 784 pages
Publisher: John Wiley & Sons
ISBN: 0471354899; 1 edition (May 4, 2001)
From Book News, Inc.: A textbook for an introductory Java programming course intended for first year computer science students. Nino and Hosch (University of New Orleans) use simple software systems to identify objects and their properties, walk through the design-specify-implement-test life cycle for classes, and present object relationships and associations for the design and implementation of applications with objects.Book News, Inc.®, Portland, OR
Book Description: The emphasis throughout this book is on problem modeling using fundamental software engineering principles and concepts. Although Java is introduced and used throughout the text, this is not a text about Java. Rather, Java is used as a tool to present the concepts. The UML is used, very informally, for denoting objects, object relationships, and system dynamics.
Learn Software Design From Two Legendary Masters, December 13, 2001
Reviewer: Joseph Huang from New Orleans, Louisiana
For nearly two decades, the computer science department at the University of New Orleans has had the outstanding reputation of possessing one of the finest academic programs in software engineering in the south. A huge part of this reputation can be attributed to the presence of two legendary software designers at the department, Professor Fred Hosch and Professor Jaime Nino. Now, for the benefit of those who are unable to experience the expertise of these two professors first-hand, John Wiley & Sons, Inc. proudly presents An Introduction to Software Construction with Java, the very first textual authority ever to be written by Professors Hosch and Nino. Although no substitution for the professors themselves, this paperback mentor will teach you how to program and program well.
Unlike any other textual teaching tools on the subject of software construction today, such as Java In a Nutshell by David Flanagan, Hosch and Nino's text is geared towards the novice programmer, that is, an introductory-level student who does not even know the meaning of the phrase "computer science." In this textbook, the authors first define what it means to be a software engineer. Then, they will take you by the hand and teach you the basic syntax and grammar of the Java language. You will learn how to define variables and construct objects. You will know what the concept of "object-oriented designing" means.
Next, these authors will teach you what no other books on software that I have read thus far will teach you: how to design a good software system. These authors will teach you how to construct interaction diagrams and how to use them so that you can implement well-organized relationships between clients and servers. You will fully understand and appreciate the extremely important, yet often overlooked, concept of designing a good programming by contract relationship between objects. Often, I see textbooks presenting as examples to students implementations that Hosch and Nino would refer to as a "house of cards." In other words, the relationships between the objects in such examples are so unnecessarily complex that any minute modifications to these poor implementations will cause the collapse of their entire software structure.
A programmer, by definition, is one who can implement software systems that execute properly. What, then, is the definition of a good programmer? A good programmer is one who knows how to implement software so that it can solve a problem within the least amount of time possible. How do you gauge the time complexity of a software system? Hosch and Nino will present you with a classical tool for measuring software speed that is guaranteed to increase the efficiency of your designs in no time.
Other topics covered in this book include: constructing lists, guidelines to writing better comments and documentations, techniques for building maintainable and adaptive software that completely encapsulates a single notion, techniques for optimizing your software's interface via the principle of information hiding, handling exceptions and failures, developing graphical user interfaces that adhere to the model-view-controller pattern, constructing advanced containers, such as dynamic arrays, linked lists, stacks, dictionaries, queues, and hash tables, and, finally, learning how to develop your very own software library.
So, if you are a software developer or are just remotely interested in the craft of software engineering, I urge you to buy this book and let Hosch and Nino, two legendary professors from the University of New Orleans, teach you the proper marksmanship of legendary programming.
An ambitious attempt, but falters badly, November 27, 2001
Reviewer: A reader from Portland, OR
My business card says "software engineer" but I code very little. This book is the text for an introductory computer science course I am taking. While I admire the authors' attempt at putting Objects First in the curriculum, they have only succeeded in confusing and alienating a number of my classmates with little programming experience. The most glaring weaknesses are the the relatively few, undistinguished examples, and the lack of rigor in teaching Java syntax and semantics. The authors' freely admit that they do not attempt to teach Java itself, but this ultimately leaves students stranded as they peruse the hundreds of Java titles at the local bookstore, looking for a decent language reference. Lastly, they mix a lot of software engineering practice in with the actual computer science. While topics such as programming by contract and software quality are important, I am not convinced that this material is suited for students at the beginning level.
Oh snap, your teacher assigned this book too!, November 7, 2001
Reviewer: sdb_8 from portland, or United States
I've read many bad computer books and this one is less then horrible, but it sure ain't good.
The authors start with a very important forward pointing out that most books and courses in C++ and Java make the mistake of covering basic implementation of the language without employing object orientated techniques. Then, when object orientated programming style is introduced, students are bound to be frustrated and confused. This is a correct description of a serious problem that university's need to address. However this book goes too far in the other direction. The authors take an extreme Ivory tower approach. They expound eloquently on program specifications and design philosophy while ignoring the implementation, which is half the battle. Explanations related to programming become meaningless unless there is good code to edify the ideas they are trying to convey. This book has very little good code in it that you can employ in a useful and instructive manner. Related to this overly object orientated Ivory tower teaching approach some major problems with this book are:
- IO streams are not even covered until the end of the book. I suppose the author's de-emphasis of realistic programming problems relates to their desire to teach beautifully rather then practiaclly.
- A continual stream of program methods are thrown about in later chapters which are not appropriate to a CS 101 level course
- Java language conventions and fundamentals are given swift and inadequate treatment in first three chapter (except for objects which are covered well).
- Very few compact code examples to illustrate basic and intermediate programming concepts.
- No answers to programming exercises at the end of chapters.
The worst thing is the stupid D&D program that they use for half the book to demonstrate too many concepts. Who in Tar-nation is going to be able to figure out what the heck is going on with a program this advanced by the time its dragged through the sixth chapter? It's a forty method, multi-class implementation! Please. How are you going to learn basic Java concepts from a program that takes up 40 pages? If you can emulate what the heck their doing with this program at that point then you should be teaching the class not taking it.
Horrible, October 31, 2001
Reviewer: Eno from New Orleans, LA USA
I'm unfortunate enough to use this book for my object-oriented software design class. The text is very complicated and very difficult to understand. Plus, there is not a whole lot of examples provided in the book. The problems on the back of each chapter make you more confused rather than increase your understanding. Do yourself a favor and stay away from this book.
Computer Graphics / Games: Photoshop Wire | CorelDRAW Wire | PC Games
Graphing Calculators | Shop 4 Calculator
© 2017, Programming Network