Book Description
Emphasizing problem-solving skills throughout this very successful book, Stephen Chapman introduces the MATLAB® language and shows how to use it to solve typical technical problems.The book teaches MATLAB® as a technical programming language showing students how to write clean, efficient, and well-documented programs.It makes no pretense at being a complete description of all of MATLAB®'s hundreds of functions.Instead, it teaches students how to locate any desired function with MATLAB®'s extensive on line help facilities.Overall, students develop problem-solving skills and are equipped for future courses and careers using the power of MATLAB®. ... Read more

Customer Reviews (5)

Works....sometimes. Don't get it if you have a Macintosh.
Bought Matlab.This company spends more time/resources making sure you don't steal it (ie allowing you to install it on your own computers hassle-free)...then it does in working the bugs out. It is advertised as working with Os X....GOOD LUCK getting it to run right. This stupid program was so important that I had to run out and buy an Intel iMac..Install that Bootcamp/Windows OS "thing", and install Matlab on the pc side so that I could have stable environment. This P.O.S. is NOT Mac compatible... Sooo...having said that....whatcha think?

Dear Matlab Folks: drop the RETARDED activation scheme which ONLY hurts LEGITIMATE users ( you can find lots of cracked versions in the newsgroups btw) and make this program WORK.

Great from Basic to Advance
This is a great book for learning Matlab. It starts from very, very basic stuff, and picks up at a steady pace, teaching u tons of things with ease. This is the official book of my College Course "Computer Programming for Mechanical Engineers", and I'm doing great in it with the help of this book.

A good first book for beginners
I am not a full time computer programmer.In spite of my limited programming experience, I was able to follow the lessons in this book.The information is presented in a logical sequence and fully explained and illustrated.As the title suggests, this book is for engineers who need answers for their own use and is not intended to show you how to make fancy illustrations for presentations.
There are two shortcomings that bothered me.One is the lack of a table at the end of each chapter listing the other commands and functions that do almost the same thing as the ones covered in the chapter.This would increase this book's usefulness as a reference.The other problem is the end of each chapter having an illustration of some interesting engineering project or concept.One claimed that Matlab could be used to drastically improve the fuel efficiency of motor vehicles.The other was a half baked political statement to the effect that you would be better off giving irrevocable control of your life over to a group of people who have a history of looking after their own interests first and others second.Of course this suggestion was worded in an appealing style.

It Could be Better.
The book is a good start to MATLAB students but there is a lot of errors in the text. Despite the author's appeal asking everybody to show him the errors, I think it would be better to rewrite the book, mainly because his work could be more useful if he insert a specific chapter about I/O operations, which is, in my opinion, the most dificult thing to do in MATLAB. Examples of I/O operations with several data formats would be useful too.

Great Book!
This is a great text. Easy to read and many good examples illustrated in the book allow you to quickly pick up MATLAB, especially the GUI section. It's very clear and up-to-date. Unlike some other texts just tell you the inefficient Matlab 4.x code for the GUI programing.

*I am a undergraduate engineering student by the way. ... Read more

Book Description
Part of the highly successful Shelly Cashman Series, this text takes the project-oriented approach to learning introductory Java programming skills. With an emphasis on object-oriented programming concepts and real world examples, this book presents students with presents difficult programming concepts in a straightforward and exciting way! ... Read more

Customer Reviews (3)

