Programming Books

this is good companion to C in nutshell. answering your c question quickly and effectively.

Not intended as a reference or a tutorial for the C language, this book fills one niche well - the gory, often forgotten or differently understood, fine details. When writing code, and noticing some behaviour which doesn't look completely natural, this FAQ can often help clear some things out.
In my opinion it is also good to read it at least once from the beginning - this gives some good insight on the language that might not always be immediately visible to beginners, or intermediate programmers who do not have years of experience behind them.
Most every C compiler these days supports some extensions and non-standard features, and some of those might be difficult to notice as non-standard. This book will also help you program in a more portable manner, and think in more standardized C.

Summit gives us an extensive test of our C knowledge. While C has a simple syntax, and lacks object oriented complexity in notation, there are many nuances that catch out unwary programmers.

A lot of the questions revolve around the assembly language-like constructs in C, for pointer arithmetic. Very easy to trip up here. And also in the related area of memory (buffer) allocation.

If that is not enough to keep you busy, Summit also talks about issues of portability across different operating systems or across different versions of the same operating system. At least you usually don't have to worry about the version of C itself. For system dependencies, Summit covers both unix and MSDOS. While C and unix grew up together, a reality is that much C programming goes on under Microsoft.

The references to MSDOS in the text reflect that the book was written in 95. Though even then, Microsft was deprecating DOS in favour of its newer Windows offerings. A newer version of this book might be overdue. Where Summit would no doubt discuss C under XP.

Simply put, this book does a good job of condensing years of FAQs from the comp.lang.c new group. Some of the questions really get down into the nitty gritty of C. The answers are easy to read and understand.

This is an essential book for any programmer. I remember buying it when it first came out in Fall 1995. I was an undergraduate senior at the time and thought I was a hotshot C programmer. How mistaken I was! Reading through this book was a humbling experience, as each page showed me fine details of C that I did not already know.

This is an excellent book. It is organised into chapters on different aspects of C, and in each chapter are dozens of FAQs that range from rather common to extremely fine-detailed. Three chapters which I particularly liked were Chapter 1 (declarations and initalisations), 3 (expressions and evaluation order), and 6 (arrays and pointers). Later chapters introduced new (at the time) concepts to me, including getopt, variable-length argument lists, and preprocessor tricks. The level of detail provided in each answer is extraordinary.

Other things I liked about the book: The index is excellent. There is a lot of discussion (spread across the FAQs) on the differences between K&R and ANSI C. (This was relevant to me because at the time, I was splitting my work between gcc and the proprietary cc compilers on DEC Ultrix and SunOS.) The style of writing is friendly and does not talk down to you. This is not a beginners' book!

Note that there is an online version, but it does not have nearly as many questions as in this book.

I salute this author with his kind of patience to walk through the implementation of the tiny PIM with the STL and with very detail and clear explanation. He has started his plan well with the class diagrams. I have learnt and pickup a number of good programming techniques (as simple as the various way of string manipulation) from this book and going to try as many STL as possible in my project development using Borland Kylix 3 Professional (C++), GNU g++/gcc, Visual C++ Professional 6, Borland C++ 5.02 and Borland C++ Builder.

Great intermediate explanation of the C++ Standard Library complete with a project from beginning to end. I especially liked the approach the book took by equating its premise to learning a foreign language by interacting with native speakers rather then memorizing the vocabulary.

This is a very good approach to teaching the standard library. The author has a style very similar to mine, so perhaps I'm biased... but I don't think so. He writes clearly and with a purpose in mind: to help the reader understand the material as thoroughly as possible. And he accomplishes his goal, with only a few typos along the way as minor distractions.

One point I should clarify, though: as far as I can tell, Jesse Liberty's contribution to this book consists of having his name on the cover. While this is unfortunate for the actual author, whose real accomplishments are undermined by that association, it is much better for the reader than if Mr. Liberty had actually had anything to do with the writing of the book. In that case, I would have expected to see much less clarity in the explanations and hundreds of errors, as those are his trademarks.

