Computing Internet Books

This book had everything a non-expert would need to understand the basics of the TCP/IP protocol and networking.

It helped me greatly to better understand networking and the OSI model.

The tone is very readable. And the use of graphics was good but could be better

Overall, I recommend this book to anyone who is trying to build a strong foundation in networking. I loved the IP address allocation and subnetting chapters.It really cuts to the chase so the reader can be doing real work in a matter of minutes. I expect to see rapid updates to this book.

I'd like to see the WINS chapter removed and replaced with a few more chapters about IPV6.I like the authors to go more in depth on IP version 6.

This book does a nice job on reviewing formulas and functions. It covers a lot of functions that other books gloss over or don't mention such as arrays, rounding, date/time functions etc.It spends a lot of time on logic and lookup functions. Best of all, it uses good business examples that help explain how to use the function. My big gripe with the book is that at times it skips details and just assumes the reader knows how to do something or understands why you would want to do something. Personally, I think the 2003 version explained details a little bit better however I still think that this is one of the better books out there for people wanting to use formulas and functions in a business environment. If you are looking for a book on solver and what-if however there are a lot better books out there.

I had originally studied the Microsoft Press book "Microsoft Windows Scripting Self-Paced Learning Guide", but still needed more.

VBScript, WMI and ADSI Unleashed is the book that I wish I had read first. It is a good choice for a system admin who wants to start scripting administrative tasks.

Having never scripted before, I had many questions. This book started from the beginning, what editor should I use for programming, and took me all the way to my first scripted program....to search AD for all Servers at or below a specified OU, remotely attach to each server, determine if it is a physical or virtual computer, run a hardware configuration utility as appropriate, reconfigure the hardware as appropriate based on the utilities output and report back to me the results. I went from nothing to decent in about two weeks.

This is a good choice for this type of book.

What a pleasure! This is a book written for technical administrators, by a technical administrator with a knack for writing. Don Jones demonstrates a talent for explaining the intricacies of monitoring and administering a Windows enterprise using WMI & ADSI scripting (et al) in a perfectly comprehensible manner without coming across annoyingly simplistic or condescendingly academic. Computer book writers take note!

Hey all,

I was a noob in all of this scripting stuff when I bought this book. Frankly it was not a bad purchase but it did leave me kind of disappointed. The first few chapters are a waste of time because there just like a huge sales ad for the author's company that sells a VBScript IDE, added to that you never get that feeling that he's fully convinced of what he is telling you, i.e. "You should learn VBScript but it doesn't matter because we have the impending doom looming over called Windows Powershell".

Last but not least is the fact related to the title of my review, basically he stresses the point that to learn VBScript you should get the online documentation for it......then what the hell did I buy this book for? If I wanted to learn structured programming I would've bought a C++ book that will do a better job.

All in all, the book has it's good points..I just can't remember them right now 'cause I'm hungry and it's Christmas Day. It does give you the basic knowledge what scripts can do, although if you been a windows admin for a while then this will only confirm to you that there are other ways of doing stuff....and that you need the VBScript online documentation (which by the way was hard to find on Microsoft's website) to do them.

This is the only scripting book I've so sadly I can't give you an alternative to it or compare it against any but if you really are into self-learning I think that a little organization, time and all the documentation available at MS's website might do.

If you have the bucks to spare buy it, if you have time on your hands don't buy and turn over to the Net to learn.

I found this book to be very helpful and practical with the examples given in the book. The examples have come in useful for me for basic systems administration in my Windows Server 2003 network with Active Directory. The author breaks down the example codes line by line and explains what is going on, which I found to be very helpful.

one thing I did not like was that some times the author purposely put mistakes in the code without initially telling you. Then towards the end of the section, he will ask you why the code did not work and will tell you what went wrong and why. He doesn't do this all the time, but a few times. It made me second guess myself and thought that the publisher had bad typos in the code, something familiarly seen in a lot of programming books. Good learning experience, I suppose.