Fast and Furious
I used this text for my first programming class. It jams a lot into 8 chapters (really 7 as the first doesn't hit you with much). I would prefer a little more of a chapter spread. In fact I would say this is a lousy intro to programming book. Now that I have been through a higher level programming class I am going back to this book and finding it more useful. The programming examples are quite complicated and makes a few assumptions on your level of understanding. The programming examples do not have errors as stated in a previous review, but when you are first learning you make typos and don't know what to look for to correct them. I like to type in all the examples for practice but after an hour of compiling and getting nowhere it would be nice to have downloadable files (Instructors can get them). Overall I would say by the time you can understand this book... you don't really need it for the price.

New Edition
While I haven't yet read this book (for class), it should be noted that the (at this time) only review must be referring to a previous edition because the current edition is from late 2005, while his post is from 2002. I assume this new edition is updated.

Good but outdated
This book is good for beginning programmers or for those who wanted to learn Java.The book is very detailed about the methodology of programming and such.However, as you continue along in the book (about chapter 3) you start finding more and more code errors in the examples you are working with.It makes it really hard to learn if the examples are wrong.Also, the Author doesn't follow his own rules in his consistancy of variable naming.I wouldn't buy this book if you are trying to learn the most current version of java and techniques.I would buy it if you are interested in learning the fundamentals of programming. ... Read more

Book Description

Genetic Programming IV: Routine Human-Competitive Machine Intelligence presents the application of GP to a wide variety of problems involving automated synthesis of controllers, circuits, antennas, genetic networks, and metabolic pathways. The book describes fifteen instances where GP has created an entity that either infringes or duplicates the functionality of a previously patented 20th-century invention, six instances where it has done the same with respect to post-2000 patented inventions, two instances where GP has created a patentable new invention, and thirteen other human-competitive results. The book additionally establishes:

Customer Reviews (2)

Table of contents
Since the "look inside" doesn't contain the toc, here it is from Barnes&Nobles:

Table of Contents
1 Introduction 1
2 Background on genetic programming 29
3 Automatic synthesis of controllers 49
4 Automatic synthesis of circuits 129
5 Automatic synthesis of circuit topology, sizing, placement, and routing 175
6 Automatic synthesis of antennas 205
7 Automatic synthesis of genetic networks 221
8 Automatic synthesis of metabolic pathways 229
9 Automatic synthesis of parameterized topologies for controllers 281
10 Automatic synthesis of parameterized topologies for circuits 301
11 Automatic synthesis of parameterized topologies with conditional developmental operators for circuits 341
12 Automatic synthesis of improved tuning rules for PID controllers 367
13 Automatic synthesis of parameterized topologies for improved controllers 387
14 Reinvention of negative feedback 413
15 Automated reinvention of six post-2000 patented circuits 421
16 Problems for which genetic programming may be well suited 483
17 Parallel implementation and computer time 515
18 Historical perspective on Moore's law and the progression of qualitatively more substantial results produced by genetic programming 523
19 Conclusion 529

Gp here we Go
Since using evolutionary algorithms for my work, it is easy to see how many of the current EAs can be used to solve or tackle various real world problems. But what Koza does once again is to argue the case that GP is more than just an optimization algorithm but instead an algorithm that tries to show what AI should do and how user and AI should interact to solve a problem. Once again numerous examples are given, with detail on how problems are laid out so as to get the best results from the GP. Koza shows that with well thought out planning GP's can be applied to all sorts of fields.
In one of the chapters he presents the characteristics a problem should have for GP to be applicable.
All-round Great work, my advice get all his books and digest how he approaches various problems with GP. This example format Koza uses is far more useful than talking about what GP is and its theory. Though for a good intro into Evolutionary Algorithms including GP get either Foundations of Genetic Programming or an Introduction to Genetic Programming. An all round good intro is Introduction to Evolutionary Computing. ... Read more

Book Description

The purpose of network performance analysis is to investigate how traffic-management mechanisms deployed in the network affect the allocation of resources amongst its users and the performance they experience. This topic can be studied by the construction of models of traffic management mechanisms and observing how they perform by applying them to some flow of network traffic.

Customer Reviews (1)

Excellent
I have read this from cover to cover and it is an excellent text on the subject ... Read more

Book Description
Have you ever seen players' eyes light up as they explore the worlds that you've created in your games? If you have, then game development probably has you hooked firmly in its grasp! If you’ve never taken your games beyond the PC, now's the time! "J2ME Game Programming" is a hands-on guide that teaches you how to create games for micro-devices. You'll be amazed at just how cool the games you create can look and play. Focusing primarily on mobile phone game creation, you'll jump right in and create your own games as you work your way through the book. The thought has surely crossed your mind that it would be nice to make some money off of this cool hobby of yours. J2ME offers real opportunity to profit from your games. Learn how you can earn revenue from your games by taking them to market. If you have a basic understanding of Java, then you're ready to explore all that "J2ME Game Programming" has to offer! ... Read more

Customer Reviews (8)

Good intro to J2ME and programming games using it
This book will show you how to code games using J2ME, with a clear focus on creating games for mobile phones. The chapters in this book are intended to be read sequentially, so if you're already familiar with the content covered in a particular section, you should skim over it rather than skipping it entirely. The author assumes you're already familiar with Java, or at least another object-oriented programming language. You don't need to be an expert, but you do need to know the basics. The book requires an understanding of rudimentary mathematics; however, the toughest level you get to is simple trigonometry, and even then the explanations are fairly detailed. It is also assumed that you're familiar with basic PC operations and can take care of environmental details such as downloading and installing software. Sometimes the language of the book is just a little too cute ala Andre LaMothe, but the information is all there.

Part I is an introduction to J2ME, including its origins and current position in the marketplace. This section also takes a look at a range of typical J2ME devices and mentions the sort of gear for which you'll be developing.

In Part II you'll grab all the tools you need and set up your environment for development. Then there is a review the APIs provided as part of Sun's J2ME SDK, along with the added features available with device-specific libraries. At the end of this part, all these tools are put into action with the creation of a small action game called "RoadRun" that presents the player with the challenge of helping a little wombat across a busy highway. The game is very simple and small, but it does illustrate some key points of J2ME game coding. I thought it was a good beginning example.

Part III covers real project development. There's a discussion of how to refine game ideas into project plans before embarking on the development of a full-scale action game called Star Assault. Then, through nine chapters the book covers all aspects of developing a commercial-quality game, including graphics, physics, environments, front ends, device-specific customization, and finally localization. This is the real meat of the book for people interested in game development, but even here there is nothing particularly difficult going on.

Part IV moves into the world of marketing and publishing games. This section looks at how to create marketing material to promote your game, as well as how and where you can earn revenue. This material is all pretty subjective.

Part V takes J2ME game development further by covering the features available in MIDP 2. The author shows how to create different types of games by developing both an isometric and 3D ray-casting engine. Finally, the book explores networking with MIDP and how it can be utilized to create multiplayer games.

All in all, this is a pretty good introduction to J2ME and to writing games using it. Just don't expect anything advanced in the arena of mathematics or physics, and get used to sitting through the author's "surfer dude" narrative style. Plus, although it is mentioned, there is a lack of sufficient information on MIDP 2.0 due to the date of publication.

Best way to learn J2ME + MIDP1.0
Some months ago I did an exhaustive research on books about J2ME + MIDP1.0.
(Although MIDP2.0 or Symbian is what you need to know to develop for the latest handsets, the big market out there is MIDP1.0)
Comparing reviews from this site and citations in expert forums like Nokia Forum, it was soon clear that this book was a winner.

This book is a heavy one. You will dedicate a complete month to master it. And a second month to develop your own game engine based on the one proposed in this book.
What I liked most about this book is exactly that. There are no open-source or cheap game engines for J2ME+MIDP1.0 around. You have to assemble your own! And Wells does a very good job explaining you every decision he made while developing the framework for the game presented in the book.
More precisely, the book presents two games. The first one is a Frogger clone, done in a pretty simple way...after the first chapters learning J2ME he shows you how to code a prototype of a game. But developing a real game is a much more involved task. That's he spends the next 300 pages explaining you how to develop your game in a professional way. Perfect!
The book also has chapters on marketing your game and sales aspects. It also has a brilliant chapter on isometric games and a -let's say- experimental chapter on a 3d technique known has raycasting (you probably wont use it but its very interesting to read anyway). It also has an introduction chapter to MIDP2, explaining you how some of the decisions he made in the development of the game where influenced by the migration path logic to MIDP2.
A word of warning: you will find some typographical mistakes in the book. There is even an example code at the beginning which is misplaced.
But you probably won't type anything from the book, everything you need to try the examples is located in the CD.
The book is in a way outdated. It explains how to code in a IDE like Eclipse and compile versions for the various handsets using Ants. Today we use Netbeans which does that transparently. Anyway, its good to know how is it done in the inside.
I finished reading this book 2 month ago and I still use it as reference while I'm developing games.

If you just want to know about mobile game programming, don't buy this book, it's too hard and long for you. But if you want to develop games professionally, this is the right book for you.

Review from someone currently reading the book
I bought this book because I'm looking to get into J2ME game development. There are VERY few books on the subject, and this book (although written for MIDP 1.0 and not the newer MIDP 2.0) seems to be the one that everybody recommends.

I've worked up through the examples in Chapter 5 and so far, the content is great. If I were just grading on content then I'd definately give it 5 stars. What I'm finding I'm having a huge problem with about this book is the staggering amount of errors in the code. I simply can't believe that a book could be released to the public (and have the publisher expect consumers to pay money for it) with so many typos. So far EVERY SINGLE example I've entered and ran has had errors. Not syntactical errors (so you can't chalk it up to "I just didn't type the code in right"), I'm talking LOGIC errors that either cause the sample applications to run incorrectly or completeley different than how they are described in the text (in the case of the first example in chapter 5. Its practically an entirely different application than what the text says its supposed to be).

Whoever proofread this book at Thomson publishing must not have been a technical person who just glossed over the code and focused on the content of the text. But most of the blame has to fall on the author's shoulders for writing and releasing code that doesn't work right in the first place...

Either way, I really can't say that I can encourage or endorse this book so far.

I hope that when I get into the main focus (after the first 200 pages of the book which rehash the same old J2ME techniques that you can read online or get from a J2ME book) that the 2 example games you write in the book from start to finish do not have so many errors.

It's a great book!
It's a great book! I recommend this book for people who want really to learn j2me.
Congratulations Martin

Game Programming
This book really explains in depth how to make a game on a mobile device. The book is well organized and he makes the difficult parts seem easy. Almost all code is based on MIDP 1.0. There is a chapter on MIDP 2.0 also. For the sake of game programming I'd say this is the book. Maybe we'll see an updated version concentrating more on MIDP 2.0 later on? All in all a very good book ... Read more

Customer Reviews (4)

very good textbook
although this isn't my favorite pascal book, it's a good textbook without any major flaws.

EDIT: pascal is a dead language. for a simple but useful language, try Delphi (based on pascl) or Visual Basic.

I LOVED this book!
I will definitely be purchasing other books from this author. He has a very direct, and extremely clear way of explaining what would have otherwise been confusing principles.

This book is the Computer Programmer's Bible for Pascal
This was my textbook for Pascal at the University at Central Florida. Ithas helped me through Computer Science I and II. It is well written andeasy to understand. It helps for both the beginner and advancedprogrammers. This is a need for anyone who programs in Pascal.

A great way to learn Pascal
The High School I attended used this book for its first-year programming course.It is well written, and clearly explains all of the basic concepts, without leaving out any of the more complex parts of the language ... Read more

Customer Reviews (1)

Mathematical notation-based approach
The author utilizes mathematical notation rather than suffering through the inevitable inadequacies and limitations of any particular language (LISP, ML, Haskell, ..) However this actually simplifies the instruction,assuming the reader is familiar with set theory and the basics of formallogic.

The illustrations are primarily of the kind familiar to anyoneinvolved in computer science, such as parse trees, flowcharts, andschematics of memory allocation. There are also mathematical typesignatures.

Program examples include [very] infrequent ones in LISP, aswell as occasional procedural examples given in antiquated-yet-adequatePascal.

For the purpose of general instruction this may well beunexcelled in the field. Upon completion the reader will have a betterunderlying understanding of any particular functional language than peerswho have been programming in one ad-hoc for a substantially longer time.Many of the general topics are fundamental to other language paradigms aswell, including procedural and object-orientation (of which the author isan expert and contributor). Of particular note are the topics of recursion,binding, and computability issues, as discussed using the lambdacalculus.

This is an extremely clear work, systematically coveringsubjects ranging through logic, computing and math without drawing anyattention to distinctions between them. Throughout, it maintains a completefocus upon functional programming. In this way there is a satisfying flowto the book, allowing the incredibly rich and fine detail to be betterunderstood in context.

It is important to take note that this work doesnot merely teach the reader about programming in a functional language.Many tangent subjects will become familiar in the process, including somewhich may have previously been a source of intimidation. And, asprogramming languages evolve, such a foundation will prove over time to bean invaluable resource. ... Read more

Book Description

The Mac has fully embraced OpenGL throughout its visual systems. In fact, Apple's highly efficient, modern OpenGL implementation makes Mac OS X one of today's best platforms for OpenGL development. OpenGL^® Programming on Mac OS^® X is the first comprehensive resource for every graphics programmer who wants to create, port, or optimize OpenGL applications for this high-volume platform.

Leading OpenGL experts Robert Kuehne and J. D. Sullivan thoroughly explain the Mac's diverse OpenGL APIs, both old and new. They illuminate crucial OpenGL setup, configuration, and performance issues that are unique to the Mac platform. Next, they offer practical, start-to-finish guidance for integrating key Mac-native APIs with OpenGL, and leveraging the full power of the Mac platform in your graphics applications.

Coverage includes

• A thorough review of Mac hardware and software architectures and their performance implications
• In-depth, expert guidance for accessing OpenGL from each of the Mac's core APIs: CGL, AGL, and Cocoa
• Interoperating with other Mac APIs: incorporating video with QuickTime, performing image effects with Core Image, and processing CoreVideo data
• Analyzing Mac OpenGL application performance, resolving bottlenecks, and leveraging optimizations only available on the Mac
• Detecting, integrating, and using OpenGL extensions
• An accompanying Web site (www.macopenglbook.com) contains the book's example code, plus additional OpenGL-related resources.

OpenGL^® Programming on Mac OS^® X will be valuable to Mac programmers seeking to leverage OpenGL's power, OpenGL developers porting their applications to the Mac platform, and cross-platform graphics developers who want to take advantage of the Mac platform's uniquely intuitive style and efficiency.

Customer Reviews (2)

multiple APIs to choose from
The text describe the nitty gritty of coding or porting your OpenGL applications to the Mac OS X environment. To a limited extent, the book has a general treatment of programming in OpenGL. But it is not meant as a text on the latter. Instead the focus is on the "issues" that making for possible problems on OS X.

One of which is that OS X has 2 types of windows, Carbon and Cocoa. It might perhaps be nicer if there was only one. But this is what you have to deal with. The Apple OpenGL (AGL) is the interface to Carbon, while you need the Cocoa OpenGL for Cocoa. It is slightly unusual that a major platform would have 2 types, and you may want to code just for one type. The book gives many details about both APIs, as well as the GLUT API. An evenhanded discussion. Different readers might well have different preferences.

Some of you should check out the discussion about multithreading, if intensive graphics performance is needed in your applications. The OS X OpenGL engine is said to have much better performance due to its multithreading, than typical serial engines.

Boost your OpenGL Programming Productivity
This book has a lot of shining points. First, all its explanations are crystal clear, focused into the concepts and techniques OpenGL developers really need. Furthermore, the book comprises OpenGL architecture and configuration on OS X, and the various APIs we can use in order to create OpenGL applications, specifically, CGL, AGL, Cocoa, (our old buddy) GLUT, and X11 APIs. A chapter focused into API interoperability is also included. But there is much more information in this book: history notes, a germane review of Mac's hardware, OS X programming, compatibility between Mac platforms, and a discussion about OpenGL extensions. Appendices contain an useful Glossary and notes about Cocoa API for OpenGL in Leopard. Last but not least, the book is the OpenGL/Mac companion we were demanding.

This, however, is not a book for starting to learn OpenGL (use the OpenGL SuperBible or the Red Book instead). This is a book aimed at two categories of programmers: Mac developers in general, and those with OpenGL foundations who want to explore the enormous benefits of OpenGL development on Mac OS X. I do strongly believe that any OpenGL developer will benefit of studying this great book.

Personally, Chapter 11 is the one I've enjoyed the most. The technical wisdom revealed in such chapter almost justifies by itself the full cost of the book. It's such a fine chapter. The almost 5 pages covering the "Axioms for Designing High-Performance OpenGL Applications" are very interesting, particularly the care we must have when doing our OpenGL drawing in Object-Oriented programs; we could easily incur considerable glVertex overhead, if our code is not properly structured. The little tutorial section "Putting It All Together" includes a detailed optimization of an OpenGL program, "Please Tune Me". Delicious. Very Recommended. ... Read more

Book Description
This is the only introduction you'll need to start programming in R, the open-source language that is free to download, and lets you adapt the source code for your own requirements. Co-written by one of the R Core Development Team, and by an established R author, this book comes with real R code that complies with the standards of the language. Unlike other introductory books on the ground-breaking R system, this book emphasizes programming, including the principles that apply to most computing languages, and techniques used to develop more complex projects. Learning the language is made easier by the frequent exercises and end-of-chapter reviews that help you progress confidently through the book. Solutions, datasets and any errata will be available from the book's web site. The many examples, all from real applications, make it particularly useful for anyone working in practical data analysis. ... Read more

Book Description
Part of the highly successful Shelly Cashman Series, this introductory book allows the user to write error free, reliable, and easy to modify COBOL programs right from the start. ... Read more

Customer Reviews (5)

A COBOL STANDARD
Used earlier of this text years ago and know many COBOL programmers who did the same.This later version is a nice update covering ANSI updates and taking into account new compilers and runtimes especially for Unix, Linux and Windows.A good, solid COBOL reference.

Great book for learning COBOL
I am finishing up my first semester of COBOL. I find this book to be a very good one, especially compared to the textbooks I've used for some other languages

COBOL is verbose, of course, and the examples in the book are quite long, but there's nothing stopping a person from experimenting with shorter programs.

The book could have done a better job just teaching some of the simpler things, 'Hello World', he does have a point in that review. But overall, it's an excellent book to learn how to code COBOL.

You might want to get another book or two on the basics, I find any book by Doug Lowe very easy to read and learn from. And Arthur Griffith has a 'COBOL for Dummies' which is very good.

But I believe you will find this book to be very useful though, like I said, it could have started a little simpler with some basic little programs for students to get a better taste of COBOL. I remember not being sure on a lot of things, but as I like to experiment, I just tried it until I figured it out.

Great transaction all-around
The transaction went quite smoothly.The shipping/delivery was most timely and the item condition was great too.Thanks!

MADNESS
"This book was developed specifically for a first course in structured COBOL programming. After completing this book, students should have a firm foundation in the concepts and techniques of structured program design and. ...should be able to solve variety of business-related application problems using COBOL."
I have to use this book for my COBOL course. The book is the mess. The book is for the students who never had any contact with COBOL; well, I don't have that feeling. The authors maybe know COBOL but they are definitely not the people who should teach others how to program with COBOL. They mentioned flowcharting, but they never explained flowcharting properly. In Chapter 2 they start with a large program and they try to explain it. Problem is that after few pages I didn't know what is what. Their approach is not to start with simple short programs that give introduction into programming that should help the student to develop, to learn different parts of program, they start with the max program and it is up to you to understand it or to drop it. In Chapter 3, Excersize 3, they ask the student to design and code a COBOL program that displays....
HELLO!!! You never showed me how to design and code a program and in Chapter 3 you ask me to do something. How to start, where to start?! How to design, how to code?!
Unfortunately, I have to use this book, but I am afraid that I will hate this book and COBOL because of this book.

A must for any COBOL programmer.
COBOL is a mature programming language and this is one of the best books and a superbtextbook. Structured Cobol Programming by Gary B. Shelly, Thomas J. Cashman andRoy O. Foreman was my book of choice as a COBOLinstructor. The chapters arewell planned with steady progress with verygood examples. Although new edition is required to cover COBOL Functionsthis book still remains at the top of my list. As an independent COBOLconsultant I find this book a good reference. ... Read more

Product Description
The rhythm within your PC, from BITs to beats. This book gives the average computer user and the conventional musician the opportunity to digitalize their creative ideas. ... Read more

Customer Reviews (12)

Trees and Forests
On a recent programming forum, a poster asked if he should code his program as one procedure like his boss instructed.He was, of course, greeted with polite howls of protest.Everyone offered (mostly) good ideas about how one should code if one is a beginner.After a while, I realized they all could be traced back to Elements of Programming Style.I pulled out my first edition and browsed it.Still the best book on style ever.Unfortunately, some of their suggestions, like minimize your use of GO TOs, have now been taken as so many commandments that many languages have now deleted them entirely.

Their use of Fortran and PL/1 is hardly a problem.Any competent programmer should be able to read the examples easily and understand the point of the example.If it is a problem for you, I'd suggest you start with an easier book and build up to Elements of Programming Style.The style of which, by the way, is modelled after The Little Book aka Elements of Style by Strunk and White.

Many rules still apply
I dare say many rules Mr. Kernighan preached almost three decades ago are still NOT followed by the programming community at large. For examples, "Modularize. Use subroutines." "Each module should do one thing well." and "Don't patch bad code--rewrite it." A widespread, bad practice of 90% of the programmers today is still writing functions that are way too long! And they very often keep modifying existing functions--inserting new logic into them--to make already bad code even worse; they seldom give it a second thought about rewriting the whole damn crap!

Another set of rules from the book: "Make sure code and comments agree." and "Don't over-comment." Many programmers seldom do the first thing, resulting in widespread mismatches between the actual codes and surrounding comments. This applies to Java code as well. The comment style recommended by Java--that is, mixing code and comments that can be extracted into so-called self documentation--is an outright violation of the "don't over-comment" rule. (This is intended to be a criticism of Java-style comments.) Good code should document itself clearly; with perhaps a little help from judiciously added few comments that are not self-evident from the code itself.

The book uses FORTRAN and PL/I code examples. There are things that no longer apply today. But the fundamental rules and styles are still well applicable today and in the future.

This book is the source of a well known debugging quote
I haven't actually read the book, or seen it in person, so I'd prefer to refrain from rating it one way or the other. It's worth noting though that this book is the source for an extremely well known quote on writing software:

"Everyone knows that debugging is twice as hard as writing a program in the first place. So if you're as clever as you can be when you write it, how will you ever debug it?"

People familiar with that statement -- it gets cited all over the place -- may be interested in looking at this book if only to see if there are any other gems inside. Chances are, the advice given may be a bit out of date in its particulars, but will have some persistent, deep, profound observations like the one above.

Some good rules for us all, still valid after so many years
I think this little book is still relevant today, over thirty years after it first appeared.

Yes, some people claim that computer programming is taught a little better today, and we all learn better habits.Actually, I'm not sure how true that is.People may be better at telling kids how to tidy up their rooms, but I've seen some rather messy rooms!

And people may say that FORTRAN and PL/I are absurd languages to use as examples today.I'm not so sure about that.As a programmer, you may very well see old and confusing programs written in either language, especially FORTRAN.And anyone who can program in more modern languages ought to be able to read the programs.

It's easy to read, it's still interesting, and it raises some issues of style that are worth thinking about.Strunk and White (The Elements of Style) is still worth reading.And so is this.

dated
well...mostly dated,
most programmers already follow most rules in this book already.
It as a 'must read' in the past,I understand, but not anymore ... Read more

Book Description
Given Perl's natural fit for web applications development, it's no surprise that Perl is also a natural choice for web services development. It's the most popular web programming language, with strong implementations of both SOAP and XML-RPC, the leading ways to distribute applications using web services. But books on web services focus on writing these applications in Java or Visual Basic, leaving Perl programmers with few resources to get them started. "Programming Web Services with Perl" changes that, bringing Perl users all the information they need to create web services using their favorite language.

"Programming Web Services with Perl" steers clear of the hype surrounding web services and concentrates on what is useful and practical. The book introduces the major web services standards, such as XML-RPC, SOAP, WSDL, and UDDI, and shows how to implement Perl servers and clients using these standards. You'll find detailed references on both the XML and SOAP toolkits, and learn when to use one technology in favor of the other. The book is rich with programming examples that you'll find useful well past the learning stage. And, moving beyond the basics, the book offers solutions to problems of security, authentication, and scalability.

Some of the topics covered in the book are:

HTTP and XML basics

XML-RPC and the toolkits

SOAP and toolkits

SOAP:: Lite

Using SOAP with SMTP and other protocols

Advertising and discovering with UDDI and WSDL

The REST methodology

The future of web services

"Programming Web Services with Perl" was written for Perl programmers who have no prior knowledge of web services. You can pick up this book without anyunderstanding of XML-RPC or SOAP and be able to apply these technologies easily, through the use of publicly available Perl modules detailed in the book.

If you're interested in applying XML-RPC and SOAP technologies to distributed programming applications, then "Programming Web Services with Perl" is a book you'll want to have.

... Read more

Customer Reviews (5)

relevant, practical and well-balanced
Programming Web Services with Perl is principally a book on implementing solutions using XML-RPC and SOAP in Perl. It also covers complementary and alternative standards such as WSDL, UDDI, and REST in some detail. And on the periphery, it finishes with a whirlwind tour of developing message routing, alternative data encoding within XML, security, transactions, workflow, internationalization, service discovery, extension, and management techniques and specifications.

The book assumes the reader will have the knowledge of an intermediate level Perl programmer. I.e., the reader is assumed to have a working knowledge of references, data structures, and object-oriented Perl. On the other hand no previous knowledge of XML, XML-RPC, SOAP or XML related technologies is required.

It should also be mentioned that both of the authors Randy J. Ray and Pavel Kulchenko are also the principle developers of the most popular XML-RPC and SOAP Perl modules: XML::RPC and SOAP::Lite respectively. That said, the book is not a soap box for the authors to tout the merits of their tools.

Rather, it is a practical book which starts with grounding fundamentals. Readers should walk away with a core understanding of XML-RPC and SOAP and not just a particular tool set for working with them. The authors examine the alternative XML-RPC and SOAP tools, illustrate how they are used, and give practical and even handed reasons why their modules should be preferred. Which comes down to issues of features, active development, support, and the amount of work required to code to a particular interface. They then settle down to a comfortable and thorough guide to XML::RPC and SOAP::Lite.

The topics and issues are illustrated throughout using real world web services. For example creating an XML-RPC client for O'Reilly's Meerkat news wire, or a SOAP client to covert use.perl.org's journal stream to RSS. Code is presented to the reader filtered down to highlight each particular issue as it is discussed. This is nice in that it avoids listing slight variations of the same code multiple times, but on the down side it can also leave the reader flipping back and forth to reassemble an example in their head. Full code for each example is provided in the appendices. And all of the example code may be downloaded from O'Reilly at [their web site].

All-in-all, the book is a thorough practical introduction to working with XML-RPC, SOAP and related technologies. When I started reading the book, I was a bit disappointed to see that it only covered XML-RPC and SOAP related services. When I finished, I was impressed with how very much information they'd managed to pack into so few pages.

And yet, I was left wishing there'd been a more through coverage of interoperability issues between other SOAP implementations and things like custom de-serializers. To be honest interoperability and de-serialization are mentioned, and the authors do an excellent job of referring the reader on to sources for continued reading on most other topics.

The book does an admirable job balancing content, length, and information density. Not to mention an excellent job delivering the information that will still be relevant years and not just weeks from the date published. Most of the topics I'd wished to see covered in more depth are those that are still developing and consequently most likely to become quickly dated. In short a well balanced practical guide to applying XML-RPC and SOAP to solve problems.

A "complete reference" is oh so hard to find...
And yet this book covers every aspect of web service development utilizing perl.As a long time user of the original Frontier::RPC2 module, things have come a long way, and with that greater complexity, the concepts have grown in scope considerably.This IS the book that you want to read if you REALLY want to understand SOAP and XML-RPC.From the XML DTD's to implementation code (either standalone applications or utilizing mod_perl) this book covers everything in between.In all it is a welcome addition to the O'Reilly family of Perl books.

Great intro to XML-RPC
As with all O'Reilly books there's a great intro to the technologies. They take you through how it works, not just how to deploy some code. When you get to the XML-RPC modules, they don't force a solution on you, but give a great tour of what's available and let you pick. For me, the highlight was the intro to Randy J. Ray's RPC::XML modules (he's also one of the authors). I've been fighting with getting the 'system.*' handlers hacked in with other aproaches and it was great to see someone had already figured out such a clean approach. (Which is something since Perl can get reeeaaal ugly!) This book has saved me many days of wasted development.

The book is worth it just for RPC::XML info
As with all O'Reilly books there's a great intro to the technologies.They take you through how it works, not just how to deploy some code.When you get to the XML-RPC modules, they don't force a solution on you, but give a great tour of what's available and let you pick.For me, the highlight was the intro to Randy J. Ray's RPC::XML modules (he's also one of the authors).I've been fighting with getting the 'system.*' handlers hacked in with other aproaches and it was great to see someone had already figured out such a clean approach.(Which is something since Perl can get reeeaaal ugly!)This book has saved me many days of wasted development.

