2 comments about Alice in Action with Java.

1. This book is very well written and contains detailed, step by step, visual instructions which are easy for introductory students to follow. I used this book as a supplement in my introductory programming class. The students were able to follow and surpass the requirements for the class.



2. Off all the Alice 2.0 texts - this is, in my opinon, the best. It goes directly to Java when the (many) Alice flaws start to cause problems.

5 comments about PgMP: Program Management Professional Exam Study Guide.

1. In considering any of the guides out on the market, you need to account for the fact that the PGMP test has not been around very long. That's why Rita Mulcahey, who guarantees results, hasn't got a PGMP course out yet, which should tell you something right there.
   
   This book actually suffers from an effort to walk the tightrope between being a useful operational program managers' guide and an exam prep book. The author has come down on the side of the exam, but unfortunately the actual exam is not like the PMP exam against which this book is structured.
   
   The text provides a map (at a very high level) to the PMI exam structure specification, but that is more than a bit of a stretch. I spent many hours searching for references to the specified material in the chapters that claim to address them, and in about 50% of the cases there is either nothing there or a sentence that you can twist in that direction if you are trying to do so. More importantly, the examples and sample questions in both the book and the accompanying CD, because they follow the PMP format of "what sub-process belongs to what process", are completely irrelevant to what you will find on the actual exam.
   
   The PGMP exam is not about the PMI standard - it is a whole lot of mini-scenarios, some of which are somewhat realistic and some are very contrived. You'll find questions that are a whole lot more like the exam in the Letavec-Rollins-Altwies book; but that book doesn't provide much of a study framework either, which is presumably what you were hoping for in an exam prep book.
   
   When an exam costs $1500 to take, a couple of hundred on the prep materials is a reasonable risk reduction strategy. I used several books, hoping to mitigate the $1500 risk I was taking, but in fact none of the materials on the market that I found (as of July 2008) have much to do with the exam (including the PMI standard and specification). The grim reality is that if you are even thinking about spending this kind of time and money to take this exam, you can probably pick out enough of the obvious school-solution answers to get to 50% and your experience will take you the rest of the way. If you do not have that experience, or if you do but you're just not a good test-taker, you're not going to enjoy this exam.



2. I'm a trainer in the fields of project management and program management and have found this book as the best not only for PgMP exam preparation but also for learning the basics of program management.
   First, for the PgMP Exam:
   The best strength of this book is that it follows and covers the official exam specifications by PMI very closely and thoroughly. Yes, if you have time you can go through different references such as, Program Management Standard (which you should go through any way), and relevant parts of other references such as PMBOK Guide 3rd Edition, OPM3 model doc, and some other references to learn the material covered by the PgMP exam as specified in the exam specifications. You can take the relevant pieces of information from these different resources and references and put them together, but it will take a lot of effort. This book integrates these pieces of information together in a seamless fashion. So, it's a great time saver.
   Bottom line: this book gives you the body of knowledge that the exam covers. That siad, no book can be a substitute for your experience. To pass the PgMP exam, you need the body of knowledge presented in this book PLUS your experience.
   Second, the program management:
   I agree with another reviewer that this is the first real book on program management (other than the program management standard, of course) that clearly distinguishes program management from project management and presents the relationship between them in a clear way. The basic concepts of program management are explained in a very clear way and the author offers comprehensive coverage in a cohesive fashion. I love the author's style of presentation. It makes learning easier and fun.



3. I like Paul's style very much, so it's a good book for me. The major problem with this guide is the practice questions. I have not taken the PgMP exam, but I expect it to be even more scenario based than the PMP exam. Paul's practice questions are way too old style, memory regurgitation types. The CD replicates the questions in the book, and the final exams replicate the chapter questions, in the memory regurgitation style.
   This is a bad sign I think, because to pass the PMP exam, wannabes need to do a lot of good quality practice questions that are scenario based. I am sure this will be true of the PgMP as well.
   The book does include the content needed to pass, and I like his style.
   Jim SLoane, PMP, OPM3CAC, CM