Kudos to Mr. Halpern! Keep writing... but under your own recognizance. You shouldn't have any trouble finding a publisher who will take you on without any "sponsorship". Good, clear technical writing is hard to find.

After returning every STL book I've purchased I caught this book here on Amazon. Pablo Halpern does a great deed to the STL community by putting out a great book on STL topped off by the use of UML to help students understand the full cycle of developing an application. If you're new to the programming world this is a MUST have to quide you along analysis, design, and implementation with a concrete example. If you're a seasoned pro but are missing STL from your life ( much like I was til I read this book ) this book will get you going. Halpern does a great job of keeping the example on an open architecture, so for those of us who want more than in-memory persistence and a command line UI implement a database and our choice of UI for the example. I myself turned this into a great COM+ web application using ASP for presentation and an added layer of COM+ data objects from my collection to hit a SQL Server 2000 database...

I am half way through this book and thoroughly enjoying it. The STL is incredibly powerful. I have read Josuttis' book, which is also a great book, but once I finished it, I felt that I had a obtained a great appreciation for the STL, but was still a little uncomfortable using it. With this book I feel that I am getting a better feel for the library because I'm actually using it in the context of a real application and am able to experience first hand the usage and trade offs of the different containers/algorithms contained within the STL. Between the two books, I think that I will be well on my way to becoming STL proficient. Simply by working through this book, you will gain many months worth of valuable programming experience.

This is a great book for a quick hands on learning for XML. I really like it and it solved my problems. I always thought parsing the XML was too damn confusing but with this book I now completely understand the DOM and SAX parsing.

This book does a great job of introducing the basic concepts and getting you into code soon, so you can see the concepts and syntax in action. The topics included XML, CSS, XSLT and XPath, DOM, SAX, and XML Schemas. All these abbreviations are explained in the book. The core concepts are well introduced without being overwhelmed in syntax, and advice if often given on what is best to use (for example "Can I use DOM or SAX instead of XSLT?").

The use of an 8 character "CodeNote pointer" allows obtaining additional information from the codenotes web site while keeping the book a readable size and price. For example the paper chapter on SAX included examples in Java, but the online "CodeNotes" allows obtaining the source in Visual Basic. In the chapter on installation, I found both the instructions on the book and the online web site out of date, so they might want to update the web. The online notes on Sample architectures was particularly helpful, so don't neglect the section on "additional material" at the front of the book. I would have also liked an actual completed application demonstrated online.

This book is probably the best value of any of the technical book I've purchased. At only $..., this book covers all the important aspects of XML in a very understable and enjoyable way. It's laid out well and the examples (and following explanations) are clear and very helpful. If only all technical books could be written this well. And is that the most aesthetically pleasing cover you've ever seen or what?

This book presents the core of XML in an organized, no-nonsense fashion. If you need to get up to speed quickly on XML this book is a great investment (and quite inexpensive too).

I used this in conjunction with an Infusion class I took and what a great book! fantastic job!

The book is useful even if you have programming experience in other languages. It explains important concepts (list, cells, symbols, variables etc) better than many other programming books do.

Highly recommended!

This is a great book for those wanting to learn Lisp.
In the first part of the book, when describing functions, the author stays away from Lisp and any real programming notation, using diagrams to show some of the fundamental concepts -- which are explained in such a clear way that everything become so obvious! Later he switches to Lisp, telling you it's a "different notation for the same ideas".
The text is always clear, short and right to the point.

An excellent book for beginners. If you are a newbie and you want to buy only one Lisp book, this is it! Highly recommended.

We had a LISP course (prerequisite for AI) in the university, and our teacher used this book. I immediately fell in love with the language! This book is written in a fun way, that really makes sense. It was only from this book that I mastered the art of recursion (the cat in the hat comes back? the dragon stories?). Everything was fun about this book, you really have the sense that it was made with extreme passion and dedication; something that usually doesn't apply to programming books.