The "Web Services" book I've been waiting for
Some time ago, I purchased a different book: "Programming Web Services With SOAP" (ASIN: 0596000952), and my feeling - and that of many others - is that it was very weak. A decent view from 30,000 feet, but it was not very helpful to a perl developer thrown kicking and screaming into a project requiring XML and the use of SOAP::Lite. "Disappointment" was the best way to describe it.

But *THIS* is the book that the other one should have been - it's fantastic. It is chock-full of real live examples *with code*, the introductory and explanatory material is excellent, and the writing style is simply a joy to read.

In particular, the reference material for SOAP::Lite is very much welcome: it was written by the author of the code.

Five very glowing stars for this book. ... Read more

Book Description
A guided tour of numerous software design methods, thisvolume collects into book form a variety of articles from P.J.Plauger'smonthly column Programming on Purpose which has been entertainingreaders of Computer Language Magazine for years. Topics span the gamut from how to be a softwareentrepreneur, the innards of floating point arithmetic, and the turbulentworld of software design methodologies, including structured analysisand data-structured design, why “bottom-up” design isn't alwaysfoolish, and why “top-down” design isn't always wise. MARKETS:For supplemental reading in an intermediate or advanced course onsoftware design methods or software engineering, and for practicingprogrammers, software engineers, and specialists. ... Read more