4. To me, this book is an order to a perfect chaos of PGMP material. What I mean that the material required for the PgMP exam is scattered in bits and pieces across several references such as Program Management Standard (full), PgMP Exam Specifications (full), PMBOK 3rd Edition (pieces), Maturity models (pieces), and so on. This book integrates all the pieces seamlessly at one place, and by connecting the different concepts to each other creates a beautiful big picture of program management that makes sense. The author adds tons of value to the standard pieces. I commend the author for that. I personally don't care if the questions are easy or difficult (nothing is going to substitute for our experience); but the book presents the material required for the PgMP exam in an excellent way. I have gone through many program management books; none of those even come close to this remarkable book...Books like this one don't come that often...Exam or no Exam this book is a keep; a must have...
   Recommended highly.



5. I've read this book from cover to cover and the PgMP exam? Tough! Been there, done that. My recommendation: this book is a must to prepare for the exam just like the Program Management Standard is. I'm puzzled at a couple of harshly negative reviews about this book: useless, waste of time, dry? These words do not describe this book....I have read other books from Dr. Paul Sanghera as well, and I love his style that puts life into even dead boring topics and make them interesting. Same is true about this book. All concepts are explained well and woven together, and there is a perfect logical flow...it's almost like reading a story... If the inputs and outputs for a process are re-organized to help you make sense, and explained why they are there, I think it's a feature and not a problem...
   
   I do agree however that the questions in the exam are much more difficult than the one in the book, but the book presents the material that you must know before taking the exam...In the exam, of course, your experience will count..no book can substitute for that...This material can be obtained from different references, scattered around...but the book does an excellent job to put all the pieces together and integrate them seamlessly... The author should be congratulated for that...Another great PLUS of this book is that it"s organized along the official exam specifications.
   Actually I would recommend this book even if you are not planning to take the exam; it's a great program management book, too.. All program managers should have it on their desk. Program Management Standard will make much more sense after reading this book.

5 comments about HTML for Dummies.

1. A few years ago I wanted to learn basic HTML. I figured the best way to do this was to buy "HTML For Dummies" and use it to set up a basic Web site for my church. That way I got both theory and hands on practice. This is exactly what I did, and the book came through for me. I learned enough HTML to set up a basic, but working, Web site for my church.
   
   The only thing I wanted to learn but never could figure out from the book was frames. I settled on tables for navigation since all my attempts at frames failed.
   
   I have since gone on to do a Web site for my cats, a text based site on the subject of the Sabbath, and a Web site to track my weight loss and measurements. I even coded my own little blog at one point.
   
   The next thing I want to learn is some basic CSS to have better control over the Web sites I've created.
   
   I recommend this book to anyone who doesn't know anything about HTML and wants to learn it.



2. I ordered this book along with Web Design for Dummies expecting to get started writing simple web pages. These books are not for dummies. It offers very little explanation of html tags; it doesn't offer pros or cons of the tag usage vs. another tag; examples are not near the explanation-you need to open the cd to view the eample in question. It spent too much time promoting tools and services outside of the "Dummy" concept.
   
   I was very disappointed with this book...I bought another book which out-performed the Dummy series.



3. This is a very user friendly book.
   On another note, I am impressed with the speed that I received my books.
   Thank you Amazon



4. Well I /was/ originally looking greatly forward to this book. I had been a fan of the "... for Dummies" books for a while now. Unfortunately I found this one to be a disappointment. Although I can appreciate having sections on good web page design, I felt it was too much to wait until chapter 4 to code your first page. Plus, there's just too much design-based content in the book overall, and not enough of actual HTML tag-based exercises.
   The examples on the CD ROM are awful. They really don't give any good insight as to how the tags work. Plus, many of the example files are identical. For example, TFOOT.HTM, THEAD.HTM and TR.HTM are the exact same file. That's just inexcusably lazy. How hard could it have been to exhibit some of the attributes of those tags?
   I give it two stars because if you already know HTML, it can be a pretty useful reference. Also, the troubleshooting chapter (chapter 16) was pretty good.



5. I'm never disappointed with Dummies books and this one is no exception. Great read, easy to learn.

5 comments about Oracle JDeveloper 10g for Forms & PL/SQL Developers: A Guide to Web Development with Oracle ADF (Osborne Oracle Press Series).

1. This is an excelent book for begining web development, it explains you step by step how things work and "glue" together. The only reason for me to give it 4 stars is that, in the book it explains how to build part of an application (tuhra) and it tells you to look for the rest (of the app.) on the web site..... I looked for it but it is nowhere to be found... (they only have the parts of the app. that you develope while doing the books excercises).



