Programming Books

A very good book for those who want to learn advanced concepts in OS. Since it is a open source the book is very useful in understanding how they look like. The paper quality is too good, which makes u read non stop. i luv reading this book. Price worth it. A good buy.

A BSD Bible. I never could read the Bible. I do Believe ...

650+ pages of truth and gore. I (as a sysadmin and BSD boomer) related most to the History (Ch.1) and Startup/Shutdown (final Ch.14). Memory management and other gore escapes me. GOOD JOB!

First of all you should be warned that this is not an introduction to get started with UNIX kernel programming. The Design of the UNIX Operating System by M.J. Bach provides a good general introduction to UNIX kernel programming. The design and implementation of the FreeBSD operating system is an excellent book to deepen knowledge of the UNIX kernel by looking how a current UNIX is implemented in practice. Even if you plan to write code for another kernel, working through the FreeBSD kernel with this book as a guide is a good excercise to become consious of the fundamental problems and solutions in kernel design. FreeBSD (or any of the other BSDs) is a good starting point, because the BSDs have relatively stable kernel subsystems and APIs due to the long cycles in BSD development.

The writing style of the authors is to the point (don't expect a novel) and clear. The troff typesetting of the book gives it a consistent style and simple, but clear diagrams (though I heard that some diagrams were hand-drawn). The book doesn't just drop the reader in a kernel subsystem. The second chapter gives a detailed explanation of the various kernel subsystems, and the relation between the subsystems. The third chapter gives a summary of what is expected from a kernel from the user level. Combined these two chapters give the reader the necessary conception of the FreeBSD kernel to start looking at individual parts of the kernel in detail. Most remaining chapters are logically ordered, in that subsystems are ordered from parts with less dependencies to parts with more dependencies (e.g. memory management and I/O are covered before filesystems).

If you are interested in UNIX programming, you should have this book on your bookshelf (as well as a CVS checkout of the FreeBSD kernel tree to read the implementation).

Before I encountered this book it was quite a bit of frustration in attempt to learn BSD and UNIX to the point I can really use it. For some reason there so many good books in a subject with one of two inclinations: or the book is too theoretical and very little of the real workflow provided or it is too down to earth and it is difficult to understand what is behind the sophisticated command line zingers.
I found this book to be well balanced, well written and generally providing good, accessible way to get into BSD. I have followed advise in someone's review here and coupled this book with Linux and UNIX for a beginner training suite, 4DVDs + 2CDs includes 4 Unix Academy Certifications ed.2008. To my great surprise I have to say they really have made an outstanding training outfit!
If you really ready for a training and do not expect that UNIX will come to you overnight it is worthy book and deserves your attention.

For the other side of the story, you may wish to check out the most recent "Inside Microsoft Windows" or "Microsoft Windows Internals" by Mark Russinovich.

Over the years, I have bought a pile of "How to" books on After Effects,Première Pro, Photoshop and Illustrator and I did not feel any urge to write anything about these books before buying Ms Hartman's Illustrator guide.

I liked the writing : unpretentious, simple with a warm tone that clicks with the reader.

The first lesson in itself, is worth more than half the price of the book.

This book honestly is like a guide line. Especially if you need to look up something you can't remember, you can probably find what you need in the book.

This book really showed me, step by (illustrated) step, the way to make the most out of using Illustrator. I highly recommend it to anyone who likes the hands-on approach to learning. In the very first lesson, the author helped me create a logo that was really great looking, which gave me a boost of confidence to go on and do more. This book is just great for a beginner, to learn all the essentials of Illustrator.

This book is a guide to learning Adobe Illustrator CS and digital illustration. The approach is divided between reading sections and step-by-step exercises. Each chapter is divided into several short lessons with accompanying images describing the steps. The key combination and minor interface differences for Mac and windows are explained when necessary.

Overall, this was a good book that provided a smooth experience to learning Illustrator and design in general. The basics of Illustrator are easy to understand through the reading and exercises provided. Although the lessons are short, there is plenty of opportunity to practice on your own. You are initially walked through an exercise, but then usually given a chance to finish part of it on your own. The "Exploring On Your Own" sections provides extra practice and places to look for more information on the various topics discussed. The rest of the book in dedicated to providing useful information on design concepts such as color chords and art principles (line, fill, value etc). The color chords such as analogous, dyad or monochromatic will definitely help on my color choices on my next project. The CD provides all the needed lesson files and any additional samples for practice.

As for problems, most were really minor with this book. There were only a few minor errors spotted such as steps with missing detail or incorrect menu paths. Also, I did think the review questions at the end of each chapter would have been more helpful if the answers were provided. Actually, the biggest issue I had with this book was the novel sized format it was published in. The book is small and the pages are difficult to keep open. Even my document holder was barely able to keep the pages open. For most of the book I had to use one hand to keep it open while working the mouse with the other. I am probably just being a little finicky since most of these minor problems had little effect on actual content.

In the end, this is still a fine book to quickly get up to speed with Adobe Illustrator. The coverage on related design principles was just a bonus. Since this is a short book, do not expect deep coverage on Illustrator techniques. If you need more advanced concepts and/or less on design, then another book will probably work out better. However, the material that is covered is done so well and it should provide a good start for any beginner.

I am a computer programmer/web designer familiar with adobe photoshop, but I wanted to learn more about designing with illustrator. I knew how to get around the program, but was not confident in using it. This book was wonderful - it's great for beginners, and I love how it encourages you to use keystrokes to get things done, instead of the mouse (much faster).

I picked up this book to help me develop an application knowing absolutely nothing about GTK+ programming and it was beyond helpful. Excellently written, not to mention many code examples showing how to use the GTK+ library properly and efficiently. This book gives you the tools and the understanding for building your own applications and not just re-creating the examples given to you.
I highly recommend this book to anyone programing in C and want to learn how to use the GTK+ library along with the GLib and Pango libraries. This is one book I'm not going to let go of.

FINALLY... a great book on GTK+.
Easy to follow and understand, great example, great explanations...

Usually I dislike the writing styles in Apress publications, but this is a definite winner. For the first time I can say I actually understand and can effectively use GTK+.

I got this book a few weeks ago and found it to be well written and to the point.

A textview widget in python had me stumped, but no longer. Anyone wishing to tackle GTK+ programming should buy this well organized and excellent book. It is well worth it.

I wanted to like this book, but unfortunately I cannot in good conscience give it 5 stars as the other reviewers have.

I will say the book is well organized and is definitely useful as a starting point for studying GTK+ and the author clearly has a great deal of knowledge about the subject. But what should have been the main strength of the book that differentiates it from the mostly inadequate online tutorials is the author conveying to the reader straightforward explanations of important concepts and insider tips and tricks that can only come from extensive experience. He tries to do this, but I found many of his explanations ambiguous and confusing. Important terminology was left undefined or poorly defined which contributed to the confusion.

The author dutifully plods through a presentation of most of the main widgets, providing essentially the same trivial example code each time with minor variations- basically just showing how to put the widget onscreen. But there was a frustrating lack of material devoted to how to use signals and events to perform any useful tasks. The vast majority of the functionality of any GUI application lies in its event handlers and callback functions. After reading this book, you will be able to prototype the GUI for your application, but you may be at a loss to make it actually do something.

By Ch.3 and 4, the same example code has been replicated so many times that there is an increasing frequency of copy-paste errors that gradually becomes very annoying. Also, there are many typos in the text. The lack of editorial oversight and technical review on the part of the publisher combined with the author's lack of attention to detail and failures in exposition has created a book that I can only marginally recommend- mostly because all of the other books that have been published on GTK+ are either out of date or out of print, so this book seems to be the winner by default.

I admit that at first I was thinking this book would focus more on the game engine part of the toolset development in its title. I knew it wasn't REALLY about developing a game engine but even so, make sure you understand what you're getting.

That said, I really liked this book. I'm halfway through it already (it's a very quick read given how discrete each chapter is and the clear and easy to read print and examples).