Customer Reviews (4)

Flawed but Potentially Useful
This book contains, in rougly equal measure, both valuable information and nonsense.

In Plauger's view, "a [design] method tells you what to do when you don't know what you're doing" (p. 63). This means that programmers need design methods because we do not always know what we are doing. According to this view, if we knew what we were doing, we would not need design methods. Stated a different way, we need one or the other, design methods or real understanding. What does it mean to know what you are doing? It means to have a complete and integrated understanding of the principles that apply in your field. With such an understandng one is able to choose an approach without the help of prescriptive methods. But this is a book about prescriptive software design methods. It is not primarily concerned with helping the reader to grasp the fundamental principles of software engineering.

The design techniques presented in this book are essentially rules of thumb that apply in specific situations. They are based not on precise facts but on a kind of "folk" wisdom of approximations and intuition. Plauger is certainly not alone in his approach to this subject, though he is undoubtedly more forthright than most. It is probably fair to say that a majority of popular books on software engineering treat it this way.

In his first essay, "Which Tool is Best," Plauger denounces "rigid thinking." But this notion is a red herring. He is really referring to blind faith, which is not thinking at all. One is not properly called "rigid" or dogmatic for one's intransigent belief that the earth is spherical rather than flat, assuming that one holds that view in a proper context, that is, with a full understanding of precisely what the words mean, in what senses they are used, and the body of background knowledge upon which their meanings rest. Real facts are categorically true and must always be held by "rigid thinking" with the proviso that they are also held contextually. The true principles of software engineering are in this category. By contrast, Plauger's programming methods derive primarily from intuition and rest on vaguely defined terms, approximations, and floating abstractions. As presented they can be neither understood in any full context nor properly integrated with the rest of one's knowledge. Without an understanding of their underlying principles these methods can only be applied in blind faith. What Plauger means by "rigid thinking" is simply a failure to recognize the proper scope of application for each technique. If one's views are based not on facts but on impressions and approximations, one must admit that they cannot be universally applicable. One cannot even precisely define their scope of application. But when engineers apply their methods in blind faith, they tend to just keep doing whatever has worked for them in the past.

