Software Books

For anyone that tells you that you can't so solid code and script development on a Mac, they haven't been introduced to the application TextMate. There are several good options for doing power editing on the Macintosh and TextMate is one of those POWER options.

'TextMate: Power Editing for the Mac' by James Gray is a perfect companion manual for all TextMate users that want to lift the hood off of this power app and get to the nuts and bolts. If you develop on a Macintosh on a daily basis for work or fun and want to learn more about what you can do to make your life easier, pick up this book and you won't be disappointed. Written well and coming in at ~200 pages, there are 12 chapters which will teach you goodies in TextMate like how to create and use Macros, using Find & Replace to quickly edit text, and much, much more!!

The Mac is a great tool for developing code and TextMate is a great app for writing it, make yourself a more efficient coder today!!

***** HIGHLY RECOMMENDED

Books on editors are tricky things... I'm (still) a big fan and user of vi, but textmate is my tool of choice for more project level work for its capabilties. This book has brought me closer to to the keyboard level of productivity that vi allows for with its two modes.

Visuals:
The font size in the Pragmatic Programmers books is a little larger than say the O'Reilly books, which I personally like. Easy on the eyes. Screenshots are clearly printed.

Readability:
I found the reading style conversational and easy to follow. Of course, with this type of book which includes many keyboard short-cuts you really need to be at your computer and using them to commit them to memory. Even a reading of the book will give you insights into the power available at your finger tips with Textmate.

Practicality:
If you spend any amount of time in Textmate, this is really a no-brainer. This book will help you be more productive and get more out of your chosen text editing tool.

Audience:
The book does not list an intended target audience, but if you use Textmate at all I would say you have a bulls-eye right on you.

Overall:
If you use Textmate get this book.

"TextMate is actually a thin shell over a personalized team of robot ninjas ready to do your bidding."

The funny thing is, to people who have never used TextMate for more than a few minutes the above phrase sounds like an exaggeration. It's not. (As long as you can accept the analogy of "really awesome code running on a Mac" = "robot ninjas"...)

Anyway, this book targets a pretty specific market: 1) Humans, 2) who own Macs, 3) and use TextMate. I'm here to tell you that, if you're human you should have a Mac; and if you have a Mac you should buy TextMate; and if you have TextMate you should buy this book. So there, now it covers everyone.

As with all of the Pragmatic Programmer books, I found this book to be concise without missing anything important. You may be thinking, "200 pages about a text editor!? That's crazy talk!" But you would be wrong, my friend. The amount of functionality built into TextMate is incredible, but I didn't even know the half of it until I started reading this book!

I don't want to give away the ending, but:

Three of my favorite simple features I didn't know about until I read this book:
- Pressing [ESC] to complete the word you're typing.
- The built in TODO list functionality (so crucial!!)
- [Cmd-Enter] to add a new line below this one and go to the beginning of it.

Things I wouldn't have been able to do without TextMate and this book:
- Edit some of my Bundles to make TextMate work even more how *I* like
- Complete an after-hours Web Site project *way* under time and budget

Seriously. TextMate is the One True Editor for Mac (it makes me loath using any other editor on any platform) and this is a great book for learning how to *really* take hold of its power.

This book is the perfect primer for what I have found to be one of the most indispensible Mac OS X applications - TextMate. If you are a software developer or web designer or anyone else that edits text on a frequent basis and you have not already discovered TextMate, stop right now and visit http://www.macromates.com.

The Pragmatic Programmers' book, TextMate Power Editing for the Mac is a thorough introduction to TextMate. Edward Gray II has written a very accessible book, that covers the product very well.

The first third of the book is devoted to the basics - things you do every day in your text editor. The second third of the book dives into the details of some really sweet features of TextMate that you'll find yourself using all the time: bundles, snippets, macros and UNIX shell commands.

TextMate ships with over thirty 'bundles'. Each bundle is a directory of related files that provide additional functionality to TextMate. Let's say you're working on an HTML file. The HTML bundle will help you with loads of things related to your document: validate the syntax of the document, open the document in the default browser, refresh the document in the current browser session, insert open/close tags for the current word, strip all HTML tags from the document - just to name a few. Each bundle provides functionality that applies not only to the syntax of the language you're currently working with, but repetitive tasks that would apply as well.

As I mentioned, a couple dozen bundles ship with TextMate and many more are available for free download from various websites. You can even create your own bundles to extend the product in ways that only you can imagine. Here are a few of the bundles that ship with TextMate: Blogging, CSS, HTML, Java, Markdown, Objective-C, Python, Rails, Ruby, SQL, Subversion, Text, Textile, Xcode and XML. Bundles provide you with lots of help editing files and performing related tasks.