I've read a number of game development books and you rarely get everything done right. This book gets close. The author describes the particular problem the chapter seeks to solve (e.g. encryption, batch processing, etc.) and goes through the steps of solving it.

The book is similar to those programming gems types of books that aren't organized in some linear fashion but are discrete chapters on specific topics that can be picked and chosen as you see fit.

The author does a very good job of putting the examples together and many of the chapters have been useful to me (I plan on implementing a number of the tools/frameworks he mentions).

If you're working on a game engine, I really suggest trying this book out. This assumes you're not already an expert game programmer who already built a lot of these sorts of tools before.

If you're looking for something that will help you build a full-fledged game engine, look for another book...then come back to this and get it to help you flesh out your toolset.

I just received my copy of Game Engine Toolset Development and I have been unable to put the book down. The author gives a good introduction to .NET 2.0 and relates it to toolset development for games. The chapters are easy to read and follow and he gives good advice on how to build good tools. He could have looked at other toolsets to make the book more complete, but I see this book as a way to introduce students to game programming who have a basic programming background (Java, C++, C, Alice 2.0, etc.).

I bought this book thinking it would help me write a new tool for, say, building 3d models, or some other general tool. When it arrived I got excited just by the shear size of it, it's huge!

However, I started flipping through it browsing each and every chapter (didn't read them all in detail of course, but quite a few) and it doesn't teach you how to make a NEW tool for your game, it teaches you how to make an EXISTING tool better. While that knowledge is extremely valuable (and the reason I gave it 4 stars instead of 3), it's not what the description of the book stated: "Readers are not required to have any experience developing game engine tools." If you have no experience developing a tool, you're going to have a little trouble getting started. If you know enough math and have good enough coding skills to get a game engine going, you'll be able to write a tool for your game, but you don't need this book to do it.

Now, with that said, this book IS quite good and worth your money so long as you don't expect to read this book and then write a tool, you're going to need more info. Get the book anyway and use it as a guide, it's usefull in that aspect.

This book is so good at making a tool better, most of it's "gems" can and should be applied to ANY application, game tool or not. Also, it covers some good highlevel (or lowlevel, depending on how you view it) .Net functionality such as interfacing with COM and code documentation, as well as few other excellent techniques. These "gems" are quite valuable on their own.

So, in conclusion, if you know nothing about writing a tool, or you don't know C#, hold off on buying this book (make sure to put it in your wish list however). If you have a tool but find it's difficult to work with, or you want to broaden it's appeal, or just simply make it better, get this book, you won't regret it.

This is an excellent book, which covers a lot of important aspects of game/engine tool development, but it is more like a recipe book, as each chapter subject is almost stands on its own - just like game programming gems series. My favorite is how to integrate native code into a managed application. The book is well written (one of the best I've read recently), and the only thing i missed is a few chapters on how-to integrate into an existing pipeline - like importer/exporter for a common 3d package at least. A better title for this book would be "(game)tool programming gems"

Then, as a hobbyist, I'll just let you know that this book not only teaches, but flat you gives you some great modular code that you can work into many different types of tools.

There's also some great design principles covered that have improved my workflow, even though i'm currently working solo.

This book was awesome, I could not put it down. You can really tell that he wrote it. It makes you understand what goes on in his head.

Jason McElwain's autobiography is well written and informative.
It describes the essential details of his life. The book presents
interviews with the most important people who have interacted with
Jason. It is highly recommended reading.
Jason's coping with his autism is relieved by his pleasure of
playing basketball. Jason in one basketball game colossally surmounts
being autistic by being artistic with his incredible three point shooting
accuracy. He sinks a total of twenty points with six three point shots and a two point field goal( where he mistakenly was standing on the three point line ) within the last three minutes and nine seconds of
his team's game. This performance was so incredibly phenomenal Jason's
life story is currently being developed into a national movie release.
One facet of Jason ( "J-Mac's" ) personal basketball practice
( "shootarounds" ) was never revealed in his autobiography that might
potentially be interesting to the public is his personal "best" basketball
shooting statistics and records. What percentage of three point shots
and free throws did Jason sink in practice? What were the most consecutive
three point shots or most consecutive free throws Jason ever sank in practice? What was the longest practice session shot Jason ever sank? Did Jason ever sink or perfect any practice "trick shots" or any other trick basketball handling or dribbling skills such as spinning the basketball upon his finger? I am an internationally famous basketball trick shooter and inspirational and motivational speaker named JIM "TRICK SHOT" LISTER.
I sink many of the most unusual and most difficult basketball trick
shots in basketball history with an astonishingly high degree of accuracy
despite shooting the basketball with a crippled right shooting hand.
My own personal basketball triumph over adversity is considered
by some basketball experts to be one of the greatest true basketball stories of all time.
I personally rate Jason McElwain's heart-wrenchingly and tear-jerkingly basketball triumph-over-an-obstacle accomplishment as the
single greatest true basketball story of all time!!!

RECEIVED THIS BOOK VERY QUICKLY. GREAT CONDITION. REAL BARGAIN. HIGHLY RECOMMEND THIS SELLER!

After seeing the tail end of Jason's recent appearance on "Larry King Live", I immediately went on line to buy "The Game of My Life". Jason's compelling story kept me up past 2:00 a.m. last night because I couldn't get enough of his unique ponderings on the importance of "focus" and his astonishing feat [20 points in just over 4 minutes of playing time!] on the basketball court.

Many parts of his narrative made me smile while others moved me to tears. I was even reminded of the brilliant screenplay penned by Matt Damon and Ben Affleck for their 1997 breakout film, "Good Will Hunting".

I can't wait to see the movie based on Jason "J-Mac" McElwain's life and to see who plays the lead role. If I were directing, I would cast J-Mac to star as himself!

Many people probably remember hearing about Jason McElwain on the news back in 2006. He scored a record six three-point shots for his high school basketball team. That might not have been outstanding for a superior high school player, but Jason was the team manager, not a first string player. And, in addition to that, he was a young man diagnosed as autistic.

In THE GAME OF MY LIFE, Jason McElwain tells his story. He shares what he recalls from family stories about his early childhood years, unable to communicate or even tolerate his mother's loving touch. Extensive medical testing resulted in a diagnosis of severe autism. With the help of dedicated parents, Jason was able to learn coping skills and manage many of his autistic outbursts. Sports provided a focus point and an outlet for his energy, and ultimately earned Jason his moments of fame.

Jason's unique voice can be clearly heard as he tells his memories of early treatments thought to reduce the symptoms of autism. He explains the frustration of moving from one school to the next as school administrators searched for the best programs to help him. As Jason became interested and involved in a variety of sports, he found not only friends, but also a way to achieve success. Always in touch with reality, Jason knew his skills were adequate but not exceptional, and his success came as a chance to just be part of a team. But with the care and concern of his coach and teammates, his part on the team gave him the chance of his life and memories that have changed him forever.

THE GAME OF MY LIFE is an inspiring story about living with an increasingly common condition. It is an excellent book for teens suffering with autism or connected to someone with the condition. Jason's positive, up-beat personality is refreshing, as well as direct and realistic.

Reviewed by: Sally Kruger, aka "Readingjunky"

This order was handled above and beyond the call of duty. They handled everything, including the problem of USPS losing the package. No questions were asked and the book was reshipped immediately. Thank You for the great service.

This book opened my eyes. I'd finished a Ph.D. in computer science, and had a decent exposure to quite a few programming languages and paradigms, before coming across this book. I was surprised to start working through this introductory book, and find myself learning new things! The book transformed my approach to programming.

From page one, HtDP starts talking about good program design, and gives a methodical approach. Until this, I'd always thought programming books were "here are ten small example programs; go write ten more." That's hardly teaching. But HtDP builds up a straightforward design recipe, to guide programs along. If I get stuck or have a mistake in my program, 90% of the time I realize it's because I strayed from the book's recipe. The approach is language-independent, although some programming environments make it much easier to implement the design recipe; the book provides links to a good (free) Scheme environment, which it uses for its code examples too. (I've come to use that environment day-to-day). My code--in any language--has become much more robust, and when I do have a bug I usually locate it early, thanks to this book.

In addition, HtDP made me think about things I'd taken for granted: How is assignment to a variable fundamentally different than assignment to a structure's field? Even, *why* do I use assignment statements in certain situations, instead of choosing a functional approach? How often do my programs actually need the efficiency of imprecise floating-point arithmetic, vs using bignums which totally liberate me from numerical inaccuracy?

Although the text is available on line, I cherish my hardcopy. This is a book to first learn programming from, and one to revisit every five years.

As a programming do-it-yourselfer I've had many conflicting responses to this text -- it's didactic style, its attention to detail, its sometimes patronizing tone, its rigor and broad scope and at the same time its immersion in minutia and quiddities I have never encountered in 'computer books' I had ever perused. Perhaps it's my liberal arts background, or love 'em/hate 'em sensitivity to all those broad stiff-spined textbooks I had carried in back-packs since childhood, combined with a disdain for the authoritative stilted style these educators exude -- despite their patent love of their subject. I felt at once both patronized and condescended to.
From the very start of their journey into a detailed six step-by-step process that show the reader how to analyze problem statements, how to formulate goals, make up examples, outline a solution, and test a solution the authors proclaim their pedagogical ends: "We [...] believe that the study of program design deserves the same central role in general education as mathematics and English. Or, put more succinctly, everyone should learn how to design programs..." This is not a textbook, this is a revolutionary pamphlet calling for educational reform. I had read nothing like this in the tens of 'Dummies' and 'In 24 Hours' books I had exposed myself to. One part priggish, two parts pedagogic. I often found myself asking for whom was it written? First-year college student?, ambitious would-be high-school programmer wanna-be? Math mavens? Surely not a middle-aged bookish clerk who tastes run more to Turgenev and Dostoevsky than Turing and Dijkstra. But then I demanded more than mere anonymous web-lurking from my lowly pc. I remember myself many years ago trying to learn BASIC on a massive time-share computer and telling myself surely there was had to be more magic to computing than this. Well, after reading more texts and having had to unlearn the 'Dummies' and the 'In 24 hours' style of disinformation I had finally found the marrow of a discipline that is as demanding as any I had ever come across and as vexing as any artistic rigor I had ever been inspired by. Come be confused, come be amused, amazed and intellectually abused. Sorely, if I find I have little talent for this excruciatingly logical endevour, I have also found a full-blown appreciation of such daunting computational cheekiness. Much to learn here, and this is only the "core subject of a liberal arts education." What had I been wasting my time on all those years as a professional student?

I have been professionally developing software for about 5 years. I found this book to be one of the most useful and helpful books to help my coding skills. Even though I have been programming professionally for a few years and have a computer science degree, I learned a lot of new neat concepts from this book. It also helped to me to remind me of all the basic good practices that I have forgotten.

It is also an excellent book for beginners. The books doesn't use a popular programming language like Java to accomplish its goals. Instead, it uses Scheme so the student can focus on the concepts rather than syntax. It also teaches great concepts and breaks the problem down on how to solve various problems. Also it isn't "hardcore" like SICP-- it is very friendly to non-MIT level people.

Great book! I liked the way the author approaches how to begin designing programs. I am half-way through the book and I am finding it very entertaining. Yeap! I recommend this book.

I have to hand it to Mr. Comer and Stevens, they have done an excellent job writing a book that explains everything clearly with very well defined (and actually working) examples.
If you are interested in learning TCP/IP programming on Unix platform this is the only book you need.
It does assume that you have knowledge of some C programming, but it does not assume that you are an expert.
Excellent Book.

I have been using Internetworking with TCP/IP Volume III for almost ten years now to teach a graduate course on client server programming. I think it is perhaps the most perfect textbook ever written. Comer's code is exquisite and can be used to teach clear and efficient coding in C. His explanations are perfect. He says everything that needs to be said, and no more. His presentation about the foundation of all distributed computing is clear concise and on target. Students require some reminders about the fact that this book can't be read like a novel, or like any less competent textbook. They need to read and carefully consider each line. Comer includes everything that is needed in the book and its appendices. In every case, you see very careful and concise statements of how things really work. I just reread his chapter on NFS this morning and was reminded about how he can take the complex and invisible and make it completely understandable.

Professor Comer's books are wonderful, but his contributions don't stop there. If you pride yourself on writing and are new to the academic realm you might find it useful to go to his website and read his advice on writing a dissertation. If you are a PhD student, or a master's student writing a thesis, this should be a mandatory stop. If you are simply a person who takes pride in writing clearly, you will learn important things.

This is a great book and I see why some teachers chose it for grad students. I didn't do well in networks last semester because I had to learn BSD TCP/IP sockets from sources like book snippets my teacher gave me, man pages, and various Internet sources. The textbook I had to buy for class has almost no C code or any explanations about BSD sockets. So, I invested into this and the Richard Stevens (UNIX Network Programming) book. Both are excellent assests.

Pro (This book): I like how it explained what each important function did (like read/write)

Con: The example code could be a little better.

This book is well-written and will be a good reference once I'm through with my class. I bought all 3 volumes since I could get them at a great price. What especially helped: sometimes books would take up to 50 pages explaining a topic. The "Internetworking with TCP/IP" series are excellent at giving the bottom line and at times makes it easier to understand the details within the longer-winded pages of other books. In a way, to me, it's like a set of cliff notes to my textbook.

If you're baffled about network programming, these books might be worth a try.

Get all three volumes. There is no better way to learn TCP/IP. The read is excellent. The examples are very excellent. Definiirly, a classic for years to come.

I used this book from cover to cover in a Unix Socket Programming class. A few good points about this book: 1) The sample do compiled on Linux with no problems. That's a plus. 2) The author emphasized good client-server design principles. 3) The introduction is gentle and very readble. 4) The code sample is directly,simple and not riddled with unnecessary details to "show off" like some authors do.

You don't need much Unix to do exercise in this book.About the only System calls you need to know are fork(),Select(),sigalarm() and execve(). The book could have been expanded to cover HTTP,SOAP and some other protocols to give it a 5stars.

Exactly as described, fast delivery. I will always try to choose amazon from now on.

This book is THE best LP book I have come across. The topics are very clear and presented in the best possible manner. Introduces you to several basic and advanced LP topics, theorems and algorithms. The exercises at the end of each chapter test the students' understanding in an appropriate manner. A good number of examples are given to explain the theory in a better way. I would definitely recommend this book to a student interested in learning about optimization procedures and/or algorithm development.

Surely helps if you have taken a linear algebra course before. Some students who haven't had a linear algebra course find the math nomenclature formidable in the beginning.

This book is impressive for theory, every thing you ever wanted to know or how to avoid some other is here. I teach to industrial engineering students, so i have to use other books for the application, but for the theory, everything is covered here, even more, in the book are several simple rules to avoid tipical problems of the simplex method or transportation problems, or integer forms. You can't call yourself a pro if you haven't read this book.

Most part can be expressed in a more terse way and with math language. However, the book revolve around using very lengthy sentence to explain, which is not so helpful and clear as expressed with math. It can be condensed to half thickness.

The best part of this book is the first half, where the foundations of linear programming are presented in a clear yet relatively rigorous fashion, accompanied by numerous intuitive geometrical explanations of the abstract general concepts. This approach, supplementing mathematics with graphical insights, works extremely well for this topic.

The quality goes down somewhat, perhaps neccessarily, in the latter half of the book as topics are presented less carefully, and in a somewhat rushed manner in order to cover all of the material the authors decided to include. Given that the fundamentals are covered so well, perhaps this is a fair trade.

The only real negative I can think of is that it's a small crime for professors to create their own publishing companies (Athena only publishes works by a small group of MIT professors) and then still charge outrageous amounts for the books. This would be completely unacceptable were it not for the fact that, unlike most self-published work, this book's production quality is on par with that of the large publishers.

I happen to know C++ and this book is quite useful for learning Java, or at least understanding any given Java program. For each Java construct, the book tells what the equivalent C++ construct is or whether it exists at all. In some cases, it also goes the other way -- for each C++ construct, the Java equivalent.

It also covers some Java libraries and briefly outlays applets. There does not seem to be any coverage of servlets or server-side programming.

As good a reference as it is, it seems to be missing some things, most notably initializations. There are pieces of Java code I've seen something like:

subr1(new Foobar {blah(){foo;} blah1(){bar;}});

i.e., a class (Foobar) is being initialized dynamically before calling a function subr1(). The exact circumstances of initialization of variables and dynamic classes are not covered at all in this book.

Other than that, this book is great.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

I picked up this book on a whim, thinking it wouldn't be as good as Java in a Nutshell or Core Java, both of which are excellent books in and of themselves. Surprisingly, this contains a condensed version of most of the information of the above mentioned books. It lacks the extended examples of Core Java, but to a good student and intelligent reader, missing out on a few examples won't break your education.

And like JIAN, there is a good amount of reference material in this book, not with the extended detail of JIAN, but enough to get by most of the stumbling stones one encounters while programming.

As a student, I can only carry so many books in my backpack; when I'm programming in the university labs, I want concise and useful as my qualities. At home, I have my Java reference library (CJ, JIAN, etc.), which I consult when I'm at a quandary; for portability and my lab work, this book is the Swiss Army knife of references, one that I carry regularly, and one that can solve about 75-80% of Java problems I encounter.

The book doesn't teach you Java. It is assumed that you already know Java.
doesn't cover all of Numerical calculus and not all of mathematical proofs but great if you are looking study practical programming with Java.

I recommend this book only if you know Java and have basic numerical knowledge.

This book is an introduction to numerical computing that is both comprehensive and fun. It is not a textbook on numerical methods or numerical analysis, although it shows many key numerical algorithms all coded up in Java. The book examines these algorithms enough that you get a feel for how they work and why they're useful, without formally proving why they work. There are also demonstrations of many of the algorithms with interactive graphical programs. Overall I enjoyed this book a great deal. It is not a beginner's book on Java - you should be a pretty good Java programmer already. Also, you should be at least somewhat mathematically mature for the material past part one. That is, you should have had some Calculus and some Linear Algebra prior to reading the last 3 of the 4 parts of this book. I further describe this book in the context of its table of contents.

Part 1: WHY GOOD COMPUTATIONS GO BAD - Simply copying formulas out of a math or statistics textbook to plug into a program will almost certainly lead to wrong results. The first part of this book covers the pitfalls of basic numerical computation.

Chapter 1 discusses floating-point numbers in general and how they're different from the real numbers of mathematics. Not understanding these differences, such as the occurrence of roundoff errors, and not obeying some basic laws of algebra can lead to computations that go bad.

Chapter 2 looks at the seemingly benign integer types. They don't behave entirely as the whole numbers of mathematics do. Arithmetic operations such as addition, subtraction, and multiplication take place not on a number line, but on a clock face.

Chapter 3 examines how Java implements its floating-point types. The chapter examines the IEEE 754 floating-point standard and shows how well Java meets its provisions.

Part 2: ITERATIVE COMPUTATIONS - Computers are certainly good at looping, and many computations are iterative. But loops are where errors can build up and overwhelm the chance for any meaningful results.

Chapter 4 shows that even seemingly innocuous operations, such as summing a list of numbers, can cause trouble. Examples show how running floating-point sums can gradually lose precision and offer some ways to prevent this from happening.

Chapter 5 is about finding the roots of an algebraic equation, which is another way of saying, "Solve for x." It introduces several iterative algorithms that converge upon solutions: bisection, regula falsi, improved regula falsi, secant, Newton's, and fixed-point. This chapter also discusses how to decide which algorithm is appropriate.

Chapter 6 poses the question, Given a set of points in a plane, can you construct a smooth curve that passes through all the points, or how about a straight line that passes the closest to all the points? This chapter presents algorithms for polynomial interpolation and linear regression.

Chapter 7 tackles some integration problems from freshman calculus, but it solves them numerically. It introduces two basic algorithms, the trapezoidal algorithm and Simpson's algorithm.

Chapter 8 is about solving differential equations numerically. It covers several popular algorithms, Euler's, predictor-corrector, and Runge-Kutta.

Part 3: A MATRIX PACKAGE - This part of the book incrementally develops a practical matrix package. You can then import the classes of this package into any Java application that uses matrices.

Chapter 9 develops the matrix class for the basic operations of addition, subtraction, and multiplication. It also covers subclasses for vectors and square matrices. The chapter's interactive demo uses graphic transformation matrices to animate a three-dimensional wire-frame cube.

Chapter 10 first reviews the manual procedure you learned in high school to solve systems of linear equations. It then introduces LU decomposition to solve linear systems using matrices. An interactive demo creates polynomial regression functions of any order from 1 through 9, which requires solving a system of "normal" equations.

Chapter 11 uses LU decomposition to compute the inverse of a matrix efficiently and reliably. A demo program tests how well you can invert the dreaded Hilbert matrices, which are notoriously difficult to invert accurately. The chapter also computes determinants and condition numbers of matrices, and it compares different algorithms for solving linear systems.

Part 4: THE JOYS OF COMPUTATION - The final part of this book covers its lighter side of numerical computation.

Chapter 12 covers Java's BigNumber and BigDecimal classes, which support "arbitrary precision" arithmetic--subject to memory constraints, you can have numbers with as many digits as you like. This chapter explores how these classes can be useful. You compute a large prime number with more than 3,000 digits, and you write functions that can compute values such as the square root of two and e^x to an arbitrary number of digits of precision.

Mathematicians over the centuries have created formulas for computing the value of pi. Enigmatic Indian mathematician Ramanujan devised several very ingenious ones in the early 20th century. An iterative algorithm supposedly can compute more than 2 billion decimal digits of pi. Chapter 13 uses the big number functions from Chapter 12 to test some of these formulas and algorithms.

Chapter 14 is about random number generation. A well-known algorithm generates uniformly distributed random values. It examine algorithms that generate random normally distributed and exponentially distributed random values. The chapter concludes with a Monte Carlo algorithm that uses random numbers to compute the value of pi.

Mathematicians have mulled over prime numbers since nearly prehistoric times. Chapter 15 explores primality testing and investigates formulas that generate prime numbers, and it looks for patterns in the distribution of prime numbers.

Chapter 16 introduces fractals, which are beautiful and intricate shapes that are recursively defined. There are various algorithms for generating different types of fractals, such as Julia sets and the Mandelbrot set. In fact, Newton's algorithm for finding roots, when applied to the complex plane, can generate a fractal.

I have got hold of this book just recently. This is an excellent book on numerical computing using Java that covers many important aspects in numerical computing. I have been writing numerical methods in Java back in graduate school as well as in my professional career for mission critical programs. I must say this book has addressed many issues that must be taken into account such as machine epsilon, choices of numerical methods for different problems, limitations and precautions in using different data types, etc in Java in which if taken for granted, would produce disastrous results.

Ronald Mak has taken the trouble to explain IEEE floating point standards in a fun and easy-to-understand manner.

Another thing about this book that is worthy of a mention is its great OO programming styles. Codes are also well commented and reader friendly. Overall, it is a great source to learn not just on how to program numerical methods in Java but how to write good OO programs.

The only two bad things I could say about this book is that I should have gotten of this book much earlier and if only Amazon allows a Six Stars rating.

As the author says, last time I looked Java still had the +, -, /, * and % mathematical operators.. though most programmers end up forgetting it lost as they are in the boring, vulgar and repetitive coding of boiler-plate "enterprise" (read "sell sell sell") applications. This book does a very good job of introducing a Java programmer to one of the most fun and interesting powers that Java can offer ... that is playing with numbers and exploring the world of mathematics. Forget (at least for a little while) Servlets, JSP, EJB, and database massaging... and give a look to how you can use your JDK to study functions, solve differential equations, integrals, system of equations, discover prime numbers and admire the beauty of fractals. The treatment of the various subjects is done is sufficient detail to be clear and sound, but without burderdening the reader
with detail and depth best left for more specialized and hard-core texts that the curious reader can explore after this one. Refreshing.

At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.

This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.

The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.

The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.