Programming Languages Books

When software development moves to embrace agility, project managers can struggle over the new approach and their roles. That's where The Software Project Manager's Bridge to Agility comes in, making it a top recommended pick for business and IT technology collections alike. It covers techniques, transition points, learning to trust teams and use agile techniques to reduce risk, and more. Even more essential are chapters on avoiding common mistakes, and coordinating efforts with project management and non-agile teams.

This excellent book is targeted directly at Project Management Professionals (PMPs) but will be extremely beneficial to any project manager who is interested in agile development. After three short chapters that introduce the general principles and activities of an agile software development project, the authors attack the meat of their subject. Each of the nine chapters of part two corresponds directly to one of the PMI's project management knowledge areas.

Sliger and Broderick, each an experienced PMP, cover the changed responsibilities of the project manager transitioning to agile. A highlight of each chapter is the small table with columns for 'I used to do this' and 'Now I do this' that succinctly summarizes the often profound differences between traditional and agile project management.

This book is necessary reading for any project manager making the change to agile as well as for any ScrumMaster or agile coach working on a large projects. The book takes a giant stride toward dispelling the myth that the only role for project managers is to buy pizza and soda and get out of the way.

When I saw this book, I knew I had to read it, though I was very skeptical about it. Mapping the PMBOK practices to agile practices, is that the right thing to do? Why would you want to do that? What are the authors trying to prove?

The first chapter already helped me forward and removed some of my skepticism. This book is really what is says it is. It's a bridge for the traditional PMI project manager to understand what the difference is between traditional projects and agile projects and it's written in the language of a traditional project manager, the language of PMBOK. From that perspective, I've come to see this as an smart and important book thatm hopefully, will help lots of trainer project managers to understand what agile development is trying to do and why.

The book start with an introduction by Stacia, who describes her experience moving from a traditional environment to an agile environment and the difficulty she faced of changing the way of working she was used to. An excellent introduction that sets the tone of the rest of the book.

The rest of the book consists of 3 parts (plus some appendixes). The first part is the "standard introduction" part in which Agile development gets introduced, in which the first mapping of Agile development to the PMBOK is made and ends with a chapter on a generic agile lifecycle model, which is a guideline for the rest of the book.

The second part is the main part of the book and is structured around the different chapters of the PMBOK. This part actually maps to the PMBOK even on sub-chapter level, done quite well. Within each of the PMBOK chapters, the authors explain the problems the PMBOK tries to solve and how Agile practices solve the same problems, but in a different way. It summarizes this in every chapter with a comparison between traditional practices and Agile practices.

All the chapters seem to cover all the major agile project management practices. It starts with integration management and discussing how all things integrate together and how changes are managed. From there it moves to scope control and explains the differences between traditional WBS task breakdowns and working in a more feature-based way. Time management is next, covering the different planning cycles in the generic agile lifecycle framework (they introduced in Chapter 3). Next is cost management, and quality management. Chapter 9 covers human resource management and was a really nice chapter in which the authors describe well the difference between traditional project resourcing and trying to work with fixed teams that can actually learn new skills when needed. By this time, I felt the major topics had been covered, but there still needed to be communications management and Risk Management to make the mapping of the PMBOK complete. Here I felt the authors started repeating things that were covered earlier, but thats the risk when copying a fixed structure. The last chapter in the PMBOK mapping is procurement management and this chapter was a disappointment to me. The authors are of opinion that there is not much difference in this area, while personally I would not agree with that. Anyways.

The third part covers "the rest" with the main chapter probably be 13 which discusses about the changes in responsibilities between a traditional project manager and an "agile project manager". It describes in fairly much detail the changes in behavior and even tries to cover how to get past this difficult change and why people would want to go through the change (whats in it for them). Also chapter 15 answers one important question: What to do with the PMO. The authors suggest transforming it into an agile supporting organization which they still call "Agile PMO".

Chapter 16 (Selling benefits of Agile) and Chapter 17 (Common Mistakes) are useful chapters for people who are driving the change. It helps them answer some of the common questions and deal with some of the resistance. These chapters conclude the book.

In many areas, I'm still skeptical and do not always agree with the authors. I don't know if it's a good idea to change peoples and organizations role and still keep the old name, like "agile project manager" and "agile PMO". Scrum has solved this by simply calling it different: when the behavior is different then also call it different. Hence the ScrumMaster. Also, the authors strongly stick to the "project thinking" and seem at assume that thats a good way of a managing work. Same with contracts, the authors don't seem to think there will be much change in that area. The book has not convinced me the PMBOK is a good idea either, instead just confirmed my earlier criticism.