Snippets are a smart completion mechanism that go way beyond the simple concept of 'finish this word'. For example, if you are editing a Ruby file and you type array_object.ea followed by the TAB key (where 'array_object' is an arbitrary Array object), the snippet feature will automatically fill in the skeleton of the 'each' iterator, including the opening and closing curly braces, the text '|e|' with the letter 'e' highlighted. You simply type the name of the variable you want to represent the next element (or simply leave it as it is), hit the TAB key again and the cursor will be placed between the closing '|' character and the closing '}' character, ready for you to type in an expression. Very cool. This same trick works for dozens of different scenarios in your Ruby code. And that's just the snippets that apply to Ruby code. There are snippets that apply to a large number of file types.

You've probably seen macros in other editors and TextMate's macro facility works as you might expect: you start recording a macro, perform some actions and save the macro. TextMate saves the macros as XML files, so it's a snap to edit a macro after recording if you need to tweak it a bit.

The ability to fire off UNIX shell commands from within TextMate gives you another powerful tool to use while editing files. You can fire off one-liner shell commands by simply pressing the ^R key on a line containing a shell command. You can also use shell commands to act on all or part of the current document.

For the advanced TextMate user, the tail end of the book shows you how to create your own language syntax for use in TextMate, including how to describe the grammar of the language in terms TextMate will understand. So, if you program in some far out funky language that TextMate doesn't support out of the box, you can add the language grammar to TextMate and program away!

Overall, I found this book extremely useful and easy to read. TextMate ships with an excellent help system that will answer many of your questions. The TextMate Power Editing for the Mac book will take you beyond the built-in help and give you an in-depth guide for this great Mac application.

This book is amazing, I didn't expect a book on software engineering to be so easy to read and understand.

Most of the other software engineering books I read are too academic and detached from the industry.

The case studies provided in this book are things I can totally relate to as a software developer. Question/Answer sections are great.

Overall this book is very well written, it is a true masterpiece.

The knowledge I gleaned from this textbook was directly responsible for my getting a high paying software engineering job immediately after leaving college - that alone should be a testament to its value. It gives a wide reaching survey (yet certainly not lacking for details) of the latest cutting-edge methods for software engineering as well as the tried-and-true methods that have been in use for decades, while placing a primary emphasis on writing software that is trustworthy on time and within budget. In a software engineering world where ethics have fallen out of favor and the "almighty schedule" has become more important than quality and security, this textbook is an extremely refreshing view of how to apply modern principles and process to produce not merely programs but supportable, trustworthy programming systems products. And best of all, Bernstein shows you how to do it ON-TIME and WITHIN BUDGET by performing quantitative cost and time estimation prior to and during the development process. If software engineering is to reach the level of professionalism long associated with other engineering disciplines, we must all embrace the methods and principles discussed in Bernstein's book.

It's important to note also that there are many case studies in this book from Bernstein's distinguished career at Bell Labs, and they are extremely valuable in learning what "works" and what should be avoided. Software engineering as a discipline doesn't learn from its mistakes as well as other engineering fields, but this book takes 35 years of hard-earned experience and the latest research by Bernstein, Boehm, Parnas, and others, and condenses it into what I consider the best software engineering textbook on the market. This is a must-read for any computer science practitioner who wants to consider himself a true engineer and a professional.

This book does a great job of covering the key tools and techniques used in the development of software systems. It is very readable, and is suitable as a course text or an informative reference guide for practicing programmers and managers. A wealth of case study material provides insights into how to develop reliable software, on time and within budget. Sprinkled throughout are pragmatic rules of thumb and metrics. A good read and a good addition to any reference collection!

The most commendable single aspect of this book is the extensive set of real case studies. The main author (Bernstein) comes from decades in high tech industry and this permeates the entire book. The book is extremely broad in scope too, so the prospective reader or student gets a tour of a vast array of related subjects. The quantitative basis for the entire book constantly reminds the reader of the usefulness of a quantitative approach to all sorts of aspects of software engineering. Prospective buyers can dive in to the text at Amazon and make up their own mind about the usefulness for their own purposes. Take a look!

Well, this is certainly a much different type of software engineering textbook than I have seen in the last score of years ☺! I was a reviewer of early editions of Pressman, and a user of every edition since the second one at four different universities. Shooman's classic 20+ years ago is another early data point for a graduate course. The Software Engineering Lectures of Tom DeMarco and Ed Yourdon from 1979 are still shelved six feet away from me, and have been referenced in every undergrad and graduate software engineering related course I have taught since 1984. The same shelves contain Pfleeger, Leach, Lethbridge, Peters, Watts & Humphrey, Sommerville, Thayer and many others within the combined 12 foot lineal span. They obviously are used, but not to the extent of Pressman.

That may be about to be changed! Larry Bernstein's new text states on page 32 ".. none of these [principles of sound organizations] will work unless our profession recognizes the next core element in the evolution of software processes as a fundamental principle. Software trustworthiness is the next major area in which academic and industry must focus -- both for national security reasons as well as to ensure that the U.S. software industry maintains its leadership. The three attributes of software reliability, security and safety comprise trustworthiness."