2. Great



3. exellent Book
   
   Goods Tips for programming Oracle ADF
   
   greetings from Toluca, EdoMex, Mex.



4. Being a traditional pl/sql developer, I was drawn to the title of the book immediately. I know I need to eventually buckle down and learn Java, but what better way than by drawing parallels to pl/sql and Forms.
   
   I like the hands-on examples that has you build a fairly complete application from scratch. I say fairly complete because its only a 500 page book and it allows the reader to go out and research ways to improve it.
   
   One of my favorite parts of the book is a summary section that shows up after a large chunk of instructions called "What did you just do?" This sums up what the reader just performed - explaining in layman's terms what you actually just did.
   
   Although I'm sure you can get similar tutorials on OTN somewhere, having a book to flip back through is always nice.



5. this book is ok.
   just like all other oracle books, they just "talk too much"..
   to much junk and too little meat...
   almost feel like they are putting in too much filler to make it to a
   500-600 page book....
   if you get the class notes from oracle's classes...it's much more compact
   and to the point.
   Too bad there is not much other jdeveloper book out there.

No comments about Programming with Microsoft Visual Basic 2005: An Object-Oriented Approach.

5 comments about AI Game Programming Wisdom (with CD-ROM) (Game Development Series).

1. "Artificial Intelligence" means different things to different people. One useful application is the control of nonplayer characters (NPC) in video games. This is the first book to address this field. Like any collection of papers, it is uneven and does not systematically cover the subject. It should be read in conjunction with a traditional AI text, such as Murphy "Introduction to AI Robotics", Russell and Norvig "Artificial Intelligence: a Modern Approach", Tom Mitchell "Machine Learning" or perhaps Bruce Blumberg's forthcoming "Synthetic Characters".

   I teach AI at DigiPen Institute of Technology and made this one of the required books. It is good in showing which techniques are most useful in games and what you need to consider when designing your AI. Some papers are overly general and some are too specific. That's probably unavoidable, but game programmers can pick and choose the most appropriate ideas. Unfortunately, some of the better introductory articles on A*, finite state machines, flocking and fuzzy logic are not in this book but in "Game Programming Gems".

   Once you understand the basics of AI, this book can save some major headaches by helping with the selection of an appropriate architecture. The CD has source code to help you get off to a good start. Reading the appropriate articles will let you anticipate problems before they happen and design around them. Professional game programmers will likely find at least one technique that pays back the cost of the book.




2. Published by the same folks who brought you Game Programming Gems (and edited by one of the more prolific AI authors in that series), AI Game Programming Wisdom provides a wealth of real knowledge by actual game programming professionals, not professional authors. As a game programming professional, the number of game programming books that sit on my shelf is fairly small. Most have nothing interesting or meaningful to offer beyond rudimentary descriptions and concepts.

   AI Wisdom is definitely a cut above the rest. The topic selection is intelligent and relevant, and the articles are all of a consistent quality and polish. I've already referenced articles several times when writing production code, and several co-workers have borrowed it when they had a particularly tricky problem to solve. This is simply a must-have resource for any professional AI programmer, period. Or, if you're an amateur or hobbyist looking to see the tricks and techniques professionals use, then this is a book you absolutely can't afford to miss.




3. Being in the game development business, I am always on the lookout for new and different tricks, techniques and strategies. When most programmers go to the lectures, panels and roundtables at the Game Developers Conference, we are looking to pick up this same sort of material... we share ideas and approaches - but rarely get the chance to get down to the code details to make it easy for us to implement those ideas into our own work. This book makes that possible.

   Along the lines of the other "Gems" series of books, this collection is filled with ACTUAL techniques and code chunks that are used by some of the top professionals in the industry. Just flipping through the list of the contributors to the book is like going around the room at one of the AI roundtables at the GDC... in fact, Steve Woodcock and Neil Kirby are 2 of the "3 AI guys" that RUN those roundtables! (The 3rd being Eric Dybsand who has contributed to the "Gems" series but not this title.)

   Many books on game development are informative. This one is actually USEFULL. I have personally adopted Steve Rabin's source code from the section "Implementing a State Machine Language" into my own game and it has saved me many hours of development and improved the readability and understandability of my code for the rest of the team. Just that section alone has netted at least a 1000:1 return on the cost of this book. Other sections have given me a different approach on how to handle the economic strategy layer that I could have come upon myself... but was able to implement a lot quicker than if I had done it myself. It was definately worth the price.

   Are any of these sections worth the purchase price for YOU? I suppose that depends on how much you value you your time. Once you equate the cost of the book to the man hours you save, it's a no brainer!