Plauger's analogy of design methods with carpenters' tools sounds pithy but thoroughly obscures the real issue. Knowledge and physical tools are not equivalent. Both carpenters and programmers employ both knowledge and physical tools. Professionals in both fields need to understand precisely why their chosen methods are optimal in given situations, not merely approximately why they seem to work. Programmers do not need more flexibility in their thinking; they need a precise understanding of the true principles of software engineering, which do not change. A carpenter needs to know why a jigsaw is not the right tool for cutting a pane of glass, but this does not constitute flexibility; it constitutes understanding. In short, what we need is not memorized methods or practices but to know what we are doing.

Much of the philosophical content of this book is evidently aimed at upholding the implicit view that software design is much too complex to approach with plain, ordinary conscious reasoning. On page 12 Plauger tells us approvingly that many truths come "packaged" as precepts that appear to be mutually contradictory. He is essentially saying that he prefers not to untangle fallacious equivocations and context dropping; he would rather leave his understanding--and the reader's--muddled with apparent contradictions. In this and other passages Plauger evinces a Zen mentality by trying to demonstrate (fallaciously) that nothing is as straightforward as it seems.

Beyond these errors, which a great many writers about software commit, this book has its own unique flaws. Much of Plauger's rhetoric is clearly off the cuff. For example, on page 108 he mentions the acronym SAPTAD but says he has forgotten what it stands for! In many places he does not even seem to know exactly what topic he is writing about. It looks as though he chose a topic for the essay and then just started writing about whatever came to mind.