All tht said. Realistically, I understand that much of these aspect will not change or not quickly. So, this book introduces new concepts in a familiar language. I do think this will be needed and the authors done a great (perhaps the best possible) job in explaining agile concepts in traditional terms without losing it's meaning. This was the purpose of the book and it certainly succeeded in that.

For project managers looking at agile development, this book is an absolute must.
For agilists, the book is still a good and useful read! (also to understand traditional thinking)

Great work!

Finally a book in the agile series that acknowledges agile and PMI are compatible. As a PMP and CSM, one of my long time frustrations has been too many agile authors create a stereotype of an overly bureaucrat waterfall process being managed by a dictator project manager. That may be a great way to sell their books, but their rejection of sound project management principles has been a disservice to the industry--the classic mistake of throwing out the baby with the bathwater.

As the title states, Sliger and Broderick sets out to bridge this divide and does a super job showing how agile management practices fit into the project management body of knowledge (PMBOK). They reinforce this message with extensive quotes from the PMBOK that explicitly address incremental and iterative development. I especially like their chapter summaries which compare and contrast project manager approaches to specific practices under a plan-driven and an agile project. One of their key messages is that project managers should allow the team to focus on the current iteration, allowing the project managers to focus on removing impediments to future work. This is sound advice no matter what development framework you are using.

Sliger and Broderick discussion on how agile is being extended to product and release planning and how it's adapting to interfacing with PMOs and non-agile teams is also very relevant. While agile purest reject such notions, these are issues that my clients are facing today. Sliger and Broderick succinctly summarize the current thinking on agile product and release planning and provide sound advice on adapting agile to meet these real-world needs.

One shortcoming in the book is that the authors imply that agile is the silver-bullet that should always be used. I wished they would have acknowledge that while agile methods are appropriate in many situations; plan-driven methods are the appropriate choice for other situations. (See Balancing Agility and Discipline: A Guide for the Perplexed by Barry Boehm and Richard Turner)

I highly recommend this book and will be adding to our seminars reference lists. It is especially useful to experienced project managers. As the product description (see above) states they often struggle while transitioning to agile. However, I don't think they are doubtful about the approach, but instead are confused by the hype they encounter. It will also be useful to agilest who starting to see through the hype in other books. Sliger and Broderick have cut through the hype and reinforce the point that effective project management principles still apply.

This excellent book is targeted directly at Project Management Professionals (PMPs) but will be extremely beneficial to any project manager who is interested in agile development.

After three short chapters that introduce the general principles and activities of an agile software development project, the authors attack the meat of their subject. Each of the nine chapters of part two corresponds directly to one of the PMI's project management knowledge areas. Sliger and Broderick, each an experienced PMP, cover the changed responsibilities of the project manager transitioning to agile. A highlight of each chapter is the small table with columns for "I used to do this" and "Now I do this" that succinctly summarizes the often profound differences between traditional and agile project management.

This book is necessary reading for any project manager making the change to agile as well as for any ScrumMaster or agile coach working on a large projects. The book takes a giant stride toward dispelling the myth that the only role for project managers is to buy pizza and soda and get out of the way.

This book is the best book on software project management available for three reasons: (1) it talks to the basics of what makes a successful project and manager, (2) it describes what does not work in a software project, and (3) it walks through practical steps that can be used on real software projects to solve real process problems through the complete life cycle. The book is well written, concise and does not subscribe to any fad methodology or proscribe any silver bullet solutions (smart work and attention to detail are the only effective methods). In fact, the author spends much time debunking industrial myths. There is a good section on cookbook solutions and an example project included as a learning tool. I use this book on the job and highly recommend it.

Unlike most text books, it is a very easy to read book allowing one to read it from cover to cover. The book is an excellent source for novice project managers who need a guide to the many aspects that come with the job. Personally I refer to it often for suggestions on which documents I should produce or what actions to take while managing a project.

This book covers Software Project Management broadly with a lot of good information for both the new project manager as well as the old hand. The material is presented as a comprehensive overview rather than a detailed instruction. By itself the book does not go deeply enough into any of the areas to provide a novice with enough useful information so it's a good book to use in conjunction with books providing more detail.