Even if you are a beginner programmer wanting to learn VBscripting, I think you would be able to get the gist of VBscript by copying the examples in the book and tweaking them for your needs. This is my first VBscript book and it's definitely a keeper for me. Highly recommended!

I hesitated to buy this book after reading other people's reviews, but I finally got it and thought it was quite impressive. The newest version covers up to J2EE 1.4. There is a simple code example for each pattern that clarifies the meaning. There is an excellent chapter dedicated to Java Connector Architecture 1.5. I've been reading this book at work as I wait for my slow computer to deploy applications to WebSphere, and it seems highly relevant. You should definitely read other books to become an architect, as I have done. I've basically read the other top-selling architecture books before this one. You should also read specific books on security and internationalization. I didn't see many bugs other than a few misworded practice questions. It's definitely worth the time and money.

i am just in the middle way of reading this book, but what i have got till now is great. I have 8 years career with software development specially in java, i reached to a point am doing system architecture most of the time, but i can say i was doing it from the point of view of "House Architect", now i can see things from Tower Building Architect, or City Architect in the extreme.
I did not pass the certificate yet so i dont know how much it is useful on this matter.

I'm not sure what the people were thinking who put this book together. There's lots of information thrown in her, but much that isn't applicable to either being an architect, or to passing the exam.

This is not a good book, and it will not help you pass the SCEA exam.

This book is amazing, and cover not only everything necessary for the SCEA, but more. Most of this "more" stuff, will not be usefull directly in your test but will help you very much understanding the necessary concepts.

Again, the book is very good, but since it has so much information, it's easy to loose yourself among this sea of words and stories.

I recommend go for other SCEA recommended books like the GoF Design Patterns, Sun Press By Mark Cade, Core J2EE patterns second edition before this one. Once you have a good knowledge to make the test, wrap it all up with this book. It will give you a perfect review of everything and call your attention about small things that no other literature will give to you.

It is a good book which describes the topics covered by the new SCEA beta certification exam. I did the beta certification exam and I can say most of the questions can be answered just reading carefully the book, specially the chapters which covers Security, JMS, JPA, JCA and EJB 3.0.

Being a great collection of masterly written articles, this book constitutes a deep introduction to a diversity of hot tech-topics. Surely, it will serve you well as a valuable skills thermometer in your professional growth planning.

Though, a couple of chapters awoke my interest and became the start point of further readings; I don't picture this book having a place in my "always at hand" book collection. I think this book, like those magazine subscriptions piling up in my garage, is a once in a lifetime reading.

Rather than having this professional guide to mainstream technological thinking dusting on my bookshelf; I would like to see it being passed around at the coffee table, inspiring, and guiding colleagues and friends. Definitely, this is not a book to own, but a book to share.

Articles by many notables - Scott Davis, Neal Ford, and more - pack an anthology covering all kinds of topics, from real-world web issues and applications to project testing, total object makeovers, and more, computer pros will find topics detailed, in depth and specialized to the computer geek world - and packed with logic and detail.

Diane C. Donovan
California Bookwatch

This is certainly an eclectic mix of a book. Topics from 15 authors covering subjects such as language-oriented programming, through agile methodology and CSS.

Written by leaders in their fields, this book doesn't aim to be definitive, but consists of essays by those people about the stuff which interests them. I didn't follow all of the subjects covered, and I think that you would be hard-pressed to. All were well written and would appeal to followers of that particular facet of information technology.

One particular thing I liked about this was the appendix covering each author's favourite reads and tools, plus a comprehensive bibliography.

I'm sure you'll find, as I did, half a dozen topics of interest, with several others opening up previously unknown fields of study. I'm looking forward to the next edition.

I attended a NFJS conference last year and was very impressed by the quality of the speakers and content. So, when I had the chance to read the No Fluff, Just Stuff 2006 Anthology I jumped on it.

