Programming Books

5 Stars

A useful book, shipment very fast! in 9 days i received it...and i live in Italy.

Thanks Amazon

Creative
Clear
Consistent
Cost little

Most software "companions" (more than a manual...not quite a book) really do not do justice to the software. Quite the contrary for the AMPL guide. AMPL (the language) is a *very* powerful and *very* easy to use Optimization package. It interfaces with most of the major solvers. Users program in AMPL which is more or less pseudocode and then solve LP, nonlinear, combinatorial, integer, etc. programs. Unlike most software packages, it is both robust and easy to use. Likewise with the companion/book. There are many great, easy to follow examples, and it clearly explains the intrecacies of the language. A must use software and most own book for anyone doing any optimization work.

The coverage of the theory in the first part of the book is very well done. However, its the practical examples in the second half where the book really shines. There are a number of examples modeling client server and web applications.

A copy of his modeling tool, PDQ, is available by download from his website. This version is in Perl. Even though I am not a very experienced Perl programmer I think this is an interesting way to get more practice by building PDQ models. The PDQ package is explained very well and a number of example models are covered.

Some of the examples are from various scattered publications. It's great to get these example models collected in one volume. Dr. Gunthers characteristic sense of humor comes through in the examples.

There is some very practical information about model validation and what to do to account for hidden latencies. There are clear examples of how to practice the art of applying queuing models to real problems.

I would have liked to see some more examples of load dependent servers. Overall I rate the book five stars and I really appreciate getting the modeling software for free!

This book lays out basics of queuing theory in a way that is both understandable and easy to apply. I have fumbled for years using complex performance analysis tools without ever really knowing whether or not I'm getting the right answer. Now I know what looks right and what doesn't. Gunther has an easy to follow style as he introduces the concepts of queuing theory. Then he shows you how to apply what you have learned using real life examples. It's a definite "must have" for the capacity planner or system performance analyst.

dr. gunther has written a gem of a performance analysis book. for starter, the unix load average is a wonderful detective story. i especially liked chapter 5 with real performance analysis experiences applying queueing theory discussed in both chapter 2 and 3. the best part is dr. gunther's exposition of queueing theory into the essence for the working performance analysts. in addition, appendix B on buffers and appendix C on memoryless property are the most lucid explanation i have read. i would also heartily recommend dr. gunther's other book, the practical performance analyst.

Great book for designer and technical architect, the presentation of the book is very good, it go through the guidelines, implementation examples and case studies in nice and simple way support by good charts, graphs and tables. That is one of few books in the market which cover all the phases of software life cycle including analysis, application architectures and design... Its easy to read and understand, but hard to find in the books stores, my guess its one of the great books I had in my library from couple of years.

Great book for designer and technical architect, the presentation of the book is very good, it go through the guidelines, implementation examples and case studies in nice and simple way support by good charts, graphs and tables. That is one of few books in the market which cover all the phases of software life cycle including analysis, application architectures and design... Its easy to read and understand, but hard to find in the books stores, my guess its one of the great books I had in my library from couple of years.

The author made no assumptions regarding the reader's technical knowledge. Thus, he provides a comprehensive guide beginning with the fundamentals of application re-engineering to the technical details of Web development; e.g., CGI and JAVA. Experienced architects will rejoice, because finally someone put all the information needed in one book. Those who are inexperienced with architectures or re-engineering can sit down and learn how all the different pieces fit together. This is the only book I have ever seen that puts all the pieces of application architecture and system design together tjat is easy to read, easy to understand, and steps through each part of the process. Well done!

This book has been a very helpful tool; it has helped me by giving me easy to follow sample programs. Having these examples to follow has given me the opportunity to find out what my mistakes were and correct them with less hassle. This book is a great tool for any student programming in more than one language. It teaches by examples, giving a hands-on approach to each example. Out of all of the books that I had to use to complete my project, this one book is the one that I constantly came back to look up any problems that occurred. With out this book my research this summer would have been a very difficult task, but with the sample coding to guide me through, I have produced a great project.

This is a terrific interfacing program book so far I have found in this site. The book provides a thorough description and detailed illustrations in interfacing programming between different languages with a lot of hands-on examples. As everybody knows, the easiest way to learn a programming language is via examples. I found that this book is an example-oriented one, and it combines theoretical knowledge with the practical programming techniques together to show me how to develop interfacing programs step by step.

Besides the interfacing technology, the author seems to have a deep understanding for each programming language. I found that in chapters, the author provides some useful hands-on technologies, such as the pseudo-components in the Visual Basic to access the
Database, recovering the developed program codes in VisualWorks in Smalltalk and developing a DLL in MATLAB. I cannot find those hands-on technologies from any other textbooks or professional language reference books in the market.

Finally, this book provides me an easy-to-learn style, which means that each example in the book starts from the fundamental level, and little by little, it gradually adds more complicated components and finally I can get a finished program that contains the completed parts I need to interface to codes developed in other language.