4. This is the best book in my library.
   Write by professionals, with usefull techniques and well explained details of almost every cool aspects of AI in the game programming world.



5. It's hard to find good information about game programming and design. The trouble is that people working in the industry have an incentive to keep their techniques secret -- they don't want their competitors to learn them. The people who aren't in the industry can write about games but don't have the experience to back it up.

   Game AI Programming Wisdom gives us wisdom from people who have worked on real games. Each section is a short explanation of a particular problem (like pathfinding, tactical reasoning, or pattern recognition). Since they're short and independent, you can pick the section that applies to the problem you're trying to solve and read that without having to read everything in order. However, each section is written by a different person, so if you try to read the book straight through you will be distracted by the change in writing styles and level of detail.

   I'm quite glad to see this book. It's actually the first game programming/design book that I purchased. (I'm quite picky when it comes to books. I'm sure Amazon doesn't like that.) Most of the game books I see go into low level programming details. This book teaches you the principles and techniques that will be useful for more than the specific problems they cover.

5 comments about OpenGL(R) Shading Language (2nd Edition) (OpenGL).

1. The OpenGL Shading Language is without doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. As one of the primary contributors to the development of the language, Rost provides a clear and well-written explanation of the language and how to use it.
   
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
   
   The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
   
   If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.



2. Twenty years ago, I used to program graphics on an Evans and Sutherland PS340. It was then one of the top of the line graphics computers (costing $100k). It could labouriously do shading, but only Phong and Gouraud. Nowadays, many PCs have this ability, and much faster. But a problem still persists, where often the shading methods are restricted to what is implemented on the graphics chips.
   
   In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
   
   The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
   
   Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
   
   Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.



3. The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex (e.g., vertex processing and fragment processing). The OpenGL Shading Language has been designed to allow application programmers to express the processing that occurs at those programmable points of the OpenGL pipeline. Independently compilable units that are written in this language are called shaders. A program is a set of shaders that are compiled and linked together. The OpenGL Shading Language is based on ANSI C and many of the features have been retained except when they conflict with performance or ease of implementation. This shading language is without a doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. The author was one of the primary contributors to the development of the language, and he provides a well-written and insightful explanation of the language and its use.
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
   I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
   Chapter 1. REVIEW OF OPENGL BASICS
   OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
   
   Chapter 2. BASICS
   Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
   
   Chapter 3. LANGUAGE DEFINITION
   Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
   
   Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
   The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
   
   Chapter 5. BUILT-IN FUNCTIONS
   Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
   
   Chapter 6. SIMPLE SHADING EXAMPLE
   Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
   
   Chapter 7 OPENGL SHADING LANGUAGE API
   Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
   
   Chapter 8. SHADER DEVELOPMENT
   General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
   
   Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
   Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
   
   Chapter 10. STORED TEXTURE SHADERS
   Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
   
   Chapter 11. PROCEDURAL TEXTURE SHADERS
   Regular Patterns; Toy Ball; Lattice; Bump Mapping;
   
   Chapter 12. LIGHTING
   Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
   
   Chapter 13. SHADOWS
   Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
   
   Chapter 14. SURFACE CHARACTERISTICS
   Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
   
   Chapter 15. NOISE
   Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
   
   Chapter 16. ANIMATION
   On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
   
   Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
   Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
   
   Chapter 18. NON-PHOTOREALISTIC SHADERS
   Hatching Example; Technical Illustration Example; Mandelbrot Example;
   
   Chapter 19. SHADERS FOR IMAGING
   Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
   
   Chapter 20. REALWORLDZ
   Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
   
   Chapter 21. LANGUAGE COMPARISON
   Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
   Appendix A. Language Grammar
   Appendix B. API Function Reference



4. I'm not a fan of the 'group of papers' style of book. But this book pulls it off nicely. The text is consistenly good throughout. And the illustrations and formulas are high quality and presented nicely.
   
   I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.



5. I definitely recommend this book for anyone working with OpenGL's new Shading Language. I would, however, say that probably the most difficult part of working with GLSL is getting it working in the first place. Especially on Linux, this is somewhat confusing - some cards support GL 2.0, some don't, but still support the GLSL if using the ARB function calls. I would also make sure to point out to new users that GLEW is close to essential when working with the GLSL - you can download it from sourceforge. It might be worth mentioning in future versions of the book, along with ARB functions which are the same as the GLSL standard functions shown in the book.

5 comments about A First Course in Finite Elements.

1. I bought this book based on the authors (Mr. Belytschko) reputation, having seen him make impressive presentations at various conferences. This book, however, is very dissapointing. Its the standard FEA theory rehashed and rolled out again - and not even presented well. There is nothing new or original about this book - there is little or no practical advice and the theory can be found in any other FEA book. Perhaps the only good thing about this book is that you get a studnet copy of Abaqus and one tutorial included, otherwise a waste of money.



2. This book is an excellent introduction to FEM particularly for undergraduates, or anyone who were not previously exposed to FEM ideas. While there are a large number of books on FEM out there, many of them require quite a bit of understanding of continuum mechanics, pde solution methods, etc. and may easily overwhelm undergraduate audience. This book provides all the essentials needed to have a fundamental understanding of FEM and equally importantly, be able to write simple codes and use Abaqus to solve problems. The authors of the text are two of the best and most famous researchers in the subject, making the text all the more insightful.



3. This book is very well written by two top experts in the field. The authors clearly explain the theory and give practical examples that are easy to follow. The chapters are well organized leading the reader from structural analysis of trusses to multi-dimension problems in Elasticity. The last chapter (available on the web) contains MATLAB codes for the examples solved in the book which the reader can easily modify for his/her needs. On top, the book also comes with ABAQUS CD for students including a self contained tutorial.
   All in all, I strongly recommend the book for first time readers. It is definitely worth the bang for the buck!



4. I found the book "A First Course in Finite Elements" very clearly
   written and pedagogically sound. It has a very nice blend of theory and implementation of the finite element method written by two
   leaders (J. Fish and T. Belytschko) in the field. It provides a
   lucid and logical introduction to
   (1) Direct approaches for discrete systems,
   (2) Strong and weak forms for 1-D problems,
   (3) Quadrature,
   (4) FE formulation,
   (5) Strong and weak forms for multidimensional scalar field problems,
   (6) Approximations of trial solutions, weight functions,
   (7) FE approximations for vector field equations and
   (8) FE formulations for beams. The text is an excellent reference, that
   will be added to the course syllabuses this year for both a senior
   undergraduate Finite Element class and a first year graduate class that
   I teach at UC Berkeley. The book provides a clear and concise introduction
   and very well-thought-out overview, to this very large field, and I strongly recommend it to students and instructors that are looking for a modern introductory Finite Element textbook.



5. The book is intended as an introductory course on the finite element analysis for undergraduate and graduate students. It is written very clearly, so the material could be comprehended by the target audience. At the same time one of the chapters of the book is dedicated to the commercial finite element program, allowing students to understand how finite element method could be used for solving real life engineering problems. Student version of Abaqus is included in the book, which allows students to experience the entire process from creating a model to viewing and analyzing the results.

No comments about LINQ Unleashed: for C# (Unleashed).

4 comments about Introduction to Neural Networks with Java.

1. I have received my copy of the book and I can't put it down. It has been great help with my AI research at the University. I have the other book from the same author "Programming Spiders, Bots and Aggregators in Java" and I have the same comments for both. Both are easy to read, have precise information and great code. Chapter 7 of this book "OCR with Kohonen Neural Network" makes the book more than worth it. Great stuff. I hope the author does not stop and keep writting books like these. I recommend this book for anyone interested in learning AI and also experienced programmers alike. The author makes though topics seem easy. Highly recommended.



2. Programming Neural Networks in Java will show the intermediate to advanced Java programmer how to create neural networks. This book attempts to teach neural network programming through two mechanisms. First the reader is shown how to create a reusable neural network package that could be used in any Java program. Second, this reusable neural network package is applied to several real world problems that are commonly faced by programmers. This book covers such topics as Kohonen neural networks, multi layer neural networks, training, back propagation, and many other topics. The content of the book is as follows:
   Chapter 1: An Introduction to Neural Networks
   The structure of neural networks will be briefly introduced in this chapter. Also discussed is the history of neural networks, since it is important to know where neural networks came from, as well as where they are ultimately headed. Finally, there is a broad overview of both the biological and historic context of neural networks.
   Chapter 2: Understanding Neural Networks
   A neural network can be trained to recognize specific patterns in data. This chapter will teach you the basic layout of a neural network and end by demonstrating the Hopfield neural network, which is one of the simplest forms of neural network.
   Chapter 3: Using Multilayer Neural Networks
   You will see how to use the feed-forward multilayer neural network and two ways that you can implement such a neural network. The chapter begins by examining an open source neural network engine called JOONE. JOONE contains a neural network editor that allows you to quickly model and test neural networks.
   Chapter 4: How a machine learns
   Every learning algorithm involves somehow modifying the weight matrices between the neurons. This chapter examines some of the more popular ways of adjusting these weights.
   Chapter 5: Understanding Back Propagation
   This chapter examines one of the most common neural network architectures-- the feed foreword back propagation neural network.
   Chapter 6: Understanding the Kohonen Neural Network
   The Kohonen neural network contains no hidden layer. The Kohonen neural network differs from the feedfroward back propagation neural network in several important ways. This chapter examines the Kohonen neural network and how it is implemented.
   Chapter 7: Optical Character Recognition
   This chapter develops an example program that can be trained to recognize human handwriting. It is not a program that can scan pages of text. Rather this program will read character by character, as the user draws them. This function will be similar to the handwriting recognition used by many PDA's.
   Chapter 8: Understanding Genetic Algorithms
   A chapter on an AI technology unrelated to neural networks.
   Chapter 9: Understanding Simulated Annealing
   A second AI technology that can be used to train neural networks.
   Chapter 10: Eluding Local Minima
   One of the most fundamental flaws is the tendency for the backpropagation training algorithm to fall into a "local minima". A local minimum is a false optimal weight matrix that prevents the backpropagation training algorithm from seeing the true solution. This chapter shows how to use certain training techniques to supplement backpropagation and elude local minima.
   Chapter 11: Pruning Neural Networks
   This chapter examines several algorithms that modify the structure of the neural network. This structural modification will not generally improve the performance of the neural network, but makes it more efficient. If a particular neuron's connection to other neurons does not significantly affect the output of the neural network, the connection will be pruned.
   Chapter 12: Fuzzy Logic
   Fuzzy logic is a branch of AI not directly related to the neural networks examined so far. Fuzzy logic is often used to process data before it is fed to a neural network, or to process the outputs from the neural network. Fuzzy logic is examined in reference to removing SPAM from emails.
   Appendix A: JOONE Reference
   Appendix B: Mathematical Backgrounder
   Appendix C: Using the Examples on a Windows System
   Appendix D: Using the Examples on a UNIX System
   This book is currently available online. Since Amazon throws out reviews with web addresses in them, suffice it to say that you just need to type "HeatonResearch" into Google. The 2nd address is the one you want. This book couples accessible instruction with plenty of code that you can lift to make your own neural network applications. I highly recommend it.



3. I have been reading through the book. Actually it provides very clear explanations, but I had the impression the author talks too much and keep saying the same things over and over again. The book could be half its volume with the same content of knowledge. Besides the provided examples are a bit too simple and obvious.
   Nothing much to put under the tooth. After reading it I felt left with my hunger for something deeper and more consistent. The algorithms provided also merely implement and stick to the few examples introduced. On the course of the book, the author wanders from the main point which is first and foremost to discuss neural networks under all angles. He unexpectedly brings up Fuzzy logic and Genetic algorithms which is not what the book title purports to talk about: a bit of confusion.
   Overall there is a bit of deception, but indeed the book does what its title says : it is really just an "introduction" to Neural Networks with Java and nothing more. I would recommend it to somebody seeking to embrace the field and who is really a beginner in the domain.



4. Very nice introduction to NeuralNetworks and how to implement them in Java.
   If you're looking for deep concepts on NeuralNetwork this isn't the best choice.
   But if you're looking to figure out how NeuralNetwork works and how to begin codeing them that's it.