Product Description
Literate programming is a programming methodology that combines a programming language with a documentation language, making programs more robust, more portable, and more easily maintained than programs written only in a high-level language. Computer programmers already know both kinds of languages; they need only learn a few conventions about alternating between languages to create programs that are works of literature. A literate programmer is an essayist who writes programs for humans to understand, instead of primarily writing instructions for machines to follow. When programs are written in the recommended style they can be transformed into documents by a document compiler and into efficient code by an algebraic compiler. This anthology of essays from the inventor of literate programming includes Knuth's early papers on related topics such as structured programming, as well as the Computer Journal article that launched literate programming itself. ... Read more

Customer Reviews (7)

Great Book; Easy, expedient Ordering
This is, indeed, a great book.I had read several reviews and decided to pick this one as my into to Literate Programming.I was not dissatisfied.This is a very good book and I love reading Knuth's works.I have all the volumes of his The Art of Programming (the original 3 volumes I got just before I graduated from Graduate School and have, in the intervening 35 years, found them to be a steady, reliable and wonderful reference...a great source of information.Knuth is a very accessible, readable author.This book on Literate Programming (a series of monographs by the author presenting) follows in the tradition and do not disappoint the reader who enjoys Knuth.

One of the things I most like about ordering through Amazon is their teamwork with a wonderful group of 3rd party suppliers.I have not been dissatisfied with any that I have worked through and this one was no excpetion.They supplier was quick and thorough in processing the order and, in my experience, live up to the fine standards that I have always had with Amazon and their partners.I am most pleased with the service and ease of ordring.

A book of historial value
This book is a collection of articles Prof. Knuth
wrote about programming. He promoted a particular
programming methodology called "literate
programming", which weaves comments into codes and
make them more readable and easier to maintain. This
book was published in 1992, but Chapter 4, "Literate
Programming", was originally published in 1984,
which was an idea way ahead of his time (JavaDoc was
first released in 1998, 12 years after the Knuth's
article). Chapter one is Knuth's Turing Award
lecture and still worth reading for his view on why
programming is an art. I was wrongly impressed that
Knuth is a very theoretical people and doesn't do
much programming. As you would discover from these
lecture and other articles in the book, he indeed
did a lot of programming and arguably in a very
clever and beautiful way, "the program of which I
personally am most pleases and proud is a compiler
I once wrote for a primitive minicomputer that had
only 4096 words of memory, 16 bites per word
(pg. 10)." The discussion about the "goto" statement
in Chapter 3 is not relevant in today's programming
and computer environment. The last few chapters are
more like manuals of the WEB and CWEB programs (C
version of WEB), which are the programs generating
documents and source codes. These manuals may not
interest readers unless they are well motivated to
write program "literally." One gem should not be
missed is is Chapter 10, "The Errors of TeX" (and
the accompanying Chapter 11, "The Error Log of
TeX). Seeing how Prof. Knuth meticulously documented
all of his bugs in TeX is just amazing. Overall this
book is more of historical value and for people who
love Knuth and his work on literate programming.

A fundamentally new view of programming.
This book is the only one that I can say has truly changed my view of software development.

The premise of this book matches my experience: technical communication with people is critical, and harder than communicating with the machines. Knuth carries that idea forward by one bold, logical step: in Literate Programming (LP), the main goal is to get technical ideas across to people. Programs are a co-product of the description process. This inverts the premise of JavaDoc and the like, in which human communication is incidental to the code.

A literate program, by the way, reads like a standard human document, whether an essay or an IEEE standard specification. JavaDoc output reads like an HTML dump of a cross-linked tree data structure - which it is. JavaDoc serves a valuable purpose, but does not permit system description in the order required by human reasoning.