I totally agree with the belief about where we should focus our attention in coming years, but not for the reasons that Larry cites. Let me explain:
* Having worked as a software/knowledge engineer on the Space Shuttle program for Rockwell International for four years, including the maiden flight of Discovery within a few months of my hire date in 1984, I am a very firm believer that the trustworthiness of the software in the shuttle and all the support effort was a gold standard at the time. I was also a full-time professor of CS concurrently, so could bring such issues to all of my classes. Although I have given up my dream of going to the moon, hatched when my small team of high school students fired off rockets in a farmer's field prior to Sputnik, I still hope to make it to the international space station, so a trustworthy system is not only of academic interest! In the last 20+ years, the ubiquity of computing, particularly embedded systems in all modes of transportation, makes such a standard a MUST, not just "nice to have" in our cars, trucks, planes, etc. When a team of Ford software engineers showed up in my office 10+ years ago, asking for help in developing safe software systems for next generation side impact sensors, I could not brush off their concerns! Obviously, software systems pervade the lives of many of the 6.6 billion people residing on this planet today, not just the billion or so who access the Internet. It is irresponsible, not to mention a direct violation of codes of ethics for computing and software engineering, NOT to develop such trustworthy systems.
* I cannot agree with Larry's rationale about the leadership of the U.S. in software. Trustworthiness of software systems knows no national boundaries! Other engineering artifacts do not know such artificial boundaries - do we want the bridges and high rise buildings of Europe, Asia, the Middle East, South America, Africa, etc. to be less safe, reliable and secure than those in the United States? I think not, if for not other reason than millions of our citizens travel to and live in those countries every day. Clearly, the lives of people across the world are just as valuable as those fortunate enough to live in our 50 states. The state-of-the-art in engineering methods is being advanced on a world-wide basis - why should we think software engineering education is somehow an exception? I would hope that this new text would be published in many languages and used by students and practitioners worldwide. I had first met Professor Bernstein on November 30, 2000 during my sabbatical to set up an International Software Engineering University Consortium (www.iseuc.org). So Larry clearly knows of my penchant for the world-wide importance of software engineering ☺!

Why do I think this new text is different from earlier ones and would recommend strongly that all current faculty and practitioners consider it carefully, especially for an introduction? The rationale includes the following. The text:
1. Focuses on the increasingly vital role that trustworthy software systems will play in the lives of current and future generations. Consequently, it is quite easy to engage or "hook" students in an introductory software engineering course about the importance of the topic - they see the impact of the lack of such systems on a weekly, if not daily, basis. Many of them will be able to share personal and professional experiences. The marvelous column by Neumann in every copy of ACM's SIGSOFT Software Engineering News provides ample examples, in any case.
2. Is cleverly written with excellent and realistic case studies with real questions and answers
3. Draws on the demonstrated expertise of the primary author when he was the CTO for Bell Labs
4. Truly demonstrates the rationale for the role of quantitative software engineering methods throughout the development life-cycle, beginning on page 4!
Reliabilty = e-k?t, where k is a normalizing constant, ? is complexity/(effectiveness x
staffing) and t is the time the software executes from its launch.
5. Emphasizes the "why" as well as the "how"
6. Includes excerpts from student teams related to the growing use of Real Projects for Real Client Courses - RPRCC-in software engineering and other courses
7. Covers most of the topics in a traditionally-structured software engineering text, but does so in a more contemporary and intuitive way. Some of the topics in other texts that wind up at the end, hence often not covered, are main-line chapters in the Bernstein text*. The newest edition of Sommerville's text does indeed have a 20-page chapter 3 on "Critical Systems" and a complete 120 page Part 4 on the same topic, but this is certainly an anomaly among current texts. The Bernstein text emphasizes trustworthiness as a continuing theme throughout, with the continual use of quantitative measures - witness the large number of "Magic Number" boxes for empirical results and heuristics contained in virtually each chapter. I admit that there would be a "learning curve" for most of us, but hey, aren't we supposed to be paragons for "life-long learning" that we espouse for our students?
8. Has fewer pages than virtually every other text. This is a real advantage. Students (and faculty) feel they have a "prayer" of being able to use the material in one course!
9. Has nice on-line support site.
10. And, finally, Larry will go to great personal lengths to support his text ☺!

A couple of possible sources of improvement for the second edition would include the following:
1. Include Failure Mode Effect Analysis (FMEA) as a major component when designing critical systems. This is a common engineering tool that was used in the design and testing of the Space Shuttle Main Engines (SSME) over the last 30 years.
2. How can the vital concept covered in the text be applied to the massive task of rendering trustworthy the extant base of millions of software systems? The text does a superb job for developing such systems, but can trustworthiness be "bolted on" existing systems? I doubt it, but cannot see an easy answer here.
3. A friendlier website for both instructors and students would be helpful, ala those for other software engineering textbooks