The book is a collection of 15 technical papers from NFJS speakers that will just make you flat smarter. I found each paper to be informative, well written, and enjoyable. For example, the first paper is "Real World Web Services" by Scott Davis. In it, he provides a broad overview of the various acronyms that make up Web Services. While I was already pretty familiar with WS, this paper filled a few gaps in my knowledge of the subject. In other sections of the book there are deep discussions on testing, continuous integration, methodologies, and more.

The NFJS 2006 Anthology cuts a wide swath across the topic of software development. And yet, each section manages to go quite deep into the subject. I found a nice balance of variety and detail. Some of the papers were on topics I wouldn't necessarily seek out but I appreciated the opportunity to widen my horizons a bit.

Check out the TOC and sample chapters on the Pragmatic Programmer site.

Think of it as a technical conference to go. Highly recommended.

There is not a single good reason known to me not to read the second No Fluff Just Stuff Anthology. Most engineers I know spend far more time coding than catching up on the latest tricks and trends in the engineering world. To those engineers, present company included, an anthology like this is invaluable. However, NFJS Anthology Vol. 2 is also grievously unbalanced.

Much material in this volume is written by agitators of the "new age" software movement, for lack of a better word. They gravitate towards weaker contracts (i.e. REST over WS-*), loose typing (i.e. Ruby over Java), relaxed processes (i.e. Agile over anything else), and so forth... While all authors are entitled to their opinions, I find it unsettling that the "new age" dogma dominates much of the publication. Brian Sletten assaults WS-* in his essay "Give it a Rest", but where is the counterargument? The three paragraphs Sletten himself offers? Or does the editor wish to suggest, quite falsely if so, that there really is no business case to explain why top enterprises leverage WS-* based solutions in spite of their cost?

How about Jared Richardson's article on JRuby titled "Integrating Ruby with legacy code"? Since when is Java considered legacy code? Since when has the free world stopped developing solutions in Java except when under the whip of mighty yet incompetent management? And once again, where is the refutation? Where is the essay on the dangers of mixing and matching languages and platforms? The weaknesses of purely-dynamic languages? Certainly not in this NFJS anthology (sorry, Jared, two brush-off bullet points don't count). And what of a counterargument to Venkat Sabramaniam's essay on Agile Methodologies? While deeply insightful into agile techniques, it also seems to offer Agile as a panacea of sorts, omitting any discussion of when an agile process may be unfitting or even crippling. Once again, shop somewhere else for the complete story.
Ultimately, the single greatest failure of this compilation can be attributed to Neal Ford's role as its editor. A quick glance at his blog allows one to glean Ford's biases with a naked eye. While the strength of Ford's dispositions does not detract from his status or credibility as a great speaker and author, it renders him unfit to edit such a compilation as this anthology. Ford goes so far as to violate a key principle of the NFJS series by propagandizing a $500 IDE (Chapter 10), while devoting less than half that real estate to Eclipse techniques (Chapter 11), despite the latter's prevalence in availability and market share. In short, Ford allows what would otherwise be an invaluable educational resource to become a hideous concoction of information and propaganda.

Fortunately, Ford's negligence toward balance was slightly tempered by the diversity and insight of several of the authors. Howard Lewis Ship's essay on testing tools and techniques (Chapter 7), David Geary's introduction to the Google Web Toolkit (Chapter 8), and Scott Leberknight's "Data Access using Spring, Hibernate, and JDBC" (Chapter 19). These chapters stand out due to both their relevance and their instructional approach. These essays teach, rather than preach, and set a wonderful example of what the rest of this volume should have looked like. While I look forward to attending this year's No Fluff Just Stuff conference in Boston and even hearing some of the people whose work I criticized in the preceding paragraphs, I hope the 2008 NFJS anthology will offer less demagoguery and more substance, less fluff and more stuff.

This book is mainly translated into English from German; therefore, the explanation isn't very clear. You spend much time to get the understanding of a subject. It isn't very much related with numerical analysis, instead modelling. Don't expect to find problems about using Numerical Formulas... Another disadvantage of this book is that it is divided into two parts, so, you must spend too much money to get the full content from two parts.