This book takes the theoretical ideas that are present in other programming books and makes it a reality. With easy to follow, practical examples, it guides the reader through techniques to communicate between different programming languages. Finally, there is a book that makes understanding how to relate information across the languages barriers a simple task. And with seven different languages, it is the only comprehensive work to do so. It was very helpful to me, because I needed to be able to send messages between two different pieces of code that I didn't have the time to rewrite. The thorough examples allowed me to quickly learn how to use the techniques and expand upon them so that it would do that which I needed it to. I learned a lot of things from this book that, previously, I didn't know were possible.

Our consulting firm has successfully collaborated with Dr. Powell for years and I have seen first hand how ADP solves large scale, real world problems that would frankly be intractable by many traditional traditional operations research or optimization techniques. While consulting firms and other business jealously guard their intellectual property, it is terrific for all of us that academics are rewarded for precisely the opposite. I would highly recommend for any serious practitioner to grab a copy of this book and study it. Probably one of the best $100s you will have spent in a while.

This book represents a paradigm shift in the presentation of dynamic programming/stochastic optimization. Classical treatments of dynamic programming/neuro-dynamic programming/reinforcement learning typically assume small "action spaces," and often assume the presence of a one-step transition matrix. By contrast, authors working with decision vectors in the presence of uncertainty often turn to stochastic linear programming. But these techniques typically struggle when applied to multistage applications. It is extremely hard to solve most of these problems without taking advantage of the presence of a state variable that captures previous history.

I have adopted the notational style where S is the state of the system, and x is a decision, using the language of math programming. x may have many thousands of dimensions for some problem classes (although the book considers many classical problems where decisions are relatively simple).

The challenge that arises when x is a vector when we use dynamic programming is the expectation within the max/min operator. Bellman's equation is typically written

V(S_t) = max (C(S_t,x) + discount * E{V(S_{t+1})|S_t} )

If x is a vector, we generally need the power of math programming to solve the maximization problem. The challenge is the expectation. We avoid this using the post-decision state variable, which is the state immediately after we have made a decision, but before any time has passed (bringing new information). Denoted S^x_t, the post-decision state variable is a deterministic function of S and x. If V^x(S^x_t) is the value function around the post-decision state variable, we obtain

V(S_t) = max (C(S_t,x) + discount * V^x(S^x_t)

The book provides a number of practical examples of this, but the key is that the maximization problem is now a deterministic problem. The final step is that we have to replace V^x() with a suitably chosen approximation. If our maximization problem is a linear, nonlinear or integer programming problem, we have to choose an approximation for V^x() that allows these algorithmic tools to be used.

In this book Warren nicely blends his practical experience in modeling and solving complex dynamic and stochastic problems occurring in a variety of industries (transportation, the financial sector, energy, etc) with algorithmical and theoretical aspects of approximate dynamic programming. The book can be either used as a textbook in undergraduate or graduate courses, or for practitioners to learn about recent advances in this exciting area. Indeed, I have already used it twice as a textbook for a graduate course, and on the other hand, I have recommended it to several practitioners. Without doubt, this is an important contribution in approximate dynamic programming.

I strongly recommend the book for all practitioners facing large-scale complex dynamic programs. It is also an excellent textbook.

The book is well organized, well written and clear. It's not a "programming language book": it will actually show you some great ideas about object orientation. The first half of the book teaches you Smalltalk (and the model-view-controller framework) and also helps show how important this language is to you if you *really* are into OOP. The second part is about best practices in design, implementation, testing and debugging.

The book focuses on VisualWorks Smalltalk, but it is OK if you are using some other Smalltalk implementation such as Squeak, for example, since most of the time it won't get into incompatible details.

I do recommend this to anyone interested in programming, and very strongly to those interested in OOP in general (not just Smalltalk).

history of smalltalk system

Simon Lewis's book "The Art and Science of Smalltalk" has to be one of the best books on Smalltalk programming I have ever read. After spending months reading many other books on the subject and still not getting a clear, concise description of some important Smalltalk constructs, I could not believe how incredibly readable this book was. Lewis has managed to explain in a few pages what took other authors multiple chapters.

In addition, diagrams and figures are only used when they will actually help the reader to understand a concept. Unlike other texts references to figures and diagrams occur in close proximity to them rather than twenty pages before or after.

The book is divided into two parts which address different but equally important aspects of programming in Smalltalk. The first section deals with the "science" of Smalltak and covers the development environment, class library, and dependency mechanisms (Model-View-Controller Architecture). The second section gives sage advice on the "art" of Smalltalk. This includes sections on how to best utilize Smalltalk in an environment of extensive reuse, management of Smalltalk projects, and debugging techniques.

I would rate this book as a must have for Smalltalk programmers at any level. If I were to teach a course in Smalltalk this book would be required. Lewis should be commended for his command of the Smalltalk language and his eloquence in explaining it to others.