My own experience with LP (a custom system) was very happy - I actually reached the "impossible" goal of true requirements traceability. I unified the system requirements, design, multi-language implementation, configuration control, and even tests under one document set. With HTML output, traceability was made real using interactive links. Anywhere else, traceability is mostly wishful thinking shared by the many owners of physically disconnected documents. (Process gurus - I hope you're paying attention.)

LP practice, however, has not caught on. LP, in today's form, does not support programming in the large. What LP does to the compilable form of a program brings C++ name-mangling to mind. I don't know of any WYSIWYG LP systems, so today's window-icon-mouse-pointer (WIMP) programmers will have nothing to do with it. And, ironically, the people who need the most support in communicating with their peers are the ones most resistant to tools for effective communication.

It's a grand vision and an exciting experiment. LP deserves more attention.

Web <> Javadoc
There's a common misconception that Webs are analagous to technologies like Javadoc. The latter is effectively a fancy prettyprinter. The former is that, and more. A well-written web actually presents a program in a way that makes sense to the reader while providing a means to make that program also make sense to the computer. The idea being that you would be able to write code that looks like: for(i=0; i@;} so that you can defer exactly what processing an array element entails until a point where it makes sense. Since these redirections are handled by a preprocessor, there's no cost at run-time for doing that like there would be if the code were written with a function call.

Arguing for an aesthetic appreciation of programming
Writing computer programs is easy, writing programs that are useful is hard and writing programs that are very useful as well as correct sometimes seems impossible. Knuth takes this truism even further and offers up theradical notion that the very best programs are so profound that people willone day read them as one would a piece of classic literature. If the ideaof curling up by the fire with a copy of The World's Greatest Programs andspending the night in a state of rapture seems absurd, you think as I did.However, after reading this book, my mind now concedes the possibility doesexist. After all, most of the great works of literature describe actions,conditions and solutions (algorithms) to problems of human-human andsometimes human-god interactions. Science fiction writers and readers haveknown for a long time that computers are very interesting objects.Buildings, paintings or other works of art are often admired not only fortheir subjective beauty, but also for the talent that it took to createthem. Programming ability can be admired just as easily.
However, anextremely large technical barrier exists, in that programming languages areliteral, terse and lack flair. Knuth works to eliminate this problem bycombining the programming and documentation languages into a structurecalled a WEB. He also adopts the reverse paradigm that a program should bean explanation to humans of what the computer is doing. The result doeswonders for readability and introduces a bit of flair. Certainly, this is agood first step towards Knuth's ideal.
The development of TEX ischronicled in great detail. It is personally comforting to read about someof the errors made in its development. Learning that the great ones makeerrors provides emotional security to all who hack for fun and/or profit.Some classic programming problems are used to demonstrate exactly whatliterate programming is meant to be. Jon Bentley, author of the`Programming Pearls' section of "Communications of the ACM", contributestwo chapters that were co-authored with Donald Knuth. These pearlsdemonstrate the applications of literate programming to common codingproblems. All are presented in a clear, easy-to-understand style.
Abit of clever humor is also used. A WEB program is constructed from twodistinct components. The Weave part explains what the program is doing, andthe Tangle component produces the program. Of course, this suggests theline from Sir Walter Scott's poem Marmion, "O what a tangled web we weave,when first we practice to deceive."
I do not know whether to considerthis book the product of a dreamer or a visionary. The truth, like most ofthe work of pioneers, is no doubt somewhere in between. My opinion is thatit is more vision than dream. And is that not a common theme among thegreatest works of art and literature?

Published in Mathematics andComputer Education, reprinted with permission. ... Read more

Product Description
C# is Microsoft's hot new language for the .NET platform. This book covers everything C# programmers need to know to create network applications, a task traditionally done in C++. It explores the basics of network programming, including IP and TCP protocols, and moves on to targeted C# instruction, including using the C# network programming classes in the .NET framework. Topics covered include low-level network programming (such as sockets and multithreading), as well as network application layer programming for email, web-based, and security applications. Specific examples show how to create applications that use network protocols such as SNMP, SMTP, and HTTP. The book also has advanced coverage of incorporating an Active Directory server database and .NET remoting in a network application. Author Richard Blum has been a network and systems administrator for 13 years for the Department of Defense and is the author of four books on networking topics. ... Read more

Customer Reviews (17)

Great for begining of SNMP Programming
This is a great book for begining of SNMP programing. It focuses on the basics but not deep.
for example , in SNMP chapter, it discusses Get PDU srtucture in detail (and that was very great because I've never seen like that in other books or articles) but there is nothing about set PDU or Trap.

OK for a sys admin
This is a good book if you are a systems admin (like the author) wanting to write simple network programs in C#.However, the author has a very limited knowledge of .NET programming.In most of his numerous code samples, his ignorance of CLR fundamentals shine through.For instance, on page 192 he has these lines of code in the VarTcpSrvr.cs listing:

byte[] datasize = new byte[4];
datasize = BitConverter.GetBytes(size);

The first line of code creates a new byte array named datasize on the managed heap.Then the call to BitConverter.GetBytes(...) returns another byte array and stores the reference in datasize!The first byte array will now be garbage collected, as it is no longer referenced and was never used in the first place.The book is filled with code examples like this.

If you are a professional developer, the book doesn't have much to offer, as you will likely already know nearly as much as (if not more than) the author.Not to mention, seeing all the poor coding samples will likely become a distraction.I still give this book three stars because the networking content is good and the code samples do, in fact, seem to work.They just happen to be coded poorly.Since the author doesn't really understand the platform he's coding on, approach with caution -- especially if you are a beginner.

Very good book
if you allready have some c# experience this books is the next step u need for jump into the network programming... the books compile the 99% on vs 2005 and the examples are clear, they left no doubt when you are reading, if you want to invest some money on learning this is one way you can do it.

Highly recommended
I used a number of books as references for a server project in C#, including the "TCP/IP Sockets in C#" book referenced in another review, but that book is more geared toward academic use (though to his credit I emailed one of the authors of the book regarding multithreading issues that were not addressed in print and he was very responsive, so I support the purchase of that book to round out your sockets library as well). Blum's book provided far more practical advice relating to my project and was the one I consistently returned to for reference. I had an issue not addressed directly in the book, did a Google search on it and found the answer...by the book's author in an online discussion forum!

In short, it is virtually impossible to find a book that addresses every last real-world gotcha inherent in starting any new project with a new language and class library as vast as .NET's, but if you have a C# sockets project to do then I can't recommend another book more than this one.

Doesn't go deep enough into the real issues
This book is a good introductory book to network programming in general. While it attempts to cover all the general topics that you can find in reference books like "TCP/IP Illustrated", it seriously lacks the breadth and depth of such reference books and falls short of tackling the real issues of Network Programming with the .Net frameowrk in C#.

The .Net framework and the C# language bring some new design patterns and some paradigms that are definitely different from what we used to see with C/C++ or Java and I found that this book while containing a lot of source code examples in C# lacks coverage of such patterns and the .Net way of solving issues like high performance multi-client servers, performance oriented data handling over network connections, multi-threaded network applications design patterns in C# and .Net framework,...

In summary, if you are new to C#, .Net and have never programmed network applications in another language and are looking for a book that covers a lot of subjects, this is your book. If you already have the TCP/IP Illustrated books and want an advanced book about how .Net and C# apply to network programming, I recommend "TCP/IP Sockets in C#", a much smaller book but extremely focused on what the title says!
... Read more

Product Description

No prior programming experience necessary!

Absolute Beginner's Guide to Programming helps readers understand what programming really is. Readers not only get an overview of the job of programming, but also learn which specific skills are needed for certain jobs.Coverage includes how a computer interprets a program's instructions with insight into what goes on "under the hood" when a computer runs a program, how programming can and does relate to the Internet and the skills required for adding security to programs, and compiled versus interpreted languages like JavaScript and HTML. Absolute Beginner's Guide to Programming offers "hands on" programming for the "absolute beginner". Though there are hundreds of books for beginners about specific languages, this is the only book that takes today's programming environments and explains why each is important and where each works best.

Customer Reviews (7)

Great for Beginners
This is the 5th book I've bought that claims to be for "beginners" and this one actually is. He starts from the basics and slowly works his way up & he does it in a way that doesnt make you feel stupid. It's a great book for beginners so don't listen to everyone else...

I have Visual Basic 2005 & I followed along just fine. Since he's teaching the basics there isn't going to be much of a difference. Secondly, I could care less about his personal life or what he has posted on his website... The idea here is to review the BOOK.


Go buy it... It's worth it... Trust me.

There is a Problem but Book Remains Excellent
There are some complaints about the fact that the 3rd edition (2003) of "Absolute Beginner's Guide..." relies a lot on Microsoft Visual Basic 6.0 Working Edition.This is a real problem since it is not available. However, I do not agree that this makes the book useless after chapter 5. Certainly, Perry should write a 4th edition that either includes Visual Basic 6.0 on CD or uses an available language. You can skip chapters 5 through 11 and still gain a lot from 1 to 4 and the rest of the book from Part IV on. Perry's coverage of Algorithms, C, C++, Macro, Batch, Scripting languages, Internet concepts, HTML, XML, Java, maintenance & the Programming Business are superb and well worth the price of the book. You can learn Basic from another excellent beginner's book "Beginning Programming for Dummies," by Wally Wang.

I would ignore the two recent comments by goof balls who do not talk about the Perry book but about what they think Perry's political views are. I mean, what sane person cares what Perry may think on his own time? His knowledge and excellent skill at teaching programming is what matters in any review of his books.

Oscar Wild was rumored to wear panties to bed. Does that stop the narcissists from reading his plays or his novels?

--J

where do you get the software?
this book is great for learning how to program...if you can get your hands on the software. Visual basic 6.0 working edition is the model for the majority of the text and the author offers no way to get it for free, which means you have to buy it seperately. I would suggest getting a book that has the programming languages you are going to use included on a cd.

Author a right-wing nut!
Please read this web-site created by author before purchase:
www.gregandjayne.com/GregsCorner.htm

I Wish I Had Known
The book lives up to its title in terms of being an introductory guide to programming, but what I didn't know was I had to have the specific program "Visual Basic" as well to get beyond chapter five. This revelation left the remaining 19 chapters of the book of no value to me at all. I do have "Visual Basic.Net", but it's way too much of a process to try to convert from one program to another and learn how they work at the same time. ... Read more

Product Description

Product Description

By using the same back-end macro programming language, Visual Basic for Applications (VBA), Microsoft Office applications allow users to easily transfer their VBA programming skills from one Office product to another. A developer skilled at using VBA to program Access can quickly learn to program Word or Excel. Better still, VBA is a fairly complete subset of Visual Basic (VB). That means a VB developer already knows how to use VBA, and a VBA programmer knows a lot about VB.

Author Rod Stephens gives you the most valuable information possible as quickly as possible without rehashing the trivial VB and VBA details you already can recite in your sleep. In Microsoft Office Programming: A Guide for Experienced Developers, Stephens skips the tiresome explanations of variable declarations and dives right into serious Office programming topics, such as automatically customizing menus and toolbars with VBA, making OLE do your work for you, and using ADO to manipulate data in an Access database.

Customer Reviews (2)

Mix and match MS Office
This book is the book you need to get you going when you want to use two or more office applications in your own home brewed apps.This book doesn't drag you through learning the basics of VBA but,takes you straight to the meat and potatoes of office development.Shows you the differences in the object models and ways you can use those differences.

It helped me restructure a few access applications to add value and greater functionality to them in my organization.I learned how I could use Excel as a report writer using preformated workbooks and the same with Word.If you want to know more about meshing office apps together without reading through material you already know then this is the book you need.

If you're not an Idiot or a Dummy
Microsoft has done an excellent job of integrating its Office suite of products. So if you are familiar with Visual Basic for Applications (VBA), you can use it to programmatically perform tasks within each Office product, like Excel, Word or Powerpoint. Or, within one of these products, you can write an application that can invoke an instance of another program.

Within one book, Stephens shows an efficient and unified way to learn how to do all this, and more. The trick is to be able to use VBA as a macro programming language. This is the key to understanding and using MS Office as a coherent entity. Ultimately, Stephens suggests that it is quicker than learning how to program each product on a case-by-case basis.

Stephens cheerfully dumps on other texts that call you an idiot or dummy. (If you know what I mean.) He unabashedly expects you to be conversant in VB or VBA. To be specific, he doesn't waste time going over the elementary syntactical points of VBA. So you don't have to thumb through these pages in idle frustration. He drags you rapidly into non-trivial coding explanations of how to use VBA to get at MS Office. ... Read more

Product Description
This textbook offers a deep understanding of the essential concepts ofprogramming languages. The approach is analytic and hands-on. The textuses interpreters, written in Scheme, to express the semantics of manyessential language elements in a way that is both clear and directlyexecutable. It also examines some important program analyses. Extensiveexercises explore many design and implementation alternatives. ... Read more

Customer Reviews (17)

very methodical and simple
its really a nice book to start with functional programming and thinkin in terms of recursion. you can easily write a cool interpreter by following this book cover to .... doesnt explain lambda calculus and combinators in much detail though

Good balance of formal and layman language
I enjoyed this book's implementation-oriented approach to teaching language constructs, in the tune of such classics as SICP. The book title is misleading in that this book focuses almost exclusively on functional languages. But within that realm, it admittedly does cover a broad range of features. The book has just the right amount of formal notation to insure relative completeness, but not so much as to scare away unfamiliar readers. I think it's a nice gentle introduction to the whole field.

As I alluded to, the only reason I didn't give this a 5-star is the slightly misleading general-purposeness appeal, even though it really is entirely functional-oriented. Other than that, the book was a great read.

An Almost Perfect Book
This book is invaluable to someone who is trying to understand how computer languages really work.

The Good
1. Very comprehensive .Covers a whole gamut of programming language features.By the time you finish the book you will have built interpreters which demonstrate recursion, call-by-value/reference/need and name semantics, class based and prototype based OO, type inference ,Continuations etc .

2. Very "Hands on" . You are taught how programming languages work by actually building intrepreters (in other words an Operational Semantics is used) .This is the best way to learn .

3.Environments and Continuations are explained extremely well.

4.Lots of exercises which explore design alternatives . For example the main flow deals with lexical binding of variables, with dynamic binding left as an exercise.

The Bad
1. A certain knowledge of scheme (let letrec, cond) etc is assumed (The First edition was better in this respect and was more self contained)

2.The writing is sometimes unnecessarily dense with long sentences and slighly disjonted paragraphs.

3.some essential features of a language design (eg: memory management ) are skipped entirely.While this is understandable from the pov of reducing the length of the book, it also means that one needs to read supplementary material before one can write real life interpreters.

4.Some parts of the interpretation/compilation process are skipped entirely or treated through "magic". For example the book provides practically no explanation of lexing or parsing and some "magic " code (SLLGEN) is used .The examples for using this framework are thoroughly inadequate.It is better to skip using this framework and just use list syntax and the read functionality of scheme .

Summary

With all its faults (which will probably get fixed in the next edition ) this is an incredible book and should be part of the library of every programmer interested in learning how languages work. As far as i know there isn't a single other book that can do better in conveying how various features of languages really work and interact .

While this book may not be suitable for an undergraduate course of study(withoout an excellent teacher to help students get ove r the difficult bits) it is ideal forthe self taught programmer .

If you don't mind reading extra material/browsing the web to supplement this book, just buy it.

Be sure to have your dictionary on hand while reading...
I honestly don't understand why professors choose this book to teach programming language concepts/semantics.The best books to learn from are written in simple, easy to read language, and with a well-designed index.EOPL lacks both of these attributes.

As a part of the class we had to take reading quizzes on each section, meaning we had to read this book cover to cover.Friedman used complex, difficult to understand language to teach concepts that themselves were difficult to grasp.To make matters worse, the professor simply read from the book during lecture, failing to clarify the mysteries created by Friedman.

An optional book for the class was Programming Language Pragmatics.It explained the implementations of Object Oriented languages, type checking, assembly, etc. using multiple languages people have used before, unlike scheme.I would suggest looking at that book before choosing EOPL.

excellent
I had a lot of fun going through the book and following the steps to build an increasingly sophisticated language interpreter.
Now if only I can get a job writing scheme/lisp code, I'll be all set. ... Read more

Product Description

Customer Reviews (65)

Required reading for serious .NET development
I read this book several years ago and have since returned to it every two years or so for a light re-read.I consider it a member of a very small group of elite .NET development books and often recommend it, along with "CLR via C#" and "C# in Depth", to young .NET developers looking to take the next step in their careers.

A great conceptual\cookbook reference for any intermediate .NET developer
I think of this book as a cookbook without the fat, or a concept book with some meat.The book discusses topics that are often glossed over in introductory books; exactly the types of things that a responsible .NET developer needs to understand to write efficient and stable .NET applications.

Can be considered a general, concise book on Software Programming...
Microsoft technology has generated some really good books on software programming over the years.This book is definitely one of them.The difference between this book and the others may lie in the fact that it is published by O'Reilly.This book is devoted to the latest Microsoft technology, but it is really a book that explains the basic principles behind all software programming.

You can read this book and substitute any other language, for example Java, to implement the principles elucidated.Of course, the set of software principles is much vaster than in this book, but there are not too many tomes that concisely and clearly explain the fundamental principles that have to show up in any software application.

And it also shows how elegant a job Microsoft has done with DotNet to implement these ubiquitous principles and make their usage incredibly easy.After the pain and torture of their earlier technology (eg. COM), this shines in contrast.Took me back to the joys of programming in plain old Basic and Visual Basic once upon a time.They must have done something right when the open-source advocates jump to implement their own version of DotNet.

.Net on Steroids !
A Classic Book that begins it's journey, where all books end. The true difference between a casual programmer and a disciplined programmer is more prominent in his/her code when they start using advanced features of the framework. A true programmer knows his stuff in and out and knows how to leverage the features of the framework effectively in every line of code. And to get to that level of proficiency it takes reading and practicing the concepts on daily basis. And if at all, there is any book out there, that will help you, then it is this book. A definite YES. 5 Stars.

One Of A Kind On .NET Components And C# Programming
Without any second thought I will place this book among the best books on the subject ever published. I hope everybody will agree that there are only a few books that worth reading from the beginning to the end without skipping a page. To me this is one of those rare books.
The author manages to reflect on broad architectural concepts and yet be extremely specific. He was able to present the most complicated aspects of component oriented programming and the C# language in a very simple, yet concise manner. Many complex issues that may turn off even experienced programmers are described in a way that not only are very well understood, but could easily be migrated into a working program. The author has found an absolutely perfect balance of presenting general architectural aspects of the subject he is discussing and real life implementation techniques.
I truly believe that anybody who is dealing with such aspects (to name but a few) as serialization, asynchronous invocation, multithreading, reflection, events, delegates, deterministic finalization, etc., MUST read this book.
By the way, this author has published another wonderful book on Windows Communication Foundation - "Programming WCF".
... Read more

Product Description
This book develops the object-oriented programming skills of experienced programmers (at the Junior, Senior or above level) by teaching you how to use Java 2 (the latest release of Sun's Java platform), and providing a complete understanding of the philosophy behind Java 2. It starts out covering the language-independent concepts that are at the heart of the Java world, and then moves on to introducing Java through several example programs. Following this is an in-depth discussion on inheritance and polymorphism. Finally, the book concludes with material on important features of Java that are not object-oriented.

Features

Teaches students why the Java language works the way it does, as opposed to simply how it works

NEW! Chapter on Network Programming

NEW! Chapter on Java 2 - the most recent version of Java

NEW! Material on pure polymorphism

NEW! Appendices on Java Operators, Java Escape Characters, Java API, and Java Syntax ... Read more

Customer Reviews (4)

Great Book on Learning OOP for Intermediate Programmers
Don't buy this book if you're a beginning programmer or need to learn the syntax.I suggest learning that from the web.

Budd has a way of explaining OOP that made it much clearer now even after hearing it explained at least a dozen times to me.The examples are solid and not silly.

One of the good books for understanding OO concepts
Though Mr Budd's language is a little abstract but he has presented theideas to understand Object Oriented Concepts very good. This book is notfor starters rather persons having little knowledge of object orientationcan benefit from it a lot. I think this book is not a basic ratherintermediate level book for understanding object oriented programming.Overall this is a good book and must be kept for reference purposes.

A book to better understand object oriented programming
This is not a book to learn java from, nor is it even a good reference. Read and understand the title before buying this book.

This review refers to the previous edition to this one.

I found the text ordered well, withmost examples clearly explained. There were some minor bugs in the codewhich a beginning java programmer would struggle with.

After finishingthe book, and running the examples, and working through several of theexercises, I found that I understand OOP much better, and of courseunderstand java better too.

I've noted several people who don't know javasyntax are frustrated by the book, as they are expecting to learn java fromit, and are never reaching the point where they will learn OOP or java fromthe book.

In conclusion, don't buy the book to learn java, buy it only ifyou need to learn OOP and are having difficulty doing so.

Mediocre for learning OOP, terrible for learning Java
If you bought this book hoping to learn Java, prepare yourself for a convoluted mass of unrelated code and disorganized presentation of Java concepts.A language as horrible as Java requires quite a bit more background and basics on the tricks and traps of the language than thisbook provides, especially for those of us gifted enough to have learned Cor C++ first.My advice for those wanting to learn Java is to get SamsTeach Yourself Java in 21 days; it is so much more thorough and complete,especially with important topics such as the AWT and Java eventmodel.

Considering the OOP side of it, the book was actually quitecomplete and thorough--assuming you are well grounded in the basic conceptsof object-oriented programming first.Like too many OOP books, it iswordy, far too abstract, and chock full of all the annoying buzzwords andlingo that characterize the paradigm.If you are making the transitionfrom structured programming to object-oriented, C++ is almost certainlybetter than Java, for Java forces you to program OOP.A C to C++transition book is likely just what the doctor ordered. UOOP is not.

Andhow would I know all this?My object-oriented programming class used thisbook. ... Read more

Product Description
Step-by-step instructions, covering all the hottest techniques for creating dynamic games and interactive graphical environments using Java 1.1.

• Covers all the essentials of Java for graphics and game development
• Shows how to write interactive video games for the Web, playable by millions around the world
• Presents unique networking techniques for multi-user environments
• CD-ROM contains complete Java source and byte codes to the class libraries and games developed, plus games, third-party applets, and development tools

Customer Reviews (30)

Java not a solution...
I was given this book by a friend, who received it from a friend, who received it from a friend.Now I'm going to give it away too, because it's useless.We are all professional programmers and two of the friends who have owned this book are now professional game programmers (using C++).We were hoping that this book would prove java to be a great way to code games for other platforms, but it doesnt even come close.If anything it's proved that java is not a game programming option.

The book itself is a good intro to java programming, but the game examples are just too basic...so basic that you dont even want to look at them.I have a stack of commodore 64 game programming books with arcade games written in line basic that would put this book to shame... with only 32k of memory.Dont even get me started on the speed.The best game in the book is "javaroids" but it's choppy on my p3-500 with 512mb of ram. It doesnt matter though because it would be a challenge to want to play it for more than 10 seconds,especially in a 200x300 window, and I *love* asteroids and classic arcade games.How sad.

Whats java good for? Moving data around between servers... but not games.If this book is offered to you for free, think hard about it but then decline.

Hopelessly, hopelessly outdated.
The Java world has passed this book by.Black Art is based on
a completely outdated version of Java.It amazes me that this
book is even still on the shelves.I am a professional Java
developer and I simply cannot recommend a book that relies on
obsolete technology like this.

Good for an introduction to Java game programming
This book was generally very good.It suffers in that it is very old for a programming book and uses a lot of deprecated Java API.It also barely touches on some essential topics such as MediaTracker (for example, how do you implement a load bar for your game?) which is important for most games which will be played over the Internet.But it does have some very useful sections and will hand-hold you through building a 2D game.It also discusses how to build multi-player Java game applets, a topic I haven't seen discussed anywhere else.If you are new to game programming or game programming in Java, this book is an excellent source of information.

old and outdated...true...but don't let that fool you
this book is pretty old, but if your a beginner to both game programming and java then there is no other better book than this...it will teach you about classes, interfaces, inheritance...and all the while making it fun and iteresting... you'll develope little games along the way and learn about some simple AI too...so old and outdated...true...but worth every penny!!!

This book rocks!
What a great way to learn java!I read several boring java books and made little progress until I picked this one up.Games give you a visual way to understand OOP and learn java without falling asleep.I'm not done with the book yet but so far I've had no problems compiling or running with jdk1.3.And because this book concentrates on applets its a great book for web developers like myself.You won't find many new books on applets anyway which is ashame.Yes, 1996 is an old book but many of the lesson's learned are timeless.Lots of good examples if you are a visual learner like me. ... Read more

Product Description
With every new volume, the Game Programming Gems series continues to provide a road map through the vast array of development challenges facing today’s game programmers. With the wisdom of many industry experts, Gems 5 includes 62 newly unearthed gems that were polished up for your reading pleasure. These gems are filled with practical insights and techniques that will solve your current problems and help inspire future games. You and your team need to develop for today’s platforms, while preparing for the new technology looming on the horizon and with the tools provided here, you can! So dig into this new collection and put it to work.

SECTION HIGHLIGHTS:* GENERAL PROGRAMMING: parsing text data in games, using templates for reflection in C++, a generic pager, CSG construction using BSP trees, building Lua into games* MATHEMATICS: geometric algebra for computer graphics, minimal acceleration hermite curves, minimal numerical approximation, oblique view frustums for mirrors and portals* ARTIFICIAL INTELLIGENCE: fast target ranking using an AI potential field, parallel AI development with PVM, beyond A*, Dynamic A star, cover finding with navigation meshes * PHYSICS: aerodynamics for game physics, realistic cloth animation using the mass-spring model, pressurized soft-body model, realistic camera movement in a 3D car simulator* GRAPHICS: dimensional impostors for realistic trees and forests, gridless controllable fire, explosion effects using billboard particles, gemstone rendering, procedural level generation* NETWORK & MULTIPLAYER: keeping an MMOG online & persistent, seamless world server, a vulgarity filtering system, remote procedure call system, safe random number systems* AUDIO: multithreaded audio techniques, sound management by group, using 3D surfaces as audio emitters, reverb based on feedback delay networks, single-speaker speech recognition

ON THE CD-ROM: The CD-ROM is packed with source code and listings from the book and demos to compliment the articles. Windows demos were compiled using Microsoft Visual C++® 6.0 (.dsw files) or Microsoft Visual C++ 7.0 (.sln files). OpenGL® utility Toolkit (GLUT v3.7.6), Sun’s J2SE™, and Microsoft DirectX® 9 SDK are also included.

SYSTEM REQUIREMENTS Windows®: Intel® Pentium ® series, AMD Athlon or newer processor, Windows® XP (64MB RAM) or Windows® 2000 (128MB RAM) or later required. 3D graphics card required for some sample applications and DirectX® 9 and GLUT 3.7 or newer required. Linux systems require the Linux kernel 2.4.x or later, XFree86 4.0, and OpenGL driver, glibc 2.1 or newer. Mesa can be used in place of 3D hardware support. Videos require the DivX codec. ... Read more

Customer Reviews (2)

Satisfied with this Purchase
I originally purchased this book to gain insight into solving a specific issue I was having after fruitlessly combing the internet for answers.

While the article I originally purchased the book for didn't really help me as much as I had hoped, there is nonetheless a wealth of other information in this book that may prove to be useful to the budding game developer.

Most of the info in this book could probably be obtained by searching the internet, but it's nice to have it all in one package.

Also note that since this book was published in '05, some of the info may already be somewhat outdated, especially those articles pertaining to graphics hardware techniques, which a significant portion of the book is devoted to.

62 Hints & Tips for the Intermediate/Advanced Programmer
Intended for the intermediate to advanced game programmer, this is a book that will literally have something for everyone. It contains sixty-two 'gems' that is, articles on how to some particular aspect of game programming. Sophisticated game programming is probably the most complex programming there is. And this book goes into some pretty sophisticated programming details.

For instance:
4.2 Dynamic Grass Simulation - Just how does grass move when the wind is blowing
5.7 Rendering Gemstones - you can see through them, you can see highlights
5.2 Let it Snow - And how does the appearance of snow change if you are moving through it.

There is no question that the main driving force for faster computers is to make for more realistic gaming. And the faster computers allow more sophisticated programming to be done to make the grass wave realistically.

This is probably not a book you're going to sit down and read from cover to cover. You'll probably scan through and read the ones that are applicable to just what you need to do next. But then in a couple of weeks, in a couple of months.... ... Read more

Product Description
Focuses on the time and cost for developing each user story and determining its priority, and planning software releases accordingly. Covers such topics as outsourcing, making changes to the team, dealing with bugs, and working with business contracts. Softcover. DLC: Computer software--Development.Amazon.com Review
The Extreme Programming (XP) paradigm has developers doing things like programming in pairs, writing tests to verify all code, and continuously refactoring designs for improved performance. Written by two of its inventors, Planning Extreme Programming shows you how to implement XP by using a simple, effective process. This remarkably short (yet remarkably useful) title will give any XP manager or programmer a perspective on delivering software that meets the needs of customers better.

Simplicity is the watchword of the XP software process. This book is virtually devoid of traditional software-engineering jargon and design diagrams, and yet does a good job of laying the foundation of how to perform XP--which is all about working with a customer to deliver features incrementally.

The terminology in the book is commonsensical. (In the terms of XP, each iteration adds certain new features, or stories. It's up to the customer to decide what functionality is more important and will be delivered first. By never letting a working build get out of sight, the XP process virtually ensures that software will be close to what the customer wants.)

Early chapters borrow analogies from everyday experience--like planning a trip or driving a car--to set the stage for XP process planning. The book has plenty of advice for dealing with the stakeholders (customers) of a project. Because of confidentiality agreements, however, we don't get many details from the real world, although the discussion is anchored by a hypothetical project for planning the Web site of the future for travel, with some specifics.

There is plenty of advice for planning projects, based on individual and team "velocity" (a measure of productivity) and the like--practical suggestions for running daily, short status meetings (in which all of the participants stand up, to keep them short). Clearly, there's a culture that surrounds many XP teams, and this text does a good job of conveying some of this to the reader.

At fewer than 150 pages, Planning Extreme Programming is notably concise, and that's probably the whole point. Most shops today work on Internet time, which doesn't wait for extensive project analysis and design documents. In XP, you create working software from the very start. This book is an essential guide to anyone who's working in XP shops or who might be interested in what this innovative, iterative software process can offer. --Richard Dragan

Topics covered:

• Introduction to planning
• Risk management in software
• "Driving" as a metaphor for software development
• Roles for software development: business vs. technical people
• Four variables for project planning: cost, quality, time, and scope
• Predicting future programmer productivity, based on past performance
• Project scope and estimation
• The XP process: software releases, iterations, stories, collecting, and writing stories (features)
• Hints for ordering features
• Tips on planning and status meetings
• Using visual graphs to monitor project progress
• Tracking and fixing bugs
• Project red flags

Customer Reviews (26)

Objective overview of XP planning
Using a very objective and simple approach, the book presents the xp way of planning ina very easy and enjoyable way. It does not contain much practical advice, but it is an excellent starting point for someone who is not familiar with xp and its practices. After reading this book one should definitely look for "Agile Estimating And Planning" from Mike Cohn. It contains a more thorough approach on the subject.

Begin Your XP Journey Here
Well, I had been tentative about spending time investigating the meaning of "Extreme Programming", based primarily on what I consider to be a name that smacks of jargon, and because I thought that the audience for this development approach was young hip gamer-types who wanted to develop business applications!I now appologize to those who synthesized the techniques (although I still consider the name to be unfortunate, sorry).I am optimistic that this approach to development will solve many of the problems that I have faced over the years, and that this solution is much simpler than I could have dreamed of!This book is just 130 pages, and the techniques are clearly, succinctly, and I think expertly described by Kent and Martin.The level of humor is good, and the practicality of the solution is clear.

crackles with ideas and fleshes out more of XP
Kent Beck and Martin Fowler have to be something of a "dream team" for a computer book. Not only was this book informative and interesting, but I actually enjoyed reading it. The book crackles with ideas and sparkles with a subtle wit.

The content of the book covers all aspects of planning, managing and tracking progress on an XP (Extreme Programming) project and is a worthy companion to Kent Beck's anthemic XP Explained. Hard stuff missed out from the earlier work such as how to estimate how long things will take, how to write user stories and how to organize the details of iterations and releases is explained in a straightforward way. It also introduces a few new key XP concepts, showing that this radical methodology didn't spring fully formed into the mind of Beck, but is still evolving. One such key is "Yesterdays Weather", the idea that you can't go far wrong by using past performance as an initial guess for future results.

If you are at all intrigued by the new "agile" methodologies, read XP Explained and then this one. Then buy a few more copies for your management.

Excellent book
This book lays out the point of planning, the approach taken, and the steps to do.

This book has a lot of content not found in any other XP book that I own. The gold nuggets in here are useful for project management for years to come.It's a 5 star for sure.

How exactly to plan XP?
This book is very valuable if you already started to practice Extreme Programming. It contains a very encouraging foreword by Tom DeMarco. The first nine chapters are introductory, and you may skip them if you read the XP Manifesto "Extreme Programming Explained" by Kent Beck. Chapters from ten to twenty three contain valuable information not found in any other XP-related book.

- How exactly to plan releases? What if frequent releases aren't appropriate and marketing demands to release once a year?

- How exactly to write user stories, and how to handle them? Although the reader may find some sample stories in "Extreme Programming Installed" by Ron Jeffries, Ann Anderson and Chet Hendrickson, the stories in the "Planning Extreme Programming" are used as core elements in the whole planning process, shown as example.

- How exactly to build the iteration plan and the release plan? How to track an iteration?

I would also like to recommend "Extreme Programming Applied: Playing to Win" by Ken Auer, Roy Miller, Ward Cunningham. I think this is the most practical book on XP ever written.

I would also like to recommend the titles about individual XP aspects:
- Design Improvement: "Refactoring: Improving the Design of Existing Code " by Martin Fowler;
- Test-Driven Development: "Test Driven Development: By Example " by Kent Beck;
- Sustainable Pace: "Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency" by Tom DeMarco;
- Pair Programming: "Pair Programming Illuminated" by Laurie Williams and Robert Kessler;
- Whole Team: "Agile Software Development" by Alistair Cockburn;
- Planning Game: "Planning Extreme Programming" by Kent Beck, Martin Fowler;
- Small Releases: "Software Project Survival Guide" by Steve C McConnell. ... Read more

Product Description

Algorithms and Programming is primarily intended for use in a first-year undergraduate course in programming. It is structured in a problem-solution format that requires the student to think through the programming process, thus developing an understanding of the underlying theory. The book is easily readable by a student taking a basic introductory course in computer science as well as useful for a graduate-level course in the analysis of algorithms and/or compiler construction.

Each self-contained chapter presents classical and well-known problems supplemented by clear and in-depth explanations. The material covered includes such topics as combinatorics, sorting, searching, queues, grammar and parsing, selected well-known algorithms and much more. Students and teachers will find this both an excellent text for learning programming and a source of problems for a variety of courses.

Customer Reviews (1)

The best book for programming contests preparation I've ever read
That book doesn't contain pure algorithms theory (like Kormen's or Skiena's book), but problems (and most of them are with solutions). Every chapter starts with the simple problem, followed by some discussions of possible solutions, and after more and more challenging tasks ends with pretty tricky problems.
The book (in my opinion) is really very practical (well, it contains some theory, but not very formal) and is invaluable for those who are preparing to the programming contests or Google/Microsoft-like interviews. ... Read more

Product Description
Fast-paced tutorial to help professionals write caliber code! HerbSchildt is Osborne's #1 programming author with more than 2 millionbooks sold! Microsoft's MFC 6 is a major revision packaged with VisualC++ 6, the U.S. market- leading compiler--both are being aggressivelymarketed by Microsoft. Revised and updated with critical coverage ofInternet Explorer, Windows 98, ActiveX, and web-based features, plushandy "In-Depth" boxes, margin notes, and more. ... Read more

Customer Reviews (39)

The best introduction to MFC one can read
I have been studying C/C++ programming and MFC/Win32 API programming for approximately one year now and during this time I have accrued over one hundred books on the subject. This said, in the Visual C++/MFC category this book is the best introduction that I have found. One clear reason is that the author teaches MFC programming in the absence of the Visual Studio App Wizard so that the reader gets a fundamental understanding of how MFC works, from the ground up, just like the title suggests. The final chapter then covers the App Wizard, and Class Wizard as well. He also covers the Document/View architecture in one of the final chapters. Moreover, the exposition, in terms of code generated (functionality), very closely parallels the code and topics the author treats using the Win32 API in his book Windows 98 Programming from the ground up,
all of which is still relevant in 2005. Certainly there are many other good books on MFC programming but as an introduction I have found this book to be the best, not surprising as the author is a world renowned programming language expert and a prolific author. Thanks to this book I will ultimately be able to read more advance books with greater comprehension in addition to writing tighter Windows executables.

The Best Intro to MFC out there.
I have a few books on MFC and windows programming in general, with one thing in common - they were collecting dust on my shelf, because none of them covered the fundamentals good, they would all go right into wizards, or spend forever on semantics, without really teaching you why.I'm an embedded engineer, with good c background, and some experience with c++, and this book IS THE BEST.After spending less than 1 hour on first few chapters, I felt like I was finally getting it, and right now, more advanced reading like Blaszczak's MFC finally makes sense.I am also surprised by negative reviews here - in my opinion this book is THE book to get started with windows programming, and really know what you are doing.

Excellent Starting Book
Looking for a good start to programming Windows 95/98/NT/XP?I can recommend Schildt.It uses "hand programming" which is the best way to learn and it teaches the Wizards later on.If you have never programmed Windows before this is s great place to start.

What's my background?I have been doing applications in FORTRAN, Pascal, Clipper, FoxBase and C++ for 20 years; all numerical apps using only the console and text files for input and output.I have been using Visual C++ continuously since 1998 and it is now my only programming language.

You need to be very strong on C++ before beginning MFC.I recommend "Teach Yourself C++" by Al Stevens and "The C++ Programming Language" by Dr. Stroustrup.I have practically memorized these and regularly use STL objects and code in my console based MFC applications.

But now I need to use the Windows interface and hence my positive experience with Schildt.I spent a week studying direct programming of the Win32 API using another book and tutorial I found on the web.My conclusion: You would be crazy not to use MFC.If you are doing anything close to a standard application you would be crazy not to use the Visual C++ 6.0 Wizards.

Schildt starts with the absolute basics, just as do the university courses on MFC.This may in fact be the only book on MFC that I need ... but I right now do expect acquire a more advanced book once I understand all of the MFC basics.

No CD-ROM is supplied with the book. Not a problem. I down loaded the code (complete with how to compile instructions for VC6) from www.osborne.com in October 2003, so even through the book is 5 years old, the code is still accessible and VC has not changed only slightly so the instrustions in teh book still applie.The code download uses the single file approach and is not split into separate header and body files.Ok for learning.

Stay away from this series
The biggest problem with this book is that it's ugly.No, not just ugly, but the typeface chosen is too large and very difficult to read.It doesn't matter that the material is good if I can't stand to read the book.What's hard about reading it?The type is too large and heavy, and you can't quickly scan the pages, you have to read letter by letter to make the words.

A good book to understand MFC
This is a book among the others that *does not only* show you how the use the wizards. It tells you step by step, in a very clear manner the underlying structure of MFC. The author starts with a very simple program, using the most simple MFC component. It then add more and more controls to that simple program, and give you very clear concept of what is going on behind the scene. This book is an excellent one for those who want to learn MFC without any previous knowledge. ... Read more

Product Description

Customer Reviews (15)

A trashing of the first edition ..........
This is a blatant misrepresentation of the excellent first edition of this book: Advanced Perl Programming.It's as if they published a 2nd edition of GoF Design Patterns but it was written by the Three Stooges and contained a rambling account of Moe, Larry, and Curly trying to implement an HTML parser.If fact that would have been a better book than this!Most of this book is filled with lists of parsing modules but with no coherent thread of discussion about how to use these modules to do anything besides trivial parsing of simple documents!The only reason this gets 2 stars is due to the very first chapter which is a decent discussion of "advanced techniques" such as introspection and a very brief discussion of perl internals.However after that you can use the rest of this atrocity to wipe your ass with......

Excellent reference for the serious Perl developer
This book truly lives up to it's title - this is a book for advanced developers who have a solid understanding of not only the Perl language but of higher level computer science concepts.

While there are some intermediate topics and short introductions, this is not a book to learn theory -- this is a book to show you how to take the theoretical concepts you've learned elsewhere and apply them to Perl, and to understand more of the internal workings of the language.

more a guide to CPAN than to the Perl language
In his preface to Advanced Perl Programming, 2nd Edition, Simon Cozens says that the focus in Perl programming has shifted, since the first edition, from techniques to resources.Rather than write really good new code, authors rely on the CPAN to find existing code and use that to solve the unoriginal parts of their problems.To cater to the discerning Perl programmer, then, the book has been completely rewritten.Instead of covering the parts of the Perl programming language that are often unexploited by more novice hackers, APP2 focuses on providing an overview of some of the major solved problems in Perl, and the modules that provide some of the solutions.

Only Chapter 1, "Advanced Techniques," bears much resemblance to the previous edition of APP.It covers subject matter closer to the language than to the modules involved: globs, CORE::, objects, B, and compilation.Each subsequent chapters discusses a common programming problem, shows off a few existing solutions (in the form of code on the CPAN), and sometimes demonstrates how to put those existing solutions to use.Among the topics covered are parsing, templating, serialization, unicode, and testing.POE, Inline, and Acme also get a chapter each.

Simon's writing is, as always, lucid and easy to follow.He provides good example problems, and he builds solutions that tend to do a good job of selling the modules on display.I must admit to feeling compelled to go do more with POE and some of the Lingua:: tools, after finishing their respective chapters.

In the end, though, I felt unfulfilled.While APP1 was not one of O'Reilly's best Perl books, it delivered what it promised: advanced techniques for writing Perl code.What APP2 delivers is a guide to avoiding the need for advanced techniques.It will save you from needing to use the strangest bits of Perl, not show you how.(The back cover quotes Andy Wardley as saying, "This book of spells goes a long way to unlocking those secrets [of advanced Perl code.]"I think, rather, that it just teaches the incantations.)

Perhaps my disappointment is predicated entirely on my incorrect expectations.If this book had been called "Leveraging the CPAN," I'd probably consider it a great success.You may, instead, be interested inIntermediate Perl or Mastering Perl.

A very different beast to the first edition
As other reviewers have noted, there's not a whole lot in common with the first edition of this book, either in feel or content. It's rather questionable whether this merits being called a second edition. Something like 'Problem solving with CPAN' would be a more accurate title (then again, perhaps it's just as well I don't work in the publishing industry).

It does still cover some of the material of the first edition, such as globs, closures, AUTOLOAD, the Perl class model, and some Perl internals, but it's all been compressed into one chapter.

The other chapters discuss various subjects using CPAN modules and gives some insight into how the material from the first chapter was used to solve these problems. A wide variety of issues are discussed, including serialization and object relational mapping, natural language parsing, templating and unicode. Some superficially similar material could be found in Perl Cookbook, but the discussion here is deeper (and more up to date), there's very little overlap.

Exactly how much you get out of the book will probably be dependent on how well you know the innards of CPAN and how interesting you find the topics. I liked the parsing and natural language processing chapters a lot, and the chapter on inlining code from other languages was diverting; conversely, I can't bring myself to find Unicode even remotely stimulating, and the POE (some sort of event-based framework) chapter didn't do much for me. The testing chapter is a solid addition to the material in Intermediate Perl, and I picked up some pointers to modules to check out, but it didn't feel all that advanced.

This is a book that fits in quite nicely with Intermediate Perl and Programming Perl -- it cleans up a few niggling details not well discussed in the former book, without having the intimidating heft of the latter, and also provides a wide ranging overview of several topics and the CPAN solutions for them. As such, it will bring an intermediate programmer up a few notches.

Already advanced Perl programmers may be disappointed, and those hoping for an updated version of the first edition will definitely be out of luck, but if you know what you're getting, and evaluate it on those terms, rather than what the title suggests, I think you'll enjoy it.

Very disappointing
This book was slated to come out for a long time before it actually did, and I naturally assumed that Simon was working on something ambitious and that it was taking him longer than he planned. I bought it sight-unseen, but quickly discovered it was more of a tour of CPAN than an in-depth book deserving of the title Advanced Perl Programming. I know from his blog that Simon was wrapping up his life to go be a missionary in Japan, so now I think the book was late because he was working on *that* project after he had agreed to write this book. Just speculation.

It reads more like an article on Perl.com or in the Perl Journal, and could easily have been several articles spread out over a few months. I have to wonder if he started the book with the idea that "advanced" means "knowing about useful modules on CPAN" or if the idea came to him sometime after it was clear the book was running late.

Regardless, consider looking at it if you see it in the store. It's not without its value, but I can't see paying for a book that mostly says, "Here's someone else's work to check out." An advanced book ought to be getting into -- well -- advanced techniques, useful info that's hard to come by, something that isn't ALREADY AVAILABLE ELSEWHERE. ... Read more

Product Description
...from my experience, most teams that say they're doing XP don't actually do the practices.

&#8212; Alistair Cockburn, Xp And The Cmm

Extreme Programming Refactored: The Case Against XP(featuring Songs of the Extremos) takes a satirical look at the increasingly hyped Extreme Programming methodology. It explores some quite astonishing Extremo quotes that have typified the XP approach&emdash; quotes such as, "XPers are not afraid of oral documentation," "Schedule is the customer's problem," "Dependencies between requirements are more a matter of fear than reality" and "Concentration is the Enemy."

In between the chuckles, though, there is a serious analysis of XP's many flaws. The authors also examine C3, the first XP project, whose team (most of whom went on to get XP book deals shortly before C3's cancellation) described themselves as "the best team on the face of the Earth". (In a later chapter, the authors also note that one problem which can affect pair programmers is overconfidence&emdash; or is that "eXcessive courage"?). The authors examine whether the problems that led to C3's "inexplicable" cancellation could also afflict present-day XP projects.

In the final chapter (Refactoring XP) Matt and Doug suggest some ways of achieving the agile goals of XP using some XP practices (used in moderation) combined with other, less risk-laden methods.

Customer Reviews (41)

Two good chapters
[Reviewed by XPSD member Sunitha Dangeti]

Having practiced XP, I particularly like two chapters in this book, one on XP in a nuthouse which is a good read for someone who is new to XP to get a quick understanding of the XP concept and the next one is the chapter on XP refactored in which the authors point out good features of XP along with their own best practices added and ideas that may make XP better.

This book is an extreme view of Extreme programming. The authors have criticized almost every aspect of Extreme programming. Any developer thinking of following the methodology would be discouraged to do so if they came across this book first.

They take a very rigid stand on refactoring, picturing as if XP programmers are in a constant refactoring frenzy for no good reason. Lack of initial design has been pointed out as being responsible for lot of rework. Release early, release often concept has been shown to increase the developer's concern of whether it will integrate into the system and satisfy all the tests or not.

They point out that XP is not scalable and is only suitable for small projects. Though most of the XP projects are small, I know the above statement is not entirely true as I heard a success story of a big project which was migrating and had a strict production deadline to meet which it did.

The authors picked examples from instances where the coders did not take care of situations. For example, they comment on unit tests saying that unit tests are stand alone in XP and often left databases dirty. The developer in that instance may not have had roll back statements in the test which is why the database was left dirty and hence it is not a flaw with XP methodology but a flaw with the way it was implemented.

By the end of the book, the authors refactor XP and delineate the pros and cons of each XP component in which they mention the following points:

* Pair programming should not be constant or mandatory
* Programmers should design
* Programmers should write their own tests
* Instead of continuous design, we should follow frequent design
* 40 hr weeks are not feasible as sometimes developers have to work overtime to meet deadlines
* Coding, testing, listening and designing of XP are worth salvaging
* Iterations should be one month long
* Test first design should complement the design but should not drive it
* Use a combination of requirements and use cases instead of user stories
* Project velocity should be measured in terms of formal requirements completed per iteration rather than user stories per iteration


Overall, I thought it was a fairly good though quick read for me

An expanded blog comment
I'm writing my thesis that reviews and debates one specific Agile aspect.
Hoped to find something valuable here, but got very surprised instead...of how certain books could get published at all.

It doesn't elaborate much on XP, but is an expanded version of what should have been a vandalic comment in an XP blog.

I can be sarcastic speaking about the childish jokes, but had enough sneering with the book already. Is a pity the name looks interesting, somebody may have wanted to use it for serious purposes.

Great insight, but enough of the Beatles parody songs
The most amusing (and damning) part of this book's message are the quoted statements from the XP prophets. They are ridiculous and hilarious.
The authors well document these statements, although using references of messages posted to newsgroups is a little on the border of legitimate. The statements quoted from the prophets' books are quite adequate.
Unfortunately the authors don't let that humor stand on its own, and they try to write mock Monty Python skits and parody Beatles songs with XP lyrics. This is where the book falls flat.

Amusing but not a serious questioning of XP
I read the book before I read the reviews, and I have to say that I found most of the more crtical reviews of this book were right on the nail. As a project manager with 19 odd years experience, the last 4 years of which have involved managing teams transitioning to Agile Practices and usually managing team technology skillset transitions at the same time, I have to say I like some XP practices but not XP as THE guiding process/methodology for a team. Working for a global IT services organisation, I'm fortunately in the position of being able to heavily influence the methodolog(ies) my projects follow, and I do consistently use selected XP practices and find them useful (my bias is exposed....).

With that said, I was looking forward to a good thorough critique of XP when I started on this book - but I really do find the satrical approach overdone. To be sure, it was entertaining the first few times, but after that the tone begins to pall. I did enjoy some of what the authors write, some of their criticsms I believe are valid, but the ongoing attempts to be funny and the overdone attacks on XP undermine what could have been a useful critique of XP. McBreen's "Questioning Extreme Programming" book is a far better examination of XP, although to my mind he doesn't dig deep enough into some of the problems that XP teams seem to experience (and I speak from hearsay here, largely from developers I've worked with who have come from teams where XP was THE only process followed).

That said,I enjoyed reading the book. Just wouldn't recommend it to anyone as a serious critique of XP.

Cut to the core of XP's glaring defects
When i first read R Martin's book on agile/xp, the first thing that jumped out at me was Pair Programming (PP): it's the most stupid idea ever!

This book did an excellent job to show why PP was bad and how it creates problems rather than solve them. It also exposed warped statistics that was used to push PP. I esp. like this quote in the book: too many cooks spoil the broth.

Unlike other fervent attacks on XP, this book provided many constructive suggestions that showed that software development is a complex business and as such cannot be addressed using a single methodology like XP. ... Read more

Product Description
If you are new to programming with PHP and MySQL and arelooking for a solid introduction, this is the book for you. Developedby computer science instructors, books in the for the absolutebeginner series teach the principles of programming through simplegame creation. You will acquire the skills that you need for morepractical programming applications and will learn how these skills canbe put to use in real world scenarios. Best of all, by the time youfinish this book you will be able to apply the basic principles you’velearned to the next programming language you tackle. ... Read more

Customer Reviews (8)

Not for beginners. Confusing.
This book is not for beginners, and it is absolutely not for "absolute" beginners. It's badly written and jump for one subject to another. It doesn't make sense whatsoever. It introduce tags and codes without any explanation and then they move on to more code using information that was never explained. Don't buy it. Save your money and time.

Save your money, mine is going back!
As always, another book for beginners that makes no sense. If you are like me trying to learn PHP/MySQL it looks like the NET is the way to go. Find tons of tutorials and read them. I only read the first 100+ pages and was not happy. It appears that they DONT KNOW what a beginner is! I'm still looking for a book to get my feet wet, so far I've read the "in easy steps" books from BN, and they were simple to grasp. But not enough.

This has been one of my biggest complaints with books for beginners... Are they really for some one who knows nothing about the subject? Or is it marketing? You make the call. I have complained forever about this! It appears they start out good then lose it, and you are now stuck.

PS This is my first review and I wanted to write it so you can see it really does not help the newbie. Good Luck in your PHP/MySQL learning.

Wonderful for Beginners !
One of the Best books I have ever read ,not only in Computers but in general.The author has brought out the exciting world of PHP/MySQL to a dumbo like me..!!

To put in a nutshell when I finished reading the book I felt that someone who has guided me over is gone !

Needless to say that I strongly recommend this book for beginners..! :)

Good but not great- it has unusable code
This book has been good for several things- teaching basic code, reusing snippets of scripts- but in Chaper 6- Working with Files, I haven't been able to get the code to work. Loading it from the companion CD, it didn't work off the bat. I went online for support and there is NO errata souce for the book which is really frustrating! I finally figured out the first problem in the code, but now I am stuck again. I like to use the book as a reference to work on a problem at hand, so this book isn't one for that. Also, the code that it suppllies should work without any tweaking needed (or tell you what tweaking needs to be done) and this book isn't one for that either. Therefore, I suggest borrowing the book from a friend or the library before purchasing, or buy it used. It is helpful at points, but en errata source would have made this perfect for me. For an example of a great book/resource on PHP and MySQL, see Larry Ullman's PHP & MySQL for Dynamic Web Sites.

Good, but doesn't help much designing the actual page.
Good, but doesn't help much designing the actual page. I was hoping to learn to make the actual design of a page, but its mostly all about scripts. I like how you do get examples though. ... Read more

Product Description
SQL--Structured Query Language--is the language all relational databases use to make enquiries. This essential book teaches SQL programming in the shortest possible time. It covers both the ANSI standard as the minimum requirement, and also discusses different implementations. It also serves as a handy reference. ... Read more

Customer Reviews (23)

Still the best
Ok, it's 10 years since this book was written and it is still the one I use as my SQL reference.

One note - I'm a programmer, not a DBA. So my SQL needs are pretty simple. But if you want a basic reference that covers all of the basics clearly - this is the book.

A Good Start
Probably not the best book ever written for SQL, let alone for beginners.

However, it is the one I used to learn SQL. It covers the basics in a fairly concise manner, enough so to be able to move on to a more advanced book. I read it cover-to-cover, and didn't agonize over the side-tracking or standards discussions. What I wanted was the details on the syntax of the language and an understanding of what the statements do, and that is what was provided along with some basic examples. By the end of the book, I was able to use SQL at a novice level.

I'm not sure I'd use this book to teach a class on beginning SQL, but as a quick and dirty read to get a first taste of the language, it fits. P-)

Very Disappointed -- Not for Beginners
I had to buy this book for an online class I'm taking.The teacher probably wanted it because of the [very old] software [on floppys] to use with the class.The book itself is basically on the border of terrible for someone like me who is new to SQL (even though I am a senior CS student).Uses a lots of terminology that he doesn't explain.Not very good examples.Cannot skip between chapters without confusion.Overall, this is the worst computer book that I have purchased.I'm looking for a new one to supliment my learning for the class.

frustration and disappointment
The book starts with installation notes telling reader that instead of using password such and such and id such, as it is described in the software's help, you rathre have to use password "sql" and password "dba".I tried to enter "sql" and "dba" into the password-asking dialog box, and it did not work. Then I realized that it is password "sql" and USERID "dba", and not only it is a misprint, they are listed in a reverse order: first you enter "dba", and second - "sql".That's on the very first page.The page 5 states, that supplied version of Watcom SQL engine will not allow to execute commands CREATE, ALTER, DROP, GRANT or REVOKE.That makes impossible to practice anything you read up to the chapter 5.However, in chapter 6 on p. 162 author offers you to execute commandALTER TABLE, and if you already forgot about page 5, that's a lot of frustration.At this time it helps to return to page 8: "The code in this book has been extensively tested ... so if you encounter an error message ... please thoroughly check that you've typed the code in correctly ...if you don't type in all of the examples, then you may encounter problems later with certain structures or features which haven't been created".

Beginners Beware
Database design and SQL are difficult subjects but a book for beginners should make every effort to accomodate the beginner by simplifying it asmuch as possible. And, to a degree, this book does that. But there are toomany forays into outer space. Consider this passage from page 122: 'You cansummarize the rule as follows: if X and Y are columns and X is a key, thenfor any Z which is a proper subset of X, it can't be the case that Zdetermines Y.' No matter how elegant, I don't think anyone would argue thatthis is helpful for a beginner. On the contrary, it tends to make thesubject seem as difficult as possible. Hardly a proper goal for abeginner's book. I am about half-way through this book and, increasingly, Iam going to MSDN for a clearer explanation to each of the subjects thatCelko addresses. ... Read more

Product Description
Are you an SQL programmer that, like many, came to SQL after learning and writing procedural or object-oriented code? Or have switched jobs to where a different brand of SQL is being used, or maybe even been told to learn SQL yourself?

If even one answer is yes, then you need this book. A "Manual of Style" for the SQL programmer, this book is a collection of heuristics and rules, tips, and tricks that will help you improve SQL programming style and proficiency, and for formatting and writing portable, readable, maintainable SQL code. Based on many years of experience consulting in SQL shops, and gathering questions and resolving his students' SQL style issues, Joe Celko can help you become an even better SQL programmer.

+ Help you write Standard SQL without an accent or a dialect that is used in another programming language or a specific flavor of SQL, code that can be maintained and used by other people.
+ Enable you to give your group a coding standard for internal use, to enable programmers to use a consistent style.
+ Give you the mental tools to approach a new problem with SQL as your tool, rather than another programming language - one that someone else might not know! ... Read more

Customer Reviews (8)

3.5 stars: Has good stuff but very undercooked
I'll expand on that when I have time; but for now, real quick:
PROs:

- As usual for Celko's books, you get this feeling of conversing with a knowledgeable and overall very likeable individual with a good sense of humour (he got me laughing on page 2, see his comments on the making of fine furniture).

- Good justifications are given for many rules of thumb that, as of now, you're likely to be adhering to on faith.

- A number of unobvious, sharp, mind-stretching tidbits (an ever-present feature of Celko books).

- Very good bibliography. Celko is not a "narrow specialist": reading pointers he gives are varied and very interesting. Also, links to a lot of net material. Great.

- He writes simply.

-----------------------

CONTRA, the one and only problem: the book appears to be written in a terrible hurry, which is manifested by the following occurrences (not exhaustively):

- Sometimes the author has something to say, but does not say it intelligibly (e.g., section 1.2.7)

- Sometimes he doesn't have anything to say, but gibbers on anyway (e.g., section 3.15)

- Sometimes he belabours the obvious or maybe even spurious: for example, there's too much of this "unlearn OO to understand SQL". One doesn't need to unlearn what one knows to learn something he doesn't; there's no clear-cut distinction: for example, operating on STL collections is very set-like, quite SQL'ish actually: you provide a predicate and it's then applied internally in a set-scoped operation. Matlab is very similar. BLAS is very similar. Fortran is similar. Iow, thinking in sets is an important thing to point to -- once; but after that it's beating a dead horse; move on already. Especially since it isn't really as black-and-white as the author suggests.

(4) The book is very inadequately indexed: index is very small; nothing can be found. What's SQL/PSM? I don't think it's been defined anywhere, but perhaps I missed it; off to index I go... and find nothing there. How nice. I mean, come on -- a five-page index in a technical book?

(5) Dropping French. Is it really necessary? "Sistemé International d'units", OK.

There's more stuff to talk about, both good and bad; but I've no time to write it up right now. So, finally: is it a worthy book?

Well, the book is flawed but not useless by any means. It's not a must read, but if you got a few discretionary bucks and a bit of free time, it's worth reading. I've learned a few interesting things here; ~1/3rd of the reading has been pleasant: in addition to knowing a lot of stuff, DB-related and beyond, Celko's got a real good sense of humour and a gift of gab. Were this book a brochure one-third its current size sold for five bucks, I'd give it five stars. OK, ten bucks.

This is the nth try to post this review
If this review finally goes in, I shall be pleased but surprised, There is something wrong with Amazon's linking. I have spoken to support and they don't know what it is. Anyway...

This is a mixed bag, but mostly very good. Lots of excellent information about different versions of SQL vs. standards, and fascinating excursions into the underpinnings of coding systems, measurements, scales, ratios, etc. We should all be a lot more aware of the work that has been done and codified in many international standards. Apart from anything else, it would save people from re-inventing so many wheels - and making some of them square!

There is an excellent and much-needed stress on the need to use relational thinking when you are working in the SQL environment, with the focus on natural keys and set-oriented processing. He rightly decries the use of "external locator" keys (which most of us call "surrogate" keys, though he defines that term differently) - anyway, basically the "Identity" type. He is perhaps a little too extreme in pretty much absolutely outlawing them, but I agree with the general principle. They are an expedient pushed by people who don't understand relational design. Natural keys are much better. (But I have to agree with another reviewer that the SSN is problematic. Coming to the US from Canada, I couldn't believe the SSN was not a check-digited number, unlike the Canadian SIN, or any credit card number, or banking ABA's. I guess the age of the system was one issue. But the result, anyway, is that duplicate SSNs exist and that they are frequently invented or stolen.)

As a self-described "old fart" he castigates the design errors that may be committed by those (like me!) who grew up in the age of punched cards and magnetic tape. But surely few current database designers have ever seen a punched card, and rarely encounter a good old sequential fixed-length-record file, let alone a mag tape. The model that leads them astray these days is not the sequential file, but the Excel spreadsheet! Time and again I see HORRIBLE designs, violating all the normal forms from 1 to 3 and beyond, based on the columns of an Excel spreadsheet. Another factor is the lack of relational training- how many people have read Codd or Date?and the harm done by the early PC databases that were just a kind of disorganized dumping-ground for data, draining meaning from the term "database."

Some of his mandates are perhaps a little too absolute "Don't use cursors" - well, 99% of the time, very true. You should be thinking sets, not serial access. But there are a few occasions where a cursor can be a useful weapon in your armory and can even execute faster than a set manipulation. Not many, but a few - beyond the outlying cases he describes. Similarly withtriggers - yes, generally DRI is far preferable (if your DBMS supports it). But if you want customized transaction audit capture, triggers are the natural way to go.

A few beefs:

There's a sprinkling of typos, and I did spot one actual error: on p 114, he presents "WHERE a = b + 2" as the alternative to "WHERE a + 2 = b - 4." Oops! Obviously the valid alternative is "WHERE a = b - 6."

The discussion of Camel Case is too limited: there are a lot of variations and his definition is at odds with the widely used Microsoft definition, which would have been worth mentioning. For MS, camel case is like "thisCase" and Celko's camel case, "ThisCase," is called Pascal case.

I found his advice on formatting and display of code sometimes odd. Often when he showed example A and then "see how example B is more readable " - I thought example A was clearer!He refers to studies on visual perception, eye movement, etc., but I am not sure that such studies done in the context of reading normal prose are valid for SQL, or other programming-type text. Comprehension likely occurs in different stages or chunks.

Also, surely Hungarian notationis found in strongly-typed, not weakly-typed, languages. In a weakly-typed language like REXX, a variable can be a string one minute, an integer the next. What prefix can you use? Whereas in VB, for instance, up to version 6, MS recommended prefixes to remind the programmer of the fixed type as defined, so he would not be tempted to write "intAccountID = "New Customer" or suchlike.[...]

Summary? Well, OK, I've listed a few problems, but overall, get this and study it- there's lots of fascinating and rewarding material, from someone who has been working in this field a long time and has gone very deeply into many aspects of it. Many of the SQL examples will really stretch your brain - his other books do that too!

Great SQL Style Reference
This is a great reference for how to write clear, concise, and efficient SQL. If you are looking for good ideas for SQL coding standards, you will find them here.

In my career, I've seen a lot of poorly written, nearly incomprensible SQL, which is always harder to maintain. I just wish more novice SQL developers and DBAs had read this book.

I really enjoyed this book
Wading through badly written SQL is a nightmare on the best of days.Proper--and consistent--attention to capitalization, indentation, and other formatting standards makes SQL much more readable and therefore maintainable.The standards outlined in this book are for the most part very well thought-out, and a great starting point for creating a set of enterprise SQL development standards.If more SQL developers would read this book, I would have many less headaches in my day-to-day work, so I believe this is a valuable purchase.

Excellent book in excellent style
Too many database books are written by developers whose expertise is OOP and not SQL.While I don't agree with Mr. Celko on every point, keep in mind that he was on the SQL Standards Committee for 10 years.Even if you don't agree with him on every point, his level of expertise is undeniable - unless, perhaps, the questioner can provide evidence of greater knowledge and expertise.

This book is to SQL grammar and style as "The Elements of Style" by Strunk and White are to English grammar and style.Mr. Celko explains, in terms that should be easily understood, why SQL should be written in standard SQL while still allowing that there can be exceptions just as verbal communications, in any language, should follow the standard grammar of the language unless there is good reason to slip into a localized dialect.

Where one reviewer rated the book with 1 star because that reviewer disagrees with Mr. Celko on a single point of database design, his antagonistic remarks have nothing to do with the point or the value of this book.

As the editorial review states, this book is not for beginners.If you have been programming SQL for a year or more and you want to fine tune the quality of your work, this work is something you should surely read.

... Read more

Product Description
Welcome to Scratch Programming for Teens! Scratch is a programming language intended to make programming easier to learn for novice programmers. It can be used to create computer games, interactive stories, graphic artwork and computer animation, and all sorts of other multimedia projects. Scratch can also be used to play digital music and sound effects. If you aspire to one day become a professional programmer, Scratch provides everything you need to build a foundation. Scratch also packs all of the programming power and punch needed to satisfy the programming needs of most computer enthusiasts and hobbyists. Best of all, it?s actually fun to use! Scratch Programming for Teens provides all the instruction that a first-time programmer needs to quickly get up and running with Scratch. Before you know it, you will be creating all kinds of projects that incorporate graphics, sound, and animation. As you learn how to program with Scratch, you will learn programming principles and techniques that you can later apply to other programming languages such as Microsoft Visual Basic and AppleScript.Jerry Lee Ford, Jr. is an author, educator, and an IT professional with over 18 years of experience in information technology, including roles as an automation analyst, technical manager, technical support analyst, automation engineer, and security analyst. He is the author of 24 other books and co-author of two additional books. His published works include AppleScript Studio Programming for the Absolute Beginner, Programming for the Absolute Beginner, and DarkBASIC Programming for the Absolute Beginner. Jerry has a master?s degree in business administration from Virginia Commonwealth University in Richmond, Virginia, and he has over five years of experience as an adjunct instructor teaching networking courses in information technology. ... Read more

Customer Reviews (1)

Amazing Book
If you are interested in Scratch, an MIT open source multimedia authoring product designed for youth. This book covers the basics and works its way through some of the tougher parts of Scratch. I enjoyed reading the book as a teacher and sharing it with my students.

Steve Kessler
Denver DataMan ... Read more

Product Description
The benefits of learning to program the computer are many. In this book, “Computer Programming 101: How To Learn Computer Programming Made Simple & Easy!”, you will learn what computer programming is, and how it can improve your life on many levels.

Here’s a little of what you’ll learn inside of “Computer Programming 101: How To Learn Computer Programming Made Simple & Easy!”:

- What computer programming is and why you should care about it.

- Where to find software lessons for beginners.

- What a computer programmer does.

- Definitions of the most popular computer languages.

- How to find a great job in computer programming.

- The future job market of the computer programmer.

- You will learn where to go to get software that will teach you to master the programs on your computer in record time.

- You will also learn where to go if you prefer to attend a class, and where you will find some of these courses free of charge.

- And more
... Read more