Despite its lack of detail, the book presents many important points - the importance of the human equation, analysis/organization tools such as Tony Buzan's MindMap, having a Management Information Center, and using standards without having a programmer's revolt. There is only passing mention of key issues such as scope creep, the tendency of management to try to throw more personnel at a project in trouble, needing to build testing into the initial design process, and the pro's and con's of the various development methods (waterfall, spiral, etc.). A number of references are quoted, including many IEEE documents (IEEE is the publisher) plus books by Gerald Weinberg, Capers Jones, Tom Demarco, and other recognized gurus - which make good adjuncts to this handbook.

Phillips perpetuates one of my pet peeves, the issue of including the top ten risks in the risk assessment document. What if there are only 7 risks which seem to be significant? What if there are 12? Granted, it would be unwieldy to track & evaluate dozens of risks routinely, but it doesn't make sense to suggest that exactly 10 be tracked.

The discussions of Configuration Management are quite lengthy and in a bit more detail than other topics covered.

Although the book is fairly short at 500 pages and is easy reading, there is a substantial amount of information covered. The 5 star rating is for the breadth of information covered, with the caveat that other references would be needed by those unfamiliar with the concepts presented.

Don't confuse the ease of reading this excellent book with the depth and power of the information within it. Being involved in software project management myself, I related to the ideas the author expressed and feel I have learned much from reading the book. Other project managers in my company are now reading this book and share similar opinions.

The book contains good explanations of various techniques for formalising projects. It also contains a number of case study experiences which are very apt.

I recommend this book to project managers of all levels and to managers of software companies.

This is a well written book for the people interested in succeeding with software project management. The author spells out the key pit falls to software development and offers realistic solutions. There are many up to date helpful graphics and tables throughout the book. This is easy reading and keeps the reader interseted.

This book has quite good coverage of topics and simple to follow.
References and follow-up/conclusion were useful.

I've maybe three or four books on the subject of software security and this is the best so far. Very concise and well organized and covers just about every facet of software vulnerabilities that I've ever heard of. Very helpful too because at the end of each chapter it gives detailed advice on how to avoid the vulnerability that they dicussed. Also, the CD comes with some nice tools and source code. I definately learned a lot from this book and highly recommend it to both web application and desktop application developers.

Every month, hundreds of security vulnerabilities and warnings are announced. Although they cover a wide set of products and programs, the underlying reason for them is generally the same: insecurely written software. When software is written in insecure code (which includes most software programs written today), serious security flaws are inevitable.

The Software Vulnerability Guide was written to help software developers acquire the methods necessary to write secure code and find existing problems in current software. After making a persuasive case for secure code in part one, the book progresses into the areas that are crucial to writing secure software.

Part two of the book covers system-level attacks and details important topics such as passwords, scripts and macros, and dynamic linking and loading (DLL). Part three plunges into attacks on the software, exploring heady concepts such as buffer overflows, format-string vulnerabilities, and integer overflow vulnerabilities. Most of these attacks have been known for decades but are only receiving wide-scale attention now.

Further chapters delve into securing data and Web servers. For each of the vulnerabilities mentioned, the authors describe how they occur and how to prevent them.

An enclosed CD-ROM contains software examples described in the text, plus various open-source security software testing tools, including Ethereal, Nessus, and Nmap. Any business serious about writing secure software should ensure that all of its code writers receive a copy of this book

Herbert H. Thompson and Scott G. Chase's Software Vulnerability Guide comes from a security director and a security architect, drawing upon their combined expertise to consider techniques developers need to use to produce secure code in modern software. Developers and testers receive both tools and assessments of tools designed to help recognize and prevent common vulnerabilties in source code. Commentary and code examples pack a guide which includes a CD-ROM with source code and many tools described within.

If you consider yourself a solid developer but know you probably don't give the security of your software/databases as much attention as you should, then you need to get your hands on The Software Vulnerability Guide.

Unlike a lot of other security books, this one isn't full of a bunch of vagure generalities. It gives you solid details on some of the most common (and perhaps some less common) holes that exist in the software you just released. The information contained in each useful chapter is easily digestable by beginners.

Buy the book and spare yourself the embarrassment from some twenty something who stole some script off the web and deleted all the data in your intranet application.
[...]

This book uses Smalltalk to teach the basics of object oriented programming on Mac or PC. Before getting my hands on this book I have to say I was having trouble grasping the basics.