This is an excellent tutorial. A good place to start before reading any of Graham's books.

Although the book is now out of print, you can use the link below to download the pdf at no expense.

http://www.cs.cmu.edu/~dst/LispBook/

A clearly written book, which employs a simple language. Another beauty of the book is that all loose ends are tied up. As sentences unfold one will realize why a particular phrase was used earlier and so on. That makes a big difference for an engineering text book.

It is the best book that I know for fundamentals. Hence, it will be useful for years to come.

Must have for all embedded systems people.

Helped me in my undergrad (older version). Helped me when I gave subject GRE recently. Covered Pipelining superscalar, out-of-order execution processors, caching and secondary storage, combinational and sequential ckt review etc real well. No computer architecture book covered them all so clearly, and in one book.

This was the assigned text for my junior year computer engineering course on computer organization. I loved it. The explanations are clear, progress logically, and are clearly presented. I find myself picking it up from time to time, both to read the more advanced chapters out of personal interest and to look up details needed in more advanced coursework.

After reading this book do not believe you'll know everyting about computing , but you'll know more than others do.

I had a chance to recommend this to a colleague just last week. It is easily twice the price of the "competing" books on the market, but you get what you pay for. With this book plus (perhaps) a hands-on course in the microprocessor laboratory--interfacing various logic families to output devices, e.g., or whipping up a robot of limited capabilities--the student gains the ultimate understanding of what makes computer systems "tick," from the loftiest levels of software, through the details of instruction set implementation (microprogrammed control, prefetching, cycle-stealing DMA transfers) and even the detailed digital logic circuits that underlie the CPU.