*Topics in the text
Part I. Getting Started
1. Think Like an Engineer - Especially for Software
2. People, Product, Process, Project - The Big Four

Part II. Ethics and Professionalism
3. Software Requirements
4. Prototyping
5. Architecture
6. Estimation, Planning, and Investment
7. Design for Trustworthiness

Part III. Taking the Measure of the System
8. Identifying and Managing Risk
9. Human Factors in Software Engineering
10. Implementation Details
11. Testing and Configuration Management
12. The Final Project: By Students, For Students

I own a lot of books on NT Server (too many in fact) and this is one of my favorites. Anyone responsible for the support of NT Server should have this book without question. Curt Aubley has produced a book that is easy to digest yet comprehensively covers all aspects of optimizing NT Server in your own environment.

It includes many ideas and suggestions that you can implement immediately and see true performance gains. If you've ever wondered, "What RAID configuration would be best for my new application server?" or "Which performance monitor counter is really the best to use to monitor this or that?", then this book is definitely for you.

Let's hope Curt produces a similar book of the same quality for Windows 2000. This book sits right beside Mastering Windows NT Server by Mark Minasi on my desk, and between the two of these and Technet, one doesn't need much more to support an enterprise Windows NT 4.0 environment.

I've been very impressed with the results of implementing what I've learned from this book. I've used the techniques at a few different Fortune 500 companies, and all my clients have been very satisfied. I would reccomend this book to anyone who takes tuning Windows NT for the Enterprise seriously.

This is the best written book I have read to date. It starts out like it should...what to do if you don't want to read the whole book. I have suggested this book to many of my friends and they have the same feeling. Great Job Curt !!!! Publish another one !!!!

Mr. Aubley's book is an excellent technical resource which addresses the difficult task of correctly sizing NT Server implementations and also how to tune NT for maximum performance with regards to various hardware and software considerations. Mr. Aubley explains the complex tasks succinctly and concisely and draws on many obvious years of experience to present hands-on solutions and case studies for reference. I would recommend this book to any NT admin that is responsible for scaling NT beyond humble file and print services. It has presented approaches to the tasks at hand that I have successfully used to effect client solutions.

I own a lot of books on NT Server (too many in fact) and this is one of my favorites. Anyone responsible for the support of NT Server should have this book without question. Curt Aubley has produced a book that is easy to digest yet comprehensively covers all aspects of optimizing NT Server in your own environment.

It includes many ideas and suggestions that you can implement immediately and see true performance gains. If you've ever wondered, "What RAID configuration would be best for my new application server?" or "Which perfmon counter should I use to monitor this or that?", then this book is definitely for you.

Let's hope Curt produces a similar book of the same quality for Windows 2000. This book sits right beside Mastering Windows NT Server by Mark Minasin on my desk, and between the two of these and Technet, one doesn't need much more to support an enterprise Windows NT 4.0 environment.

Lafore has done a wonderful job. Specially his explanation of the C syntax in this book is excellent. If you are an absolute beginner then this is your book. Learn C in a painless way. Moreover this book also teaches you C graphics! that is something you will not find in most of the great C books in the market.

This book is best for people who are getting introduced to programming ... or C for that matter. It is THE best start-up material. Tip: Read it to build up concepts and move to books dealing with more advanced topic for the highest personal gain.
A book worth digesting !!!

Its a good and well written book. This was my first book which I used to delve into programming. Found it very useful. Cannot be really used as reference, but its good to clear your concepts of OOP.

LeFore's book is a great book for beginning programmers. I have taught C/C++ at our local community college and have often recommended this book to students and friends. It is well written and not overly complex. It has clear explanations of constructs and good examples. Kudos to the author. All beginning books should be so easy to understand.

I'm a chem e of 15 years beginning an MS CS degree. A PHD candidate CS friend of mine recommended this book. My programming in C class uses Deitel. Deitel is very poor in explaining the basics of functions and pointers. Lafore does not go into as much depth as Deitel, but does an excellent job with the basics of arrays, functions, pointers, and the syntax around them. By the time Deitel got to fucntions, pointers and pointers to functions from within other functions, I got lost because I couldn't follow the synax in the examples with any certainty. Lafore saved me. I read the chapter on functions and the first 5 pages on pointers and gained a much clearer understanding of the basics. I was then able to understand the more in depth examples of Deitel. I deduct one star for Lafore's lack of depth.

This an awesome book. This book is the to have for all web developers.

This text book is of very high quality and an engaging read. Apart from the expected target audience of web developers, I will suggest that website owners and non-developers should consider getting hold of this vital textbook.

The fact that it leaves you wanting more is a compliment to its quality. Even though it is bulky, I wished it had covered certain areas in more detail.