I personally bought the book as I want to learn Smalltalk. For some reason the "with Robots" in the title had me skip over this book for almost a year. Most, if not all the other Smalltalk books I got, although great, usually assume differing levels of pre-existing programming knowledge and experience and approach the teaching of Smalltalk skimming over the stuff that is a required foundation to *understand* it. Stephane Ducasse does an excellent job of explaining that missing foundational stuff. And he does it without getting too deep into Smalltalk or Squeak itself.

As others have pointed out this book is not really focussed on teaching Smalltalk - Smalltalk is the tool used to teach basic O-O programming. However, he's done an excellent job of doing both!!!

Having finished this book I'm writing basic programs - and finally understanding better the programs of others.

The use of an Integrated Development Environment [IDE] for a user to learn a language in, and to then program within, is well known. Microsoft has made powerful IDEs for its languages. And the open source Eclipse can be used for Java. Along these lines, Ducasse offers his book. It teaches Smalltalk using the Squeak IDE.

The twist is that Squeak uses the visual metaphors of robots and robot factory, to convey the crucial concepts of objects/classes. As Ducasse explains, Squeak can be directed at an audience that is perhaps of high school age or even younger. So a clear visual feedback between example code and what the student sees then happen is vital, given her limited background and possibly limited attention span.

Squeak uses Smalltalk in part because that is a very minimalist language. If you come from C++, Java or C#, you may be struck by its simplicity, compared to the oodles of classes and notational intricacies of those languages. Which of course also makes it easier for a young student to learn Smalltalk or Squeak itself.

I wonder a little about the book itself, though. A motivated high school student could easily use it. But for some younger students? In that situation, it may well be that the book could be best directed at a teacher, who can then instruct from it.

I whole-heartedly recommend this book for introducing the novice to the nature of computing. I am giving a copy to my 14 year old grandson to introduce him to the fascinating world of programming. He lives 500 km away from me, so he will largely be on his own. I do not expect this to be a problem because the book is perfect for self study.

I want my grandson to learn the essence of computing without spending time on things that he will have to unlearn later or that prove to be blind alleys on his road to computer proficiency . This book is ideal for this purpose. It will let him experience the basic notions of computing in carefully graded steps. Each step tells him how to do fun experiments in the provided environment where he directs a robot/turtle to draw interesting patterns on the screen. The 22 steps take him from a simple sequence of commands to the creation of elaborate simulations; ending at the point where my grandson should start creating his own classes and subclasses.

The experiments are all done in Squeak, a dialect of Smalltalk. It could be argued that my grandson had better learn Java or some other mainstream language. I believe Smalltalk is a better choice because it is simpler, cleaner, and more immediate. The basic concepts are universal and my grandson can easily switch to some other language after he has mastered the fundamentals.

The book is written in a fluent, idiomatic English. It is written in the first person; the writer speaks directly to the reader. This writing style combined with the examples being concrete makes for the smooth communication of what are really abstract ideas.

Anybody wanting to understand more than e-mail and text processing could not do better than to install the free robotic environment on their computer and work through the book’s text and examples.

I've used this book and the BotsInc environment to show my 12-yr old daughter how much fun writing software can be and it's been a wild success!

In fact, it all fits together so well that I'm planning to use it as the basis of an introductory series of classes on software writing as craftwork, to be offered through a local craft organization.

Help train the next generation of software writers! Buy this book!

This book actually teaching computer programming, rather than teaching a computer programming language. It has to use something, and Smalltalk (Squeak) is gentle enough that it doesn't get in the way of the topic.

Stéphane Ducasse, a prolific writer about object-oriented programming, says in his preface: "The material for this book was originally developed by my wife, who is a physics and mathematics teacher in a French school where the students are between eleven and fifteen years old". Indeed, the pains taken to make object-oriented programming understandable to someone with no background are quite apparent, and they certainly pay off. The author has more than met his goal "to teach you object-oriented programming, because this paradigm provides an excellent metaphor for teaching programming".

Instead of teaching Smalltalk, the computer language he uses, he's actually teaching programming. Smalltalk, originally designed as a teaching language, has minimal syntatic issues and it very simple once the student knows a few basic rules. The reader of this book doesn't have to know much to start workign though, since the author distributes a working Squeak environment that's ready to use. He's already provided a "Bot factory" and a working (virtual) robot to which the reader can send commands, much like the LOGO language and its turtle. Without getting caught in the details of object or class design, the readers start out simply by interacting with objects and sending them messages to control their behavior.