I dare say the student who aces this course is all but prepared to build a simplistic CPU on his own--"simplistic" because, though the concepts can be understood quite completely, it's an intricate challenge. Notably, the book has kept pace with the times: while the PDP-11 instruction set is didactically wonderful--clear and easy and even sporting reasonable opcode mnemonics--you don't see lots of PDP or LSI (or, for that matter, VAX) minis floating around nowadays. So, HV&Z moved on to the 68000, the Power PC, perhaps even the Pentium in the latest (of five or six) editions. (Good move, gentlemen: you've actually done your homework rather than just changing "happy" to "glad" and reprinting with a new version number!)

I used this book as a junior, but (a) I went to Cooper Union, which operates at an extremely high intellectual level [let's put it this way: I took a number of graduate-level computer science electives--compilers, OS, etc.--taught by Bell Labs MTSs as a junior and senior; and some "doctoral" courses that I took at Case were--honest Injun--watered-down versions of similar courses I had taken at Cooper], and (b) I graduated more than twenty years ago, and requirements always creep downward: a few credits fewer, a few tangential courses eliminated, perhaps one fewer humanities elective necessary to matriculate, etc. By 2006 standards, I would reluctantly have to reclassify HV&Z as a postgraduate text.

(A little puzzle for the reader: we had to build--from NAND gates--a microcomputer featuring two three-bit registers, and my squad was the only one that implemented an "exchange registers" function that required only one cycle and used no auxiliary storage registers. How did we do it? Tick ... tick ... tick ... time's up! The circuitry compared corresponding bits from both registers. If they matched, it did nothing; if they differed, it flipped both! So, there was no literal "exchange" operation: rather, each was simultaneously reset to the value of the other.)

For those engineers who start their first embedded Linux project, this book is a must have. The book is not for those who want to understand how kernel runs but it gives you the most important concept and work flow to bring up the OS on your development board. The author also provides a useful further reading list in case you want to dig more. A very practical and clearly written book and I would recommend it to those who have solid experience in embedded development but just start to explore in Linux.

This book is very well organized, and provides a good level of detail of the topic. I do recommend it.

I am an experienced embedded developer that just inherited an embedded Linux-based project already in progress. As there happens to be no one else at my company with any embedded Linux experience, I automatically became the de-facto Linux expert and I needed to come up to speed on a lot of topics very quickly. I found this book to be an excellent survey of the must-know topics for the embedded Linux developer. It also contains many references to the most definitive sources of information on the various topics. Highly recommended for coming up to speed on embedded Linux.

Wow!
So far the book proves that embedding Linux while not easy can be fun and interesting. You never know what Tux will do during his startup sequences, even if you did indeed write the stuff the kernel is using for that series of startup steps.

This book, the CALAO SYSTEM USB-A9260 card, an eeePC and a cross over cable is all that you need to study embedded system everywhere (even along the Seine river in Paris - yes I did it !).
The chapters about the U-BOOT bootloader, the BUSYBOX embeded Linux and an extra piece of information on the JFFS2 file system are welcome. If the cross-development environment chapter had been about BUILDROOT, this book would have been THE BOOK for the present embedded Linux based systems designers.

This book teaches you how to think about designing web interfaces for social websites or websites with social features. You will learn a bit about the psychology behind what works well, so you can incorporate the knowledge into your own design.

The book explains how to prioritize features from the initial sign-up through active user participation on the social website. Many industry examples are given along with some of the reasons why each is successful or not.

The book is about designing the user interface and the overall web site experience. It can and should be read by all team members on the web project including: graphic designers, information architects and developers.

I think its an excellent book
Sadly I lost it after reading 1/4 of it
He knows his subject Design for Social Web
and it was very interesting what I read
and there are good diagrams

Judy

I used this book as one of three textbooks in a class I recently taught. This was one of two texts concentrating on social networking. (The other was Derek Powazek's "Design for Community".) The students enjoyed the easy style of the book and the case studies for what works and what does not. The book kicked off more than one interesting discussion on barriers to entry, what makes good design, and how to effectively incorporate social networking tools into a business or non-profit website.

I bought this book a few weeks ago and found it a great introduction to the concepts involved in designing social applications.

Many of the most amazing success stories on the web are social websites (youtube, myspace, facebook, flickr etc), yet books on this topic are hard to find. "Design for Community" by Derek Powazek is one rare exception, I consider it a masterpiece, but it was published in 2001 and it's out of print. Finally we've got some fresh, up to date material. Porter benefits from extensive, first-hand, experience in the field; he has a pragmatic, practical approach to problems, he deliver valuable advice without pretending to know "the ultimate truth" (like many authors do).

The book is well layed-out, and descriptions are clear and concise. The first 95 pages or so are relatively basic. I have used a crusty version of Homesite to create a few basic Websites in-the-past, so those first 95 pages didn't teach me anything that I didn't already know. Except perhaps for the design and paper and pencil preparation.

After page 95 (or so), you jump right into Dreamweaver and are instructed as to its' functions. The Webpage you're building is a basic HTML page, and does not use any server-side technology like ASP, or PHP, or CGI/Perl.

It too is well layed-out, and step-by-step. I only wished that a deeper discussion of CSS integration was employed.

So, for the beginner, or for someone who likes to paper & pencil prep, I'd have to say that this is a worthwhile buy.

For the more advanced user, I'd have to say that you may be better off with more of a reference-style tome.

All said, I do not regret the purchase.

This book takes you from web-site zero through building a basic client-side only web site using Dreamweaver 8.

My only critique is that it seemed like we didn't even get to actually using Dreamweaver 8 until about page 100. Before that was an intro to general web-site concepts and HTML.

Anyway, it's an attractive and informative book that is priced lower than most.

If you are looking for website building software, you might want to take a look at Dreamweaver 8: Design and Construction. This book educates the reader on the various aspects of Dreamweaver 8. It also shows the reader, step by step, how to build a website using this software. The author also includes all sort so tips, illustrations of what the reader will see as he or she builds their site, and helpful tech talk boxes that explain some of the more technical issues in an easy to understand way. Everything in this manual is suitable for those with little or no knowledge of website design or website design software.

I believe that the best way to choose website software is to understand what that particular program can do and how this may or may not suit your needs and your abilities. It doesn't help to buy software that can do seemingly magical things if you don't have a clue how to actually make it work. This book helps the reader understand the basics of the Dreamweaver 8 program with a taste of some of the more complex things that can be done.

This book is well written and laid out well (for the most part), but the lack of color really, really hurts this Dreamweaver 8 guide. Perhaps I am being a bit of a stickler, but a book in 2006 not only needs to have good content, but it need to also have a great layout as well. Deciding to go with 5 major colors (white, black, grey, blue, dark blue) not only makes the book seem dull and drab, it detracts from the reader the good content within.

For anyone that uses Dreamweaver 8 on a daily basis this is a great reference guide but the layout editor could have done a much better job. If you care about content more than pizzaz, I think you will be happy with this book

**** RECOMMENDED

Are you new to Dreamweaver 8? If you are, then this book is for you! Author Marc Campbell, has done an outstanding job of writing a book for people who are new to creating their own web sites from the ground up and all that it entails.

Campbell, begins by showing you how to devise your plan. Then, the author shows you how to develop a blueprint for your site. Next, he shows you how to add just about anything to the pages of your site. Finally, the author shows you how to take the working prototype that exists on your computer and publish it to the Web for all of the world to see.

This most excellent book serves an introduction to creating web sites using Macromedia Dreamweaver 8. More importantly, the focus throughout this book is that sound design and usability are inextricably linked.

Excellent book on JMS,
topics in book like easy going ,
dont think just buy and read its worth

This is a very decent book for JMS. It works out well to learn the basics. It goes into good depth on the basics. After the basics your pretty much on your own for getting too advanced.

This book makes the process of learning JMS easy for all skill levels. Dr. Yusuf provides real-world examples in a language that is down to earth. He has assembled its content into sections for someone just learning JMS while providing code samples for the seasoned developer. I found the "how to" diagrams extremely helpful when configuring Enterprise JMS in WebSphere. This is a must have for anyone interested in JMS and how it's applied in an IBM WebSphere environment. This is an excellent book!

I found this book extremely useful. It is practical, well-written and provides the necessary ancillary information required to understand the topics. The author builds up nicely from messaging, to JMS basics, advanced JMS topics, IBM JMS offerings, hands-on scenarios(which bring it all together, especially for people who learn by doing), and deployment. In addition, throughout the book, the author provides implementation considerations, recommendations and best practices, which will be of great value to designers and developers alike.

I've been working with WebSphere for over 5 years (since the beginning) and this was still worth reading. Great book full of examples, step-by-step "labs". This is focused on WebSphere and MQ, but will be very helpful to those who wants to use MQ with any other J2EE server. If you are not MQ and not WebSphere user - this still will be helpful since it has great deal of JMS basics, but you will have to use your vendor's tutorials and examples instead of those in the book. Concepts are still the same.

If you are using the Rational Unified Process, or considering doing so, and worried about applying it to a whole IT department rather than separate projects then this book could well be useful. The book has four parts - From RUP to EUP, Beyond Development, Enterprise Management Disciplines and Putting it all Together. Each section has several chapters and the chapters all start with a nice reader ROI section (showing the payoff for reading that chapter). The writing is clear and there are plenty of diagrams, tables and helpful tips.

The book starts of with some background in the RUP. I particularly liked the description of RUP as serial in the large and iterative in the small. Within the RUP there are also nine disciplines (Business Modeling, Requirements, Analysis and Design, Implementation, Test, Deployment, Configuration and Change Management, Project Management, and Environment). The authors outline 10 best practices they see as core to the EUP (they extend the original 6 in RUP) - Develop iteratively, Manage requirements, Proven architecture, Modeling, Continuously verify quality, Manage change, Collaborative development, Look beyond deployment, Deliver working software regularly and Manage risk. Each is clearly described.

In addition to the change best practices, EUP adds a Production phase and a Retirement phase. They point out that the Production phase is not just maintenance or just operations and support but both and more. I think that any organization building systems should spend as much time and effort thinking about production and running their application in production (which includes maintaining it over time) as they do in building it and I was glad to see this so strongly proposed. They also added an operations and support discipline, mostly but not entirely in the production phase. This discipline includes running the system and making hot fixes. I think the Retirement phase is overkill for most organizations but some will find it useful.

They also added some "Enterprise Management" disciplines for use outside the context of a project and this too is a good idea. The disciplines are Enterprise business modeling, Enterprise Portfolio Management, Enterprise Architecture (I particularly liked the idea that "modifiability" should be considered as part of an enterprise architecture - far too few organizations do this well and fail to differentiate between stable services and much more changeable ones), Strategic Reuse (Again I liked the called-out focus on this - without a real plan no reuse is going to happen), People management , Enterprise Administration and Software Process Improvement (Another good one and a timely reminder to all that you should keep improving your software processes)

Overall I liked the book, though it was a somewhat dry subject (as methodologies often are). There was a lot of good advice, some nice tips and some clearly hard-won experience being shared!

Many IT organizations still pursue pet projects and develop duplicate applications in isolation, only to address later crises in corporate reporting, portfolio management, IT infrastructure, business objectives, and other areas.

EUP gives a coherent roadmap of how to architect smarter and for the long term. For organizations that don't have a strong enterprise aptitude, this book is a lifesaver. The EUP provides the business case for implementing EUP that will help cut through the politics by addressing the benefits to the bottom line for pursuing an Enterprise Unified Process.

I will be referencing the EUP regularly, and passing it around to others in my organization!

The Enterprise Unified Process (EUP) unites diverse disciplines, including development, enterprise architecture, operations, production and portfolio management, reuse and business process modeling, under an easy to follow framework. It was refreshing to find a book that recognizes the need to accommodate the installed base of existing software as part of the planning, development and deployment process. This is an excellent guide for any manager who wants to ensure that essential IT disciplines are addressed.

The focus of EUP is to enhance the commonly accepted Rational Unified Process (RUP). The authors have added new disciplines to RUP that include business modeling, portfolio management, enterprise administration, reuse, enterprise architecture and process improvement. The introduction of business modeling into the overall process is essential to weave IT processes and disciplines into the most essential driver of any systems initiative - the business. The enterprise architecture discussion was also refreshing given that many organizations have forgone this discipline and have created redundant, stovepipe applications and data structures that significantly stifle business agility.

The "Reuse" chapter raises the rarely deployed reuse strategy. It is critically important to not replicate business processes, models, systems, data structures, source code and interfaces. The costs and risks of trying to keep parallel assets synchronized have been written about extensively. This book promotes the idea that reuse is just another aspect of the enterprise unified process. It is also one of the few discussions about reuse that recognizes the value of harvesting existing assets.

Also of note is the portfolio management discussion that focuses attention on the need to incorporate project management with application management. It should be noted, however, that portfolio management has much less focus on applications than the traditional industry definition as promoted by Gartner, Inc.

Finally, this book makes great use of tips, tool references and citations to books or papers that readers can use to expand on their understanding of a given topic. The last chapter of the book takes a realistic and honest look at deploying the enterprise unified process, including its possible retirement.

This book is must readying for any organization using -- or attempting to use -- the RUP. The EUP's additional disciplines completes the RUP in a necessary and sufficient manner.
The book is written in a straight-forward manner, is easy to read and is well-organized. Each chapter reminds you to be practical (the antipatterns), explains how the additional discipline relates to the others and provides software tools and suggested reading.
Don't RUPture your software development efforts without having the more comprehensive approach of the EUP!

The book provides a very readable coverage of IBM's Rational Unified Process, as well as useful extensions that address important aspects of enterprise systems planning, development, and management. The systematic and disciplined treatment is greatly enhanced by the inclusion of much useful, pragmatic advice that draws from the practical experience of the authors in building real systems.
I quite liked this book. Although it doesn't give enough emphasis to conceptual data analysis (something RUP has always been weak on), it has loads of useful, practical content that make it a worthwhile addition to the literature.