Despite these flaws, most of the design techniques in this book will be valuable to the engineer who understands the unstated rationales behind them. The nature and complexity of modern software problems along with advances in design methodology are such that these old structured design techniques are generally no longer useful for designing whole systems; but they have specialized applications within larger object-oriented designs. For example, often once a class has been specified, one must design one or more complex data transforms to implement its methods. Hence even modern programmers need to understand the principles of data structured design, and this book presents a thorough survey of its essentials. Nonetheless, the reader must seek out their underlying principles in order to ascertain their proper scope of applicability. And some of Plauger's ideas, particularly those associated with object-oriented techniques, are just plain wrong.

The first few mentions of object-oriented programming in this book are markedly antagonistic in tone. When Plauger finally gives in and decides ostensibly to advocate object-oriented programming, he attempts to trivialize it almost out of existence. He maintains that the popularity of object-oriented programming is mainly caused by hype but grudgingly concedes that certain object-oriented language features can be useful.

Plauger devotes essays twenty through twenty-two ("Abstract It," "Encapsulate It," and "Inherit It") to attempting to demonstrate that there is really nothing new about object-oriented programming, but he is attacking a straw man. It is clear that he does not understand, even on a rudimentarly level, what object-oriented design is. In "Inherit It," on page 199, he confuses the inheritance relationship with the class/instance relationship. Not only does he think an instance inherits functionality from its class, but he even thinks a function can be said to inherit the functionality of the primitive language types and run-time routines that it uses. He endeavors to demonstrate what he clearly believes--namely that object-oriented programmers merely attach fancy new names to existing concepts--but he only succeeds at showing his ignorance of object-oriented concepts.