As the reader learns more about what the robot knows how to do, the author devises trickier problems for the reader to solve. These usually involve causing the robot to move in such a way as to draw out a pattern. In doing so, the reader is actually writing programs that control the robots behavior to accomplish the goal. Although the language is really SmallTalk, the author effectively hides most of that through the use of the robot's little language.

The Squeak environment the author distributes is easy to use for anyone with a basic idea of computers (i.e. mouse and keyboard, click here, and so on). It's easy to install because you only need to download it and click on the file. From there, you see the Squeak environment and a ready-to-use robot. Move the mouse near the robot and a speech bubble with a blinking cursor appears. Type a command and the robot responds. Easy peasy.

If you are already a computer programmer, or have some experience with computer programming and want to learn Smalltalk, this book is probably too basic for you. However, if you go to the authors web page (Amazon tends to edit links from reviews, so google the author's name) you'll find links to many free Smalltalk books that you can download as PDFs.

Trying to learn useful things about XML can be hard. XML is so flexible and can be used for so many things, descriptions of it have a bad tendency to be vague, never touching the real world. Or they are too detailed and technical to easily understand. This book has a really nice balance of these factors. For example, if you want to know what a web service is, and want to see an actual example of one without an overwhelming amount of technical detail, this book is a good place to look. You can see the code and what's actually needed to implement it.

As a strategic decision maker in the software development industry, transitioning into XML based technologies is at the top of my priority list. Strategic XML provides a very good introductory through advanced study of the topic. The author not only educates the reader from an academic perspective, but goes in depth with real world examples. He actually goes one step further and points the reader toward suitable tools and development platforms. For anybody moving into (or already in the midst of) joining the XML world, I would highly recommend giving Strategic XML a read.

I love this book, it's not your average learn to build a CD or Book database in XML. If you want to learn the XML, buy a generic fat red book with the lots of faces on it, if you want to learn how to apply the XML to practical situations, get this one. It's not going to take you years to read and the selection of applicable quotes at the start of each make it quite amusing and exciting. Add a bit of method to your madness, buy this book and apply a Software Engineer's approach to your data modelling.

I really liked this book. It gave me some very good insight into how to use the XML I have been learning for the past 2 years. It is not filled with a lot of useless rehash of XML primer material, it has a real nice review/overview of the technology and then focuses on the real issue of how to use it to solve business problems. I would highly recommend this book to anyone who doesn't need a 600 page regurgitation of XML basics, but instead is focused on solving problems with an exciting technology!

I initially read this book because I know the author and I promised him I would. I'm not a programmer but I am responsible for the technical direction of my company. Suprisingly, the book was written in plain enough English to give me a good general understanding of how to use XML, SOAP, Web Services etc. I'm passing it on to my programming department as a primer to start getting us up speed on these technologies.

In my view, this book is an excellent introduction to the Struts 2 framework. The authors approach to the reader is well thought out and the book is actually a "good read". The conversational tone with which the book was written lends itself tremendously to the reader grasping a firm hold of the technical information. It's not "dumbed" down at all, it's just explained very well. Each chapter builds on previous information presented to provide a clear picture of how the framework operates.

According to the authors, there is foundational knowledge that must be understood before Struts 2 can really become a useful tool in a developers hands. (See chapter 4: Adding workflow with interceptors.)

They do an outstanding job of taking the reader though the key concepts of the frameworks architecture. At the end of each chapter, I understood what they were saying and I had a clear idea of the concepts they were attempting to get across. Not many technical books do this very well, however, this one does.

As far as Struts 2 being the "best" framework? I won't go there. However, Struts 2 looks to be more than capable of handling the requirements when developing both simple and complex web applications. It appears there have been lessons learned from Struts 1.

In summary, it is the opinion of this reader that if you want to learn and *understand* the Struts 2 framework this book will get your there and you will enjoy the journey as well.

This is a proper "In Action" book. I do strongly recommend it. If you plan to buy only one reference in the subject, look no further this is it! Down Brown is a Struts PMC member and an authoritative voice, among others he is the author of the Struts 2 REST plugin which is a superb addition to the framework from version 2.1.2

The book is very well written and easy to follow. I personally found the explanations very concise and appreciated the most their unique and clear way of breaking down and explaining all code snippets. This is really a great reference.

The first two chapters are a very good introduction to the framework. I am a pure version 2 user and had to learn most of these concepts from online documentation and from the Struts mailing lists.

Among all the topics covered I enjoyed and appreciated the most the coverage of:
- Interceptors
- OGNL and Type Conversion
- Validation! before this book, you could only find the relevant coverage of this topic scattered online in e.g. WebWork articles outdated
..for Struts 2. The authors did an excellent job explaining validation in chapter 10
- Really unique was the coverage of:
..... Unit testing actions
..... Tiles plugin
..... execAndWait interceptor "processing your request, please wait .."
..... UI component templates
..... Writing Struts 2 plugins

On the big plus side, the authors did a superb job keeping the book agnostic to minor versions of Struts 2 i.e. there were several differences from 2.0.x to 2.1.x and I was very happy to see that the examples and explanations were not outdated for the later.

On the down side and as a trade off I can only complain that the book left the Ajax topics out; maybe also because there have been many changes on this topic from minor versions of Struts 2 e.g. the ajax theme of Struts 2.0.x was converted to the dojo plugin in version 2.1.x. In any case, I somehow find the Ajax topic in Struts 2 to be one of the best documented online.

I believe that the Practical Apache Struts 2 Web 2.0 Projects (Practical Projects) book from Ian Roughley is a very good complement to this one. If you want to find coverage on topics like Security and Ajax in Struts 2 you will want that one too. The only issue there is that the coverage of the ajax theme is partially outdated for the newest version 2.1.2 of the framework

Struts 2 In Action is the best resource (hard or soft copy) for Struts 2 available. I took a look at this book as someone with quite a bit of experience using Struts and Struts 2. I really thought I had a good understanding of the core framework before, but many of the topics that lack online documentation were covered in more depth than I had seen in the past. As an example, many others have shied away from covering OGNL because it is a language all by itself. In this book you will find what I consider to be the most thorough explanation of how OGNL fits into Struts 2 and how to use it yourself. I was tempted to give the book 4 stars because there are a few things that I thought could have gotten more coverage, like Spring/Hibernate integration and AJAX, but I realized that it really would be impossible to cover everything in one volume. Struts 2 is a large and comprehensive framework and with anything of that scale, a good understanding of the fundamentals is the best way to start. This book delivers.

If you are wondering what is covered, you will find comprehensive coverage of the following -
- writing actions
- action workflow basics
- type conversion
- OGNL
- form tags
- non-form tags
- results
- intro to Spring/Hibernate integration
- validation
- i18n
- struts 2 plugins
- migration from struts 1

I had to learn Struts2 quickly since I recently changed jobs and my new team has several web application projects built using Struts2.

Overall, I thought the book was done very well if you are looking for a good introduction to Struts2. The first 8 chapters are very good.

The main negative is the source code for the book's examples. The authors provide one very large war file with all the source code embedded into the war file along with an overall web application divided into sub-applications for each chapter.

This packaging of the source code into the war file made it difficult for me to create individual projects in my development IDE that demonstrated just the material in a specific chapter. I had to spend quite a bit of time breaking down the source code into individual web projects and then figuring out on my own what jars needed to go into each project, what the struts.xml file needed to have, and what ever else was necessary to separate out just that chapter's sub-application so I could run that example and play with it.

Where this really became a problem was in chapters 9 and 10. Chapter 9 is a very advanced introduction to integrating Spring and Hibernate/JPA into Struts2. I never could get this chapter's example to work correctly.

However, chapter 10 on the validation framework then uses the same code as chapter 9, so you really cannot separate out the code for either chapter 9 and 10.

The validation framework is likely something even beginning Struts2 developers will want to use, while Spring/JPA/Hibernate is for more advanced developers and should have been well after the chapter on how to use the validation framework.

Also, the authors really don't give you a good understanding of what Struts2 jars you need to have to build a basic Struts2 application. There is some information about this in chapter 13 (setting up your IDE) but this information should really be at the beginning of the book. Also I don't think the list the authors provide is accurate since my basic HelloWorld (get the user to enter a name, call an Action class, and then display Hello userName in new jsp) worked with far fewer jars. Note there is apparently a new example war that just is a basic Hello World so there may be some information in that war file. That war was not on the manning web site when I purchased the book.

This book is good but be prepared to struggle working with the code examples if you want to work on the examples in your own development environment.

I recommend the authors create separate complete war files for each chapter's example to make it easier for users to just get that chapter's example code into their development IDE.

Lastly, the book does get 4 stars because the author's explanations of the basics of Struts2 (chapters 1-8) is very easy to follow for experienced Java developers. I'm now ready to tackle the Struts2 applications in my new job.

I took a chance and pre-ordered this book because I have recently started a Struts2 project and wanted to learn more about the framework. The book did not disappoint.

The authors explained the concepts behind the framework clearly and used examples that were immediately useful. The book is a little too short and in many cases a few more details would have been appreciated but it seemed to be a deliberate decision to leave out some of the less common use cases to avoid cluttering up the book. Thus, this book is ideal if you are new to Struts 2 but have some prior experience with Java web development.

I like the fact that an entire chapter was dedicated to integrating Spring and Hibernate into the framework. It brings all the bits and pieces from the online documentation together in a cohesive and comprehensive package.

Chapters were also dedicated to validation, internationalization, best practices and migration from Struts classic. The authors spent several chapters on how the Value Stack and the ActionContext worked and how OGNL fits into this framework.

All in all there is enough information in this book to start and to produce a complete Struts 2 application.

This book is excellent. It is very thorough and easy to understand. There is sample code in every chapter so the concepts are very clear.

I have been using subfiles in RPGIV for many years - this book taught me some new tricks I wasn't aware of!

This is THE subfile book for AS/400 RPG programmers.

Mr. Vandever approaches the subject with a sense of humor, lots of examples, and excellent technique. The examples are written in ILE RPG IV (RPG III programmers will find the book useful, as well), and do a nice job of showing off recent RPG IV enhancements by incorporating them in the examples.

I have developed lots of subfile programs, and read the other books on the subject. This is by far the best treatment of the subject that I have seen.

As a programmer new to RPG 4 and programming for the AS/400, I needed help with subfiles. This book proved easy to read (I can't say I've read it through, but enough to get what I needed) and there are lots of helpful code examples. I used the sample program for a page-at-time subfile application almost verbatim to get started on one of my programs, which saved a considerable amount of time and effort. Overall this book has been quite useful for me.

Book really explains subfiles in terms anyone can understand. The CD/ROM has sample code that you can use immediately as "models" to develop your own programs. Author does an excellent job of explaining how subfiles work. But if you are like me, you will develop several subfile "skeleton" programs for your own future use. That's where the examples can really help...

This is a well written book, code is easy to download, and a number of topics. All in all though, the writing is clear and easily understood so it's well worth the money...

I am a Java web/search programmer who wanted to "get into" text mining. I found this book an excellent resource for this. Text Mining is a field in which active research is still going on, and other Text Mining books I have looked at reflect this - the authors expect you to have a certain degree of mathematical background to understand what they are saying. This book explains briefly the math behind each of the approaches, but it focuses more on the algorithms that result from the math, so it is easier to read.

Of course, a side effect of this is that the approaches described are not necessarily the state of the art for solving any given problem, but once you get the basic approach to solving a problem, it is relatively easy to find and understand the documentation on the web for the more advanced approaches, since you now know what you are looking for and how it differs from your basic solution.

The book does have a (fairly long) chapter where it covers the math background necessary to get started with Text Mining. If you understand the stuff in there, you will actually be able to think up solutions to text mining problems that are unique to your own situation.

The algorithms in the book are in pseudo-code, but the book comes with a CD (or download from the author's sourceforge project textmine.sf.net) where you can see working Perl code.

Overall, I think this is one of the most useful books that I have purchased in a while. It should appeal most to programmer types who have programmed in their language(s) of choice for a while in areas other than text mining, wants to get into text mining, and doesn't want to spend a lot of time relearning high school and college math before starting off.

Text mining is one of the most exciting subjects of the web, and too few books are dealing with it. This one is one of them, and it gives quite a few examples of text mining applications, like spam filters or search engine ranking algorithms. The style is easy to follow, and the concepts easy to understand given some maths background.

However, I expected more details, and a richer content overall, thus the four stars. This is still a good book.

Software developers learn how to mine information on the Web and turn it into valuable data; but developers need to understand how data mining works. For a programmer's application-oriented review, Text Mining Application Programming is the item of choice: it reviews text data, how it's found, and how search engines locate and gather it. Next, it teaches how to build spiders to crawl the Web, how to use the information, and how to monitoring it. Perl developers will find its Perl-based code useful, but it's not necessary to know Perl to run the software herein. An excellent guide to mining the Net.

There is an old expression that half of knowing anything is knowing where to find it. And there is little more frustrating to be looking at 'My Computer' trying to find what you know you have stored in a file somewhere. Well, perhaps just as frustrating is to go to one of the search engines and try to find something that you know is there but just don't know the proper words to find it.

In this book Dr. Konchady talks about how to go find data that is in text form on your system, on your network or out on the web somewhere. It talks about search engines, but also about other techniques that can be used only by programming.

The CD that comes with the book contains several Perl software snippets that help to find named entities, parts of speech, phrases and gives a summary of text documents. This area includes developing web crawlers that can be adapted by individual users to go out and find specialized information. It further contains an Open Source software package called Text Mine that is designed for mining operations. In addition it has utilities to build and enhance Text Mine and utilities to build and manage MySQL database tables. This is an excellent book on everything from the basic hints and types through some of the mathematics that underlies text mining.

His section on the nature of an English language Question and Answer system is the best I've ever seen.

This is the second book on Forth that should be read by any person interested in learning Forth. After finishing the examples in Brodies first book, read this one to pick up on how a Forth programmer solves different programming problems. You will find that the methods learned are applicable to all languages but especially useful in the iterative style that is Forth.

If you program in Forth, this book is mind-opening. I second the reviewer who said you should read this book after reading "Starting Forth".

However, to the reviews along the lines of "You don't use Forth? Doesn't matter": I think this book would be very hard going for someone not familiar with Forth. In fact, it is a bit dated, and there are better, more modern books available on non-Forth design, factoring, etc.

Also note that the copyright holder has made this edition of the book (2004) freely available online. Buying from Amazon saves you from getting square eyes (or using up all your print toner).

FORTH isn't for everyone, the use of Reverse Polish Notation, stack operations, and language extensibility can be daunting. But, between Starting Forth as a tutorial and this work providing conceptual insight, there is a path for self study that can bring you along to intermediate level with a reasonable investment of time. Add the FORTH Programmer's Handbook, the ANSI spec and a freeware FORTH package for your flavor of OS (including PalmOS, UNIX, WINDOWS, MSDOS, just about everything has a version) available via the net, and you've got everything you need to explore and learn this powerful, extensible, and compact language.

Thinking FORTH is as much about philosophy of problem solving and programming style as FORTH. Concepts presented in this '84 publication were light years ahead of their time. OOPs concepts, including data encapsulation, modularity and overloading are explained in simple understandable terms (although with different terminology). Emphisis is on eligance, flexibility and reusability, written in Leo Brodie's unique style. (NO YOU CAN'T HAVE MINE!)

As a teacher/programmer I found this to be a phenomenal piece of work. One of the hottest items in programming today is refactoring - it's here. Object orientation, modularity, top-down, bottom-up, it's all here. You can't read this book without becomming a better programmer regardless of the language. But you don't want to just read it. Work through the examples, follow the logic until you understand it - really understand it. You don't use Forth? Doesn't matter. The principles of problem analysis and good program construction are language independent. Try this one - you'll like it. Learning to function in the sparce yet luxuriant Forth universe will change the way you program.

I picked this book up probably around 11 years ago and it is what I used to learn C programming. I had other books at hand as well, but this one really shines. The book has an obvious DOS slant to it as it is from that pre-Windows era. But in learning C programming, this one is hard to beat. I have since gone on to learn other languages, most notably Pascal / Delphi, but this book will always remain on my shelf. It was incredibly useful.

This is a great book for C programming. It starts from elementary level and ends up teaching you advanced controls and professional aspects. It also covers some part of C++ and object oriented programming.

To be fair, I have the first edition of this book, dated 1987, and called "Turbo C Programming for the IBM". It has been with me many a year and has always been my favorite C book. It is the easiest of my C books to understand, and can be read like a novel with only occasionally going to the computer to try out their programs for reinforcement of a concept. All their examples are complete programs which are very helpful to me. Drawbacks to this book include: a) their sections on "Turbo" C are not applicable anymore, b) there are sections dealing with pc-specific issues that are not useful, and c) the C is not ansi compliant. However, in spite of this, it is still my favorite book because it is easy to understand.

This was my very first C programming book. I had used Pascal a little bit when I bought it. 11 years later my copy of the book is tattered and torn, but I always keep it handy. The book is illustrated very well. It has floating arrows that describe what each element of the source code does. It does not talk down to the audience. The information within is presented with extreme clarity. I would recommend this book to anyone wanting to learn C. I would also recommend this book to anyone wanting to give it as a gift to a teenager.

This book is how I learned to program 'C'. This is my favorite programming books of all time. It's easy to follow, good explanations and an excellent read. I've went on to become a lead programmer, and it all started here. Nostalgic, you bet. If you want to learn how to program in 'C', start here! I can't say anything more.