This book gives an excellent overview of numerical analysis from both the theoretical and practical points of view. The in-depth discussion given by the author makes this book a welcome addition to the literature on numerical analysis and scientific computation. Fortran 90 is the language of choice for the author in discussing programming implementations of the examples and concepts. There are no exercises in the book, so it would be difficult to use as a textbook or a course in numerical analysis, but it does serve as a useful reference and supplement to such a course.

In chapter 1, the author briefly overviews the strategies and techniques behind scientific modeling and gives many historical examples. A rather short discussion however is given on the testing and validation of models. More should have been said here about this very important phase of the modeling process.

The author introduces the principles behind numerical analysis in chapter 2. He uses the problem of the plane pendulum from elementary physics to motivate the issues involved, such as the accuracy of the mathematical model. The author then classifies numerical problems into four categories, and gives a rigorous discussion of the accuracy of numerical results. This is followed by a discussion of the types of error one would encounter when doing numerics, these being model errors, data errors, algorithm errors, and rounding errors. Data error analysis, which studies the impact on the solution by altering the data on which it is based, is given a fine treatment by the author in terms of functional analysis. He defines the important concepts of absolute and relative condition numbers, and then discusses ill-conditioned problems. The author emphasizes that characterizing a problem as being ill-conditioned depends on the desired level of accuracy. He then gives a fairly complete overview of the validation of numerical computations and numerical software. The author emphasizes the extreme difficulties involved in the accessing of software quality statistically.

Chapter 3 gives an overview of computer hardware and architecture used to perform numerical computations. The author discusses the use of parallelization, pipelining, vector processors, memory hierarchies, caching (the discussion of this is excellent), virtual memory, and interleaving. He also gives a useful discussion of how to quantify numerical software performance, and how to perform an analytical and empirical assessment of hardware performance.

The actual implementation of numerical algorithms is discussed in the next chapter, wherein the author discusses just how numerical data is represented in digital circuits, and how such data is operated on arithmetically. The implementation of floating-point arithmetic, via the IEC/IEEE floating-point standard is discussed. The author addresses well the accuracy issues that arise for problems (such as partial differential equations for example), involving an extremely large number of floating-point operations. In addition, he discusses the use and implementation of multiple-precision arithmetic, with examples given of the ISML, MP, FM, and MPFUN packages for doing this. I have found though that, in addition to some of these packages, high-level symbolic programming languages, such as Mathematica, can be very suitable for heavy-duty number crunching. The discussion of number systems and rounding in this chapter is excellent and well suited for the beginning student in numerical analysis.

Chapter 5 gives begins a discussion of numerical algorithms, and the author discusses the basic notions of algorithms and their complexity characterization via the O-notation. Case studies in matrix multiplication and summation are given to illustrate the contributions of rounding errors and error propagation. This is followed in chapter 6 by a discussion of numerical programs, wherein the author discusses the quality, efficiency, and computational overhead of programs. Performance optimization, via such techniques as loop optimization and blocked memory access, is given a fairly thorough treatment. Again, matrix multiplication is given as a case study for the concepts and techniques discussed by the author.

The software currently available for numerical algorithms is discussed in chapter 7. The IMSL and NAG packages are emphasized, but the author gives a very long list of the packages that are available, both commercially and as freeware.

In chapter 8, the author returns to a discussion of mathematical modeling, wherein approximation techniques are emphasized. After a brief discussion of analytic models, the author moves right into the techniques used to approximate these models, such as discrete and function approximation. More functional analytic techniques are brought in to discuss how to quantify the distance from a model function to the function actually being modeled.

The important technique of interpolation is discussed in chapter 9, and very thoroughly. Polynomial interpolation via Bernstein and Chebyshev polynomials is included, as well as the Horner, Clenshaw, Casteljau algorithms for finding the values of polynomials. Piecewise polynomial interpolation is also treated, as well as spline functions, the latter of which in particular is given a thorough treatment. Multivariate interpolation, along with tensor product interpolation is also discussed at the end of the chapter.