One small criticism relates to the javascript examples. The discussion of events refers to techniques that are questionable in terms of robustness and re-usability, issues that, to be fair, the author does point out. [Background; search for "addEvent considered harmful" in your favorite search engine.] Yet no definitive solution is given, and the reader is left hanging. More serious is the very poor quality javascript code sample given for the cssjs() utility function, which is poorly designed (needs to be repackaged, should be a class), is inefficient, and is fragile as it contains (at least) two immediately apparent critical bugs.

But such small gripes should on no account not put you off buying this text. The overall verdict, "Outstanding."

Anyway, the numerous authors are to be congratulated. Indeed, given the size of the field and the rapid pace of developments, a second "part II - advanced" volume would be a very good idea indeed.

If you are serious about accessibility (and you should be), this book will not dissapoint. The authors know what they are talking about, and do a good job and presenting both the facts and their opinions in a clear relavent way.

The only reasons I do not give it 5 stars is many items within the book are redundant (I think due to the great number of authors (11!), and perhaps they wanted the book to serve as a reference also), and because the presentation is generally dry. Good information, but not coffee-table reading.

Still in all, as a web developer I would highly reccomend this book to any other developer weather you just want a little understanding of accessibility, or a big dose.

Web Accessibility: Web Standards and Regulatory Compliance, written by eleven experts and released in July of 2006 by friends of Ed, is one of very few books about web accessibility. It is also the best. The writers include luminaries and pioneers in accessibility - Jim Thatcher, Cynthia Waddell; and technical experts - Christian Heilmann and Andrew Kirkpatrick, to name a few.

The book is an overview of accessible best practices in web technology, and the legal landscape it inhabits. It was compiled with several target audiences in mind.

Certainly, it is intended for developers - newcomers as well as veterans. This is the group that most needs to understand the technology, and unfortunately, seems to "get it" the least.

Another audience is the managers and administrators; that group that should be most adverse to risk and whose responsibility is to keep their government and corporate employers out of the courts and headlines (like those that have embarrassed [Target retailer]). Covered in some detail are the ADA section 504 and section 508 requirements, and in lesser detail international laws.

The technical information is very current. There is a chapter on accessible JavaScript (most would consider that term an oxymoron) even though it has only recently seen coverage in articles and blogs online. Likewise, there is good information on making Flash content accessible.

A book assembled as a compendium of contributions begs to be updated frequently. The next release, for example, could add much needed chapters on AJAX and Web 2.0, podcasting, and learning management technologies. Regardless, all practitioners of accessibility will find this book valuable.

Web Accessibility: Web Standards and Regulatory Compliance is the
perfect reference for any site development team. Everything you've
wanted to know about Accessibility and the Web is here in a single text.
Each member of the team will find necessary information and practical
solutions in one or more of the thorough discussions here. For the
designer/developer who works alone, Web Accessibility: Web Standards and
Regulatory Compliance is the all-in-one reference with the most
up-to-date information and techniques. Thanks to the clear organization,
two tables of contents, and index, all information is easy to find as
well.

For those of us who like background and theory, the book contains lively
discussions of accessibility standards, of the intent of the standards,
and suggestions for using the standards. For me, though, the heart of
the text is in the practical discussions and how-to guides in order to
improve accessibility of every common web technology -- from PDF to
Flash, from javascript to data forms. In addition, we finds clear
descriptions of the law and web accessibility. Importantly, these
discussions are international in scope.

The collective experience of the authors of this text is impressive.
These are the experts to whom we've turned to assist us with accessible
design and development for years. In this text, we have a collection of
the most knowledgeable voices on the subject of accessibility, who speak from a real-world
perspective. They share freely their best techniques, so that we can
create the "best possible experience for the greatest number of
visitors."

For me, Web Accessibility: Web Standards and Regularory Compliance is a
must-have.

I am not an expert developer but I have a fair amount of experience building financial applications in Java and C++. I spent quite some time looking for a book that would get me started with Web technologies. It is not easy. Yes, there are many books that describe one or another technology but I wanted to find one that puts these technologies in prospective. I was very pleased when I found this book. I can always dig deeper in one direction when I need to but this book helps me to understand how to get started and where to concentrate my efforts. I like it, I think it is very useful.

I have to disagree with the reviewer who disparaged this book's emphasis on history. The background on TCP/IP protocols explained how HTTP came to be and why servers and browsers work the way they do. Discussion of how web development platforms evolved provided insight into the problems newer approaches tried to solve and the problems some of them created. The authors may have gone overboard spouting the merits of "separating content from presentation" and touting the praises of MVC approaches, but their point is a valid one you can really relate to if you've worked with page-centric platforms like ASP and JSP. The historical review of different approaches explained the authors' reasons for ultimately choosing an MVC approach with Struts and JSTL, and offered insights into how development platforms may evolve in the future. This is a book that starts with basics and builds on them, covering protocols, markup languages, and development platforms. The history helps drive the points home. Personally, I learned a lot from this book. I agree that they could have provided a CD-ROM, but it turns out their website (webappbuilders.com) is pretty good and has other good info aside from the app's source code, including some articles from the authors.