Plauger also talks somewhat excessively about himself in this book. A significant share of its content is about the author, not the subject. The final essay, "Remedial Software Engineering" (p. 215), is nothing but a story about some of his teaching experiences, though he does not even seem to realize that he has not been expounding great truths about the state of the art. On the other hand, his self-deprecating remarks in the early chapters are tiresome. One finds oneself thinking, "If he's really so insignificant, why am I reading this?" As the book progresses his tone grows more authoritative. In "Which Tool is Best," on page 8, he says that he does not pretend to be a software engineer; but in "Remedial Software Engineering," on page 220, he claims to have successfully taught graduate students everything they would need to know in order to call themselves software engineers.

According to the preface, these essays were professionally edited for publication in the magazine "Computer Language," but Plauger went back to his originals and re-edited them himself for this book. That is unfortunate. A good editor could have enhanced the value of this book considerably. On page viii of the preface he also mentions "a certain colloquial illiteracy" that he finds "comfortable." This is certainly evident in the numerous occurrences of downright bad grammar that distract the reader's attention from the material. The effect is merely one of shoddiness. What excuse can a professional author of technical books have for not being "comfortable" with proper written English?

This book could have also benefitted greatly from the services of a good designer and professional typesetters. Here again, Plauger has chosen a do-it-yourself approach, and it shows. Some of the diagrams look like bad photocopies that are several generations old and almost unreadable. The typographical style, though not awful, is not up to the usual standards for technical books.

This is a book of classic "folk" wisdom from the age of structured and data structured design. It is valuable because it surveys many of the key design techniques from that era, and these are still useful to modern engineers employing object-oriented methods. Some of the insights in this book are very good. But one must read this book critically and be prepared to wade through irrelevant material about the author, to disregard flawed philosophy, and to ignore bad grammar and substandard typography.

Why is software design so hard?
Maybe because, unlike Plauger, most authors tend to advocate for their particular methodologies and do not really teach how to make the best use of the available design techniques. (Well, maybe it is just that way and it will never become easier. That's part of its charm.)

There are no silver bullets (that is, no "one-size-fits-all" method) and "we often cannot articulate why we do what we do when we do it." Plauger tries to address this problem not by proposing yet another silver bullet, but discussing useful design principles.

Despite some dated examples, Plauger's observations and advice are still relevant. You will find interesting essays on stepwise refinement, the use of grammars to parse input data, and structured design techniques.

If you think these are not "hot topics" today, pick this book just to enjoy yourself reading about "software design heresies" (apparently counterintuitive ideas), the authors' curious approach to teaching, or his peculiar comments trying to demystify [and even debunk the hype behind] object-oriented programming (written at a time when object-orientation was something completely new for the standard software developer.)

I'm sure you will not regret the time you spend reading this book.

A must have for any professional programmer
Definitely a must have. One thing to keep in mind while reading this book is that it is a collection of essays taken from Plauger's column in Computer Language. Mr. (or should I say Dr since he has his PhD) has an easy and enjoyable reading style. The book's main thrust is collection of design methods each with a specific purpose. These design methods are used at various stages of developement on specific type of problems typically faced by programmers. Thankfully, P.J. also provides an overview chapter of when these various design methods must be used as well as their strengths and weaknesses.

This is not an OO methods book. Although P.J. does mention OOP, he is not focused on this subject. However, he does remind us that abstraction, encapsulation, and inheritance existed long before OOT. While this is rather obvious, it is something many of us need reminding. This book convinced me that understanding pre-OOT design methods (i.e. structured analysis, data-structured design) would enable me to better apply OOT.

Although Plauger mentions near the end of the book that he is not a text book writer, I sure wish he would reconsider turning this material into a textbook. The essays are really good, but some lack enough detail to be applied strictly from the knowledge imparted in the essay. Plauger also cheerfully reminds us that there is no one-size-fits-all method to solving a problem and that sometimes experience might lead us to do things we previously thought we shouldn't. In the end, software development is still as much an art as it is anything else. Thanks Mr. Plauger for an excellent read.

Simple, powerful ideas
Few books I review get 5 stars. This is one of them. Programming on Purpose is a collection of essaysoriginally written for Computer Language magazine. Although the original publication of this collection was in 1993, the materials in the book date back considerably further. Are Plauger's observations and nuggets of advice stillrelevant? Absolutely.

When you read modern classics like Design Patterns (Gamma, et. al.) you might mistakenly think that such works are revolutionary instead of evolutionary. Going back and reviewing books like this should correct any such misconception. Here's an example:

In his discussion "order out of chaos", Plauger writes "When you encounter a situation where data is presented in chaotic order, but must be processed in some definable order, you have a sorting problem. Forget about data structures or structured programming for the time being. Instead, cast the problem in a form that can be handled by known sorting technology, then apply it."

In short, Plauger urges you to "see the patterns" in the problem. If books that purport to teach design patterns were so pragmatic and clear they might bemore successful! Plauger has many such clear, lucid thoughts, elegantly expressed. Here's another:

"My major concern here is the Principle of One Right Place--there should be One Right Place to look for any nontrivial piece of code, and One Right Place to make a likely maintenance change." Of course. Good OO design, indeed any good system design, should support this notion. Yet, how many systems and their designers do not?

UML design tools and other wizard-like code generators may produce the superstructure of our programs (under our design and direction, of course), but what goes between those curly braces often, if not always,dictates the final quality of our work. Plauger provides powerful insight into our craft that shouldn't be missed by anyone who codes for quality. ... Read more

Customer Reviews (17)

Informative
The book is good for beginners.All you need to know to get started with Unix/Linux programming.

A very useful reference
I bought this book in order to get an overview on what primitives I have available on a unix system for doing system programming. I found the book to be very useful for that purpose.

I use it occasionally.

I also found my peers lending it from me again and again.

To summarize: useful.

The best UNIX programming book that I know of
What's more to say, the title say's it all...Buy it!

Good Coverage
This is an exceptional introduction to Unix features that most people won't see in every-day programming. The feature that Rochkind starts with may be the most problematic: portability. There have historically been dozens of Unices (sp?), all slightly different from each other. Even today, there are a number of different implementations in use, with small but maddening incompatibilities between them. Rochkind not only addresses the more common ones, he shows the standards-based ways of dealing with their differences.

After that, Rochkind goes over read/write/open/close/ioctl again, dealing with [a]synchronous subtleties that can mean a 100x difference in performance, backed by code samples and timing measurements. The rest of the book deals with multi-process applications, including communication and distributed processing issues. That includes process groups, interprocess communication (with all its system-dependent weirdness), sockets, and signals.

This isn't for the beginner or for the kernel developer, but never meant to be for either. It is a good, readable introduction to protentially tricky parts of the Unix API. I recommend it strongly to anyone building their own library of Unix references.

//wiredweird

Just right
This book starts at the beginning, assumes very little, and takes you quickly to the essentials you need to know about unix. The text is clear but too verbose - you can actually finish this book, which I find important for programmers who want to get a sound introduction and then get to coding. The new edition is updated for modern unix-like systems. ... Read more

Book Description
Linear Programming and Network Flows, now in its third edition, addresses the problem of minimizing or maximizing a linear function in the presence of linear equality or inequility constraints. This book:
* Provides methods for modeling complex problems via effective algorithms on modern computers.
* Presents the general theory and characteristics of optimization problems, along with effective solution algorithms.
* Explores linear programming (LP) and network flows, employing polynomial-time algorithms and various specializations of the simplex method. ... Read more

Customer Reviews (11)

Very Theoretical but good fundamental and advanced techniques
The techniques described are very theoretical but are friendly to be used in Computer programs. Has a great deal of depth.

This book is only useful if you already know about linear programming.
I am using this book for a linear programming course.The most flagrant problem with this book is that it is filled with typos, making reading through proofs and examples very frustrating because you're never sure what is supposed to be written.The book is also not very good at explaining concepts and leaves many steps out in the development of new ideas.If you can avoid it, do not use this book to learn linear programming.

It Could be better
In my point of view this book has 2 related problems:

Problem 1. It tries to pack much information in a small space.

Problem 2. I dont like the author's style of asking why? and how? to the reader in the midst of the text. Maybe this is to keep the book small but it forces you to stop reading and think about the question.


However, I think this book is a good reference. But, certainly the authors could have made it better. Let's wait for the next edition.

Strong Graduate Treatment in Linear Programming
I used this text while taking a graduate linear programming (LP)course on LP and network flows.I really liked the treatment.The typesetting was clear ,consistent and easily followed (not as good as Nash and Sofer's).The book also includes lots of nice side discussion on how or why the theory is the way it is.Plenty of references are offered for further study.Proofs were not rigorous.The highly mathematical reader may be disappointed by the "show proof" style used instead of a rigorous theorem-proof style.In fact, I seem to recall a time or two where the theorem came after the usage.For me, I didn't mind that, but a pure math guy would likely grind his teeth.

The network material was acceptable.I personally thought the text problems were not of the best quality.I would suggest a teacher supplement their own favorites outside of the book.

One caution is that the book is somewhat aged.I noticed a text like Nash and Sofer seems to have newer updates on the theory.

Overall, a great read for getting into the nitty gritty details of LP.

Excellent but DENSE!!!!
I am currently working toward a Ph.D. in Management Science and used this book for a LP course.If you can get past the matrix algebra (which isn't too terribly difficult) you will find that this book contains more practical LP information than any other resource available.However, those looking for a "how to" book on linear programming might want to try a more elementary text first.This book is geared toward those interested in the more advanced computational aspects of LP (e.g., revised simplex method, LU decomposition, product form of the inverse, bounded variables, etc.).The chapter on sensitivity analysis is particularly well written and thorough.But beware, this book packs more info per page than I have ever seen!!! ... Read more

Book Description
Combining the Deitel™ signature Live-Code™ Approach with a new Application-Driven™ methodology, this book uses a step-by-step tutorial approach to begin teaching the basics of programming, builds upon previously learned concepts, and introduces new programming features in each successive tutorial. KEY TOPICS This comprehensive introduction to Java covers GUI design, swing components, methods, classes, data types, control statements, arrays, object-oriented programming, strings and characters, sequential files and more. It also includes higher-end topics such as database programming, multimedia and graphics, and Web applications development.For individuals beginning their mastery of Java Programming. ... Read more

Customer Reviews (5)

Not for serious programmers
This is a text book such as a high school or junior college might use to support a Java class. There are lots of excercises, the programs come quickly. But the book does a poor job of teaching the basic precepts of Java.

Wonderful introduction to java programming
I have been a mainframe developer for 16 years and very resistant to switch to objected oriented programming.Let me tell you something:"Simply Jav