This book is an ideal text for providing intermediate-level web developers with a solid grounding in architectural principles and more advanced techniques. Before going into why I like this book I do want to offer one caveat - the authors' approach is towards the Model-View-Controller paradigm, and is based on Java Standard Tag Library, Jarkata struts and Apache. These are solid elements, but if you are working in a different environment you will not appreciate this book as much.

The historical material in this book is not fluff if you approach it with the intent to gain a fuller understanding of the major components of the Internet and web. This material is rich with details about why the core web technologies developed and evolved, including design choices the pioneers made in the face of constraints. In a subtle way this part of the book is a primer on design and architecture.

What makes this book so valuable is the non-trivial application that brings this book alive. This is a refreshing change from other books that use thinly contrived snippets of code or trivial applications. The code for this application can be downloaded from the book's supporting web site, which also contains errata (thus far there are only two entries), and articles that are valuable resources with or without this book.

Overall this is one of the better books on web application design and development, and one that dives into code and technical details.

I've been writing Windows-based mutlimedia applications since Windows 95 was released. I've been looking for a good book to help the crossover to web application development, and I found that this was just the ticket. Explanations were solid and presented in a way that made experimentation easy (both from the browser and server side). Quite simply, this book served as a great jumping off point for deeper exploration into session management, security, web services (both SOAP and Rest), etc. Definitely a great introduction for folks with a software engineering background.

I always thought Amazon search is good but I stumbled upon this book at a store. It's a useful summary, but not a reference. I particularly like the examples and the way they build up from trivial to complex. The level of detail is right. Altogether, very refreshing.

Kalpanik blends art, craft and wit into a narrative which teaches us lessons we did not know we know.

This book combines elements from good humor, a memoir, a scenic travelogue, a touching love story, science fiction and philosophy.

Whether you ever wondered about meaning of it all, or you want to read something light amusing, or want to see places like Seattle, San Diego, and Nashville from the eyes of the writer, or vicariously live the life of a
student at University of California, this book is for you!

The author, purportedly an Artificial Imagination computer program simulating a life/career journey through the Hi Tech and yet very scenic world of California and Washington (Settle) is witty still though down to earth and funny! The book is written in a very conversational style, as if you are reading a letter from a close friend!!

Great book, love it! It's hilarious! I could not stop giggling, I cracked up page after page. Really Nice!

And so many nice photographs. I felt I was traveling with the author, no, I was him, feeling his ambitions, his surprise, excitement and pain. And what a brave soul! He (yes, despite its claims to have been written by an AI program, this book is written by a loving, feeling, breathing human for sure!)--He is able to maintain his sense of humor even as he moves from one place to another, faces one set back after another! He always comes back!

Wow! What a story!!

This book transcends genres -- it's a good collection of memoirs, entertaining style, nice splash of humor, an extremely detailed travelogue with beautiful photographs, a good description of technology, a touch of Science Fiction (since it is purportedly written by a Artificial Imagination program) and suffused with philosophical musing and last but not the least, a moving love story.

Even though it's obviously written by a Technologist, the book is very human. It is primarily about the immigrant experience, but Kalpanik is extremely observant and has an eye to look for the unusual, notice what stands out and build humorous side of people, places and his own life.

Wonderful! I am specially moved by his bitter-sweet love story at the beginning.

Watch Video Here: http://www.amazon.com/review/R167JUBPRPS0DJ Entertaining and interesting!

Steve Heller does it again, this time pushing the envelope. It continues where his Introduction to C++ left off in Who's Afraid of C++, and gets into more complex topics. The book provides another great stepping stone into the world of C++ programming. Its a great book, and worth the read if you are a bit more than a novice, or you have read the previous one. It not only tells you how to program in C++, but explains why you do certain things, something which other C++ books skip on because they assume you've already learned C. You don't have to learn C to program in C++, this book proves it, and if you know C++, then its a snap to do a little C programming.

1. Steve writes VERY well. 2. The interplay between Steve, and Susan is very engaging (it ought to be, ... they got married) 3. Steve uses iterative improvement to demonstrate how software really gets written. 4. He admits to his mistakes, at least some of them ;-) 5. He presents the material in a way for the reader to add new knowledge to a solid foundation.

Steve, you done good!

I've read some of the more technical language references for C++, but I'd always end up just using them to look up stuff when I got stuck. This book (and the first Who's Afraid...) both have a casual and clear tone that makes complex and abstract concepts seem to make perfect sense if you slow down and especially if you read the questions asked by the "student". About 1/2 to 2/3 of the time I had the same question. Some people won't like the fact that it's not purely a technical book, but a little story goes a long way in making a book interesting enough to read through instead of wade through.

Following the lead of the first book, "Who's Afraid of C++?," this latest volume does not skip a beat. While most books _show_ you how to write _code_, this one _teaches_ you how to be a _programmer_. The two are not synonymous. Through the object-oriented development of a realistically sized application, the reader is engrossed in the software design process. Features of the C++ language are introduced as their need arises in the program, giving the reader a great perspective on why they exist and how they are used effectively in real programming situations. You will learn how to truly utilize C++ as the tool for solving problems and designing great software. At the end of this book, you will have the tools necessary to advance in the world of C++ with great confidence. Without reservation, enthusiastically recommend the two "Who's Afraid of..." books to anyone interested in truly learning C++. I pity those who have to learn it any other way!

The genius of Steve Heller has created a masterful sequel to his original work "Who's Afraid of C++." His treatment of complex topics like encapsulation, inheritance, and polymorphism demonstrates an understanding of the difficult process of learning advanced C++ concepts. Steve's goal is to help the reader understand how to create his or her own class as opposed to simply referencing classes created by others. His writing style, which includes using a student-teacher dialogue, is unique in the world of C++ instruction. All of the topics covered follow a logical progression of thought. His in-depth treatment of memory addresses and program instructions enables the reader to see at a glance the complex workings of the execution of a C++ program. The highpoint of the book has Steve teaching a unique method for the creator of a class to hide pointers from the user of a class in order to prevent many of the common memory-allocation problems associated with C++. As he did in the original "Who's Afraid of C++", Steve encourages the reader to build a working example of the techniques covered in the book. The software included with the book has the source files used and a C++ compiler on CDROM. There is also an e-mail discussion group that allows the reader to contact other readers and Steve himself regarding issues covered in the book. In addition to all the C++ covered, Steve offers his thoughts on the Y2K problem and its consequences. If you really want to understand C++ and develop your general programming skills, you can't go wrong with this volume.

I was told about this book by a co-worker who took classes with Professor Giannini. We were discussing a new project I am starting which required some internet and database access code, which (since I have done mostly GUI programming) I wanted to brush up on quickly.

This book was very well written, and seemed to address exactly what I needed. I found the sections on CGI and COM very helpful on the Internet side (part of our project is a ColdFusion page using a COM object), and the comparison of various database approaches like ODBC vs. DAO very helpful. The sample programs comparing the different database technologies was a great idea.

My only complaints would be that the index was a bit hard to use, and there was no CD provided. But, I was able to locate the source code for download on the authors FTP site.

I recommend this book for anyone familiar with programming, that needs to get working quickly with some new specific aspect, like Internet or database.

I got this book because I was tired of diddling around with the MFC Socket classes, and none of my other books seemed to have much material outside the predefined classes (CInternetSession, CHTTPFIle, etc.). I was very glad to see the source code for the CPNSocket class, and it explained a great deal. Seeing the MFC classes just completely bypassed, seemed to prove my own frustrations.

Then, looking at the other chapters, which is rich in MFC examples, I decided I had made an excellent purchase. If you are an MFC programmer at any level, I highly recommend this book.

This book covers a lot of material on both API and MFC programming for Windows. I got it mostly for the Internet topics, since it seemed to have a pretty wide range of topics, including ISAPI extensions.

The sample programs, an FTP program, an emailer, a link lister, and others, were all very neatly written, and the source code described them in good detail. The socket class described in the book as a replacement for the MFC classes, was an amazing piece of work, and discussed each function in a clear understandable manner. I got everything I wanted out of this section, without having to purchase multiple books.

I'm glad to say that I now feel comfortable with several new technologies (to me), and have some excellent sample source code to help me understand it all. Increasing your knowledge in as many possible directions is important in this field, and this book helped me.

It's hard to say where this book fits in exactly, but it does several things nicely. One, it has a very broad range of topics. Going from basic windowing into database and internet programming, but showing the code and step-by-step instructions for each. I didn't read any of the beginning chapters, but then happened to find an interesting section on MFC subclassing with a great demo, and decided that I should probably go back and read the first part.

I especially liked the chapter on database access, and the fact that there are 3 programs that are identifical in every way except how ODBC, DAO, and ADO work with the data. That gave a great chance to compare the various methods. The introduction on database access was good for a beginner, but also had some interesting observations and hints for the more advanced.

The section on the Windows Installer, and creating installation programs is also a topic I hardly see anywhere, so having it all in one nice package was great.

If I had to nitpick, maybe there could have been more on Active Directory for Win2000. But, Win2000 was covered enough to get you started, and the PocketPC programming was covered in a bit more detail.

Summary: I liked it alot. It is right on my shelf now with the Kruglinski and Petzold books.

You can't go on a holiday to Portugal armed with only a Portuguese dictionary and grammar book and hope to converse with the local people. You will be forever turning the page here and there to construct the sentence you want to say. What you need is a phrase book: a book containing common and useful phrases such ` Where is the nearest tourist office please?' or `When is the next train to Lisbon?'.

That's what this refreshingly straightforward and intelligently laid out book, written by Keogh&Giannini, is. It is a phrase book for Windows programmers. The most common scenarios are discussed, with full code given. You won't find obscure situations such as those found in Petzold's oversized Windows Programming book like how to draw an elliptic circle in a window! What you will find in this concise book is useful code such as creating an application where the main window is a dialog box used for data entry through edit boxes. (This very common and fundamental of situations is not addressed in Petzold's book).

Each example is explained sufficiently enough for any programmer to build on or tailor to their needs. And the core explanations are embedded within the code so you won't have to laboriously cross reference with the main body of the text. How refreshingly intelligent is that?!

Whats more, for those new to the Visual C++ environment, step by step instructions on how to use it to enter the code and build it are given in list form e.g. 1) Select File/New menu choice 2) select the Win32 Application project type, and so forth. Most Windows programming books often make the assumption that you know your way around the environment.

And you will find each example written in both MFC and Windows API! Name me a book that has done that?!

The problem with so many Windows programming books on the market including Charles Petzolds and Joseph Newcomers is that they are basically dictionaries, grammar references of the Windows language. They are inaccessible. If these books were to be useful to anyone it would only be to a seasoned Windows programmer who already has a feel for the language, but definitely not for a beginner. These books are not practically organized and don't fit the needs of today's developers. For example, discussions on essential topics such as dialog boxes are left until chapter 11 in Petzold's classic; in Keogh&Giannini's book, it is discussed in chapter 3. And Petzold's book misses a number important programming issues. These are not my own criticisms by the way. These criticisms are those of Dr Dobbs Journal, arguably the most technical journal in computing, certainly more so than those that Petzold decided to quote on the back cover.

In Keogh&Giannini's book , there are bonus chapters on database programming (ODBC), internet programming, Windows CE and 2000 programming, threads, ActiveX controls and lots more.

I am giving this book 5 stars because it is head and shoulders above the rest in terms of accessibility, completeness, conciseness, modern refreshing style, and its use of novel approaches to speed up learning for the impatient novice Windows programmer.

I have shelves filled with computer "How To" type books and in the past have stayed away from the "Dummies" series thinking them to be a bit too simplified. However, recently I needed to get up to speed with Microsoft's Access, specifically in order to prepare reports. So I bought Access Forms & Reports for Dummies by Brian Underdahl. I found this book to be a refreshing diversion from the normally dry and sometimes obtuse computer books of the past. Mr. Underdahl has a colloquial writing style which is not only entertaining but highly informative. Within a very short period of time I found myself successfully creating Forms and Reports which made my work go much smoother. I highly recommend this book to anyone who needs to understand Access and quickly create Forms and Reports.

Access is, of course, a database program. Unlike many of the big database programs, it is closely integrated with a quite sophisticated front end package to enable the creation of easy to use input forms and quite good looking reports to take the data stored in the database and present it to the outside world in a clear and useful format.

A database is useless unless you have a way to put data into and take it out of the database. This book mostly covers the setting up of input forms and output reports. It obviously won't be your only Access book, because you'll need something to describe how to set up a database. So this is a specialty book, that does an excellent job of covering this important aspect.

Selecting data out of the database to then present is sometimes a problem. Most beginning books just use the Access QBE to produce the data. Often this is enough, but this book goes just a bit into SQL that allows you to do so much more. While this is not a book on SQL, this is a good start to give you enough information to know if this is a direction you need to go.

All in all, this is a very useful book to enable you to get more utility ot of an Access database.

First, it is important to realize what this book is not. It is not a complete Access reference book. It will not teach you database theory and all aspects of data normalization. It does not cover advanced techniques such as VBA programming, the ADO object model or using the Windows API.

So what do you get from this book? A fantastic introduction to developing forms, reports and queries. In the tradition of the Dummies series, the author gently guides the novice towards building expertise in this narrow but all important aspect of Microsoft Access. With a conversational style, each step in creating a report, form or query is clearly explained. Also, the reasons for creating a report or form, and the differences between the two are presented. Although the title doesn't mention queries, because they are integral to producing reports and forms, several chapters deal with queries. Finally, two chapters discuss enhancing queries with SQL and troubleshooting those queries when things go wrong.

In summary, by spending a few days with the author, via this book, a beginning Access programmer can quickly become adept at designing forms and generating reports.

I use Access daily and thought I knew it pretty well. But this book really showed me a lot of new tricks I couldn't find anywhere else. This is by far the most useful book on Access I've found!

I bought a bunch of Access books, but this one is by far the most helpful one yet. It shows me how to do a lot of things I've wanted to do, but simply couldn't figure out on my own (or from any of those other books). You really need to add this one to your collection!