3 comments about CWNA Certified Wireless Network Administrator Official Study Guide (Exam PW0-100), Fourth Edition (Certification Press).

1. The book was delivered iin good condition and an excellent book covering all the required topics on wireless



2. This book was a great tool for helping me pass the CWNA! Tom has covered the material in enough detail that it gives you a foundation of wireless knowledge to build on to pass the CWNA test. As Tom states in the book, you need to use other reference material, in addition to this book, to prepare for the test.
   
   thanks Tom!
   
   Bruce



3. I'm not sure if I should be angry with, or feel sorry for the editor. Never has an author's writing style enraged me so. In other words, I will expound upon why this book should never have been published, let alone copied into a fourth edition.
   
   In the last paragraph I said the author's writing style enraged me so. That is to say, you have read that the way the author tries to explain difficult technical concepts to an audience that is trying to learn these difficult technical concepts could actually cause hypertension. In other words, this book is unreadable. I will talk more about that and hypertension in later paragraphs.
   
   Hypertension, according to certain definitions is considered to be the condition such that a person's systolic blood pressure is consistently 140 mmHg or greater than 140mmHg, and/or their diastolic blood pressure is consistently 90 mmHg or greater than 90mmHg. In other words, I would rather rub ground glass in my eyes, than have to continue reading on. Although this material is not on the test, it is nice to know. That is to say, it's like having all your eggs in one basket---but there is no basket. Further, because eggs are considered to cause your systolic blood pressure to rise above 140 mmHg, there are no eggs. But you won't be tested on any of this.
   
   Note: A note should only be a quick statement of note and not a half of a page that includes phrases such as, "In other words", "Though you will not be tested to this level of depth..." or "For example", nor should it include a metaphor that breaks down with an explanation as to why the metaphor breaks down. In other words, violations of the fundamental precepts of technical writing can be infuriating. That is to say, with each paragraph, the list of things that are wrong with this book grows exponentially. If you're still breathing, in a later chapter, I will explain what exponentially means.
   
   When I explain what the word exponentially means you may involuntarily tear the flesh from your face. In other words, you won't actually understand what the word exponentially means, but I'm covered because I told you that you would need other material to pass the test. That is to say, there is technical material to be read that may not contain the pronouns "I" or "you".
   
   If an author has the character string, "In other words, " on a macro key and uses that phrase and similar ones with great proliferation, then the editor should tell the author to save a few trees, a year or two of his audiences' lifespan, and a whole mess of redundant and convoluted statements by using those other words in the first place. How many times, I wonder, and I wonder why I wonder, is that phrase used in the first three chapters? I also wonder why Part II is not Part I. That is to say, the author's impartation of his obviously expert knowledge is skewered by the organization of the material.
   
   So, I'll be using the table of contents and headers as a guide to what to study for the PWO-100 because reading the IEEE 802.11 standard itself is easier on the comprehension, the hypertension, and it was written without the help of Jesus.

5 comments about Emergent Design: The Evolutionary Nature of Professional Software Development (Net Objectives Product Development Series).

1. Bain's book is a graceful read. At least compared to some texts on "heavy" methodologies like CMMI. He addresses the professional programmer. At some level, there is an introspective feel to parts of it. Can the profession be more professional, in reducing bugs and bad coding practices? More pertinently, can you do this? In expanding on the possible answers, he takes us on a recap of decades of progress in programming.
   
   One big innovation was the rise of object oriented programming, compared to earlier procedural efforts. Hence C++, Java and other OO languages. Another key idea to remember is that of patterns. Even if you can't remember all the patterns he discusses, at least being aware that such exist is a good step forward in your abilities.
   
   There is also lots of advice about littler details. Like having names for classes, methods and variables that are as descriptive as possible. Doesn't matter what language you're using. You should always strive here, so that the code is as self documenting as possible. Though Bain is careful not to go to the extreme of suggesting that no comments are possible. Another key note is that automated unit testing is a great thing. Sure, it takes time to run the unit tests. The payoff in code maintenance makes it all worthwhile.
   
   Much, if not all of what is written has appeared in other texts. But Bain provides an easy to read and unified treatment. Well suited for a junior programmer.



2. This book is a gold mine of wisdom.
   
   This book contains a ton of wisdom that has come out of the software engineering field over the years. It brings together a lot of software development best practices that can be found in other resources and puts them together under the umbrella of Emergent Design.
   
   He covers patterns, principles, processes, and practices by presenting the best of each that has been proven to work again and again. The common sense communicated out of this book is priceless.
   
   The author has a presentation that touches on a lot of the content found in the book. It can be viewed by Googling for "EmergentDesign_12_11_2007".
   
   Forward thinking is something that I find lacking in a lot of the environments I am exposed too, especially development environments. This book nails how to do forward thinking when it comes to software design and development. You will end up making your solutions more valuable with each change, instead of degrading them with each change if you follow the advice in this book.
   
   If you do development, this is a must read. I would advise all team leads to get rid of anyone who has not read this book by the end of the year.



3. As the cover implies, this book is the basis of a revolution. It is a tour of everything required to become a professional software developer. I believe this book to be distinguished from other technical books in the way that great works of fiction are different from genre books. It defines a category rather than just being a part of one.
   
   It is a call to arms for all of us who consider ourselves professionals to band together into a true profession. Simultaneously, it is a tour of all those things that we as a proto-profession have identified as important and valuable. Practices, patterns, principles, disciplines, tools... Bain shows how all of these things work together. He goes one step further, though: he shows how they can coalesce into the basis for our occupation's transcendence into a profession.
   
   If you have not been introduced to these concepts - if you work in a heavily waterfall environment with brittle code and death-marches at the end of long release cycles - this book is your way out. Read it. The most you will have lost is the time it takes you to read a three hundred page book and you have everything to gain. Emergent Design will show you that there is a better way. A way to make software that gets easier to maintain over time, not the other way around.
   
   If you are familiar with these concepts, as I believed myself to be, then you will enjoy seeing everything come together in one book. You will probably gain some valuable insights along the way. I certainly did. You will also find that it is powerful recommended reading for those around you. Scott Bain's writing is clear, concise, friendly, funny... oh yeah: and very persuasive. Having read this book will give you and those whom you coach, teach, or work-with a common frame of reference; even more-so than Design Patterns.
   
   I truly believe that this book is going to be at the center of a series of discussions, debates, and decisions which will ultimately lead to the formalization of software development as a real profession. It would be easy to characterize your choice as "buy it or don't buy it" but that would not be accurate. The real choice before you is this one:
   
   You can either be an informed participant in the formation of our profession or you can just be governed by it.
   
   I trust you to do the math from there.



4. EMERGENT DESIGN: THE EVOLUTIONARY NATURE OF PROFESSIONAL SOFTWARE DEVELOPMENT is for college-level libraries strong in software engineering, and discusses the foundations of systems development, helping developers work with the flow of ideas inherent in emergent design principles. From tips on how to produce more professional software designs to testing designs throughout the process and learning when to stop, EMERGENT DESIGN is a fine choice for software engineers who would streamline their efforts to produce quality designs early in the process.
   
   Diane C. Donovan
   California Bookwatch



5. 
   Emergent Design by Scott Bain is a interesting book. The title is very promising, when I first heard about it, I got very excited! Finally a book about how designs emerge, how designs emerge from multiple people and how designs evolve over time compared to specifying. After reading the book, I felt the book was good, but disappointing. It did not cover the topics I would like to have seen.
   
   The general idea of the book is that software should grow better over time instead of decay over time and that the optimal design will emerge. An idea I strongly agree with. The author links this to software development needing to change to become a profession. If SW development is a profession, then people will use proper practices and design will emerge. The practices (in a broad sense) are principles of design, patterns and disciplines. After the first couple of chapters the book was having a good start, though I started wondering if the author didn't bite of more than he could chew. Those are huge topics by themselves!
   
   From chapter 7 to chapter 14 the author just describes good practices. He starts with qualities of code and qualities of designs. He moves to unit-testing, refactoring and then Test-Driven-Development. He ends with the pattern chapter. The last chapter puts all things together in a case study. Scott does a reasonable job in describing all practices. There are a couple of weird things, like the recommendation that every class has exactly one test class. The TDD chapter also seems to have very little TDD in it :)
   
   As a catalog of best practices, this book perhaps does the best of all the current agile related books. Great job by the author.
   
   However, there are some things that personally bothered me. The book seems to be very pattern focused. Scott seems to be of the opinion that patterns is what hold everything together (probably everything in the world). Though, I agree that patterns are an important concept in modern software development, I wouldn't put so much pattern focus in e.g. a chapter on test-driven development. Maybe the title of the book would better be "Scott on SW design and patterns".
   
   That brings me to another issue with the book, the title. Emergent design is an immensely important topic. How does a design start with the first requirement. How does it evolve. How do multiple people work with the design. How can the overall architecture evolve. What about items that evolve difficult, like different programming language usage etc. So much to talk about and the book doesn't do this. It misses a huge opportunity to talk about emergent design & architecture and instead (although important) decides to talk about design principles, patterns and practices. (in that sense, the book is similar to Bob Martin's "Agile Software Development: Principles, Patterns and Practices", which I would recommend over this book).
   
   But again, the content of the book is good and useful and normally I would go for a 4 star rating, but I decided to go for 3 stars. This is because the book IMHO contains things that really turned me off.
   One of the examples is the talk about professionalism. Don't get me wrong, I do agree with the author on this subject. The point is, we are not alone. In fact, IEEE has been working on certification for many years. In 1999, Steven McConnell wrote a book called "After the Gold Rush" with the subtitle "Creating a True Profession of Software Engineering". Scott talks about finally making a profession out of SW development, but he seems to have not done any research on this topic and seems to not be involved in other attempts to make it a profession. It would have increased his credibility a lot if he would have said "the earlier attempts are different because ..." or something similar.
   
   Another item that was a huge turn-off was the constant promotion of Net Objectives. The book, at times, almost felt like a commercial. Personally, I didn't need to know about what courses Net Objectives teaches, I want to know about Emergent Design!
   
   Anyhow, all these negative points aside, Emergent Design is a good introduction to modern agile development practices. Especially if you are not yet familiar with topics like Refactoring, TDD and patterns, this book is certainly worth reading. Next to that, Scott's writing style is funny and easy to read. So, if you belong to that group of people, recommended! Otherwise, skip it.

4 comments about Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition.

1. This book is the much needed update to the book on embedded systems also published by O'Reilly. This book assumes that the reader already has some programming experience and is at least familiar with the syntax of the C language. It also helps if you have some familiarity with basic data structures, such as linked lists. The book does not assume that you have a great deal of knowledge about computer hardware, but it does expect that you are willing to learn a little bit about hardware along the way. This is, after all, a part of the job of an embedded programmer.
   
   The book contains 14 chapters and 5 appendixes. The chapters can be divided into two parts. The first part consists of Chapters 1 through 5 and is intended mainly for newcomers to embedded systems. These chapters should be read in their entirety and in the order that they appear. This will bring you up to speed quickly and introduce you to the basics of embedded software development. After completing Chapter 5, you will be ready to develop small pieces of embedded software on your own.
   
   The second part of the book consists of Chapters 6 through 14 and discusses advanced topics that are of interest to inexperienced and experienced embedded programmers alike. These chapters are mostly self-contained and can be read in any order. In addition, Chapters 6 through 12 contain example programs that might be useful to you on a future embedded software project.
   
   Throughout the book, the authors strike a balance between specific examples and general information. Minor details have been eliminated making the book more readable, at least in my opinion. You will gain the most from the book if you view the examples primarily as tools for understanding important concepts. Try not to get bogged down in the details of any one circuit board or chip. If you understand the general C programming concepts, you should be able to apply them to any embedded system you encounter. To focus the book's example code on specific concepts, these examples have been left intentionally incomplete. For example, certain include files and redundant variable declarations are omitted. For complete details about the code, you can refer to the full example source code on the book's web site. I discuss this book further in the context of its table of contents:
   
   Chapter 1, Introduction - Explains the field of embedded programming and lays out the parameters of the book, including the reference hardware used for examples.
   
   Chapter 2, Getting to Know the Hardware - Shows how to explore the documentation for your hardware and represent the components you need to interact with in C.
   
   Chapter 3, Your First Embedded Program - Creates a simple blinking light application that illustrates basic principles of embedded programming.
   
   Chapter 4, Compiling, Linking, and Locating - Goes over the ways that embedded systems differ from conventional computer systems during program building steps, covering such issues as cross-compilers.
   
   Chapter 5, Downloading and Debugging - Introduces the tools you'll need in order to iron out problems in both hardware and software.
   
   Chapter 6, Memory - Describes the different types of memory that developers choose for embedded systems and the issues involved in using each type.
   
   Chapter 7, Peripherals - Introduces the notion of a device driver, along with other coding techniques for working with devices.
   
   Chapter 8, Interrupts - Covers this central area of working with peripherals.
   
   Chapter 9, Putting It All Together - Combines the concepts and code from the previous chapter with convenience functions and a main program, to create a loadable, testable application.
   
   Chapter 10, Operating Systems - Introduces common operating system concepts, including tasks and synchronization mechanisms, along with the reasons for adding a real-time operating system.
   
   Chapter 11, eCos Examples - Shows how to use some features of the eCos real-time operating system.
   
   Chapter 12, Embedded Linux Examples - Accomplishes the same task as the previous chapter, but for the embedded Linux operating system.
   
   Chapter 13, Extending Functionality - Describes options for adding buses, networking, and other communication features to a system.
   
   Chapter 14, Optimization Techniques - Describes ways to decrease code size, reduce memory use, and conserve power.
   
   Appendix A, The Arcom VIPER-Lite Development Kit - Describes the board used for the examples in this book and how to order one for yourself.
   
   Appendix B, Setting Up Your Software Development Environment - Gives instructions for loading the software described in this book on your host Windows or Linux computer.
   
   Appendix C, Building the GNU Software Tools - Shows you how to compile the GNU development tools
   
   Appendix D, Setting Up the eCos Development Environment - Shows you how to build an eCos library appropriate for your embedded system so you can compile programs to run on your system.
   
   Appendix E, Setting Up the Embedded Linux Development Environment - Describes how to install the embedded Linux tools for your Arcom system and build and run a program on it.



2. Programming Embedded Systems with C and GNU Development Tools appears in its second updated edition to include even more real-world and Linux examples, and is a recommended pick for programmers with a familiarity with C. It's been used as a college textbook and covers everything from basic debugging skills to determining the applications and needs of real-time projects. In updating details and clarifying routines, the 2nd edition of Programming Embedded Systems should be considered both a classroom and lending collection standard.
   
   Diane C. Donovan
   California Bookwatch



3. This book gives an excellent overview of programming embedded systems. It provides numerous examples of real-world hands-on embedded programming. I'd recommend that you have experience in C. Experience with operating systems concepts (such as interrupt service routines) would also be helpful.
   
   Unlike usual programming books, you won't be able to pick up the book, download something, and start working. You'll need to have an embedded system that you can use. The authors use a system from Arcom that will run you about $300. I've not used it and was very wary about it when I first started reading, but as I read through the various examples I gained a great appreciation for the system. It looks like a great way to gain hands-on experience with embedded programming.
   
   Before getting this book I read through the Lego Mindstorm NXT documentation and felt very lost. I didn't understand the symbols on the schematics and they used strange acronyms (like I2C and PWM). I also have an Iguanaworks USB infrared transceiver. I bought it to use in a MythTV system I am building. This book has enabled me to understand the schematics of both the Mindstorm and the transceiver as well as the documentation of both systems. I now feel ready to do my own embedded systems programming.
   
   That said, I did not like everything in this book. They gloss over areas that I felt would have helped me (such as how to use a JTAG adapter and how to create an interrupt service routine under Linux). There are areas where the writing does not flow well and is redundant. The book switched from using an embedded x86 processor in the first edition to using an ARM processor in the second and there are still references to the old processor.
   
   Even with its faults I am glad I got this book. It filled in many of the gaps that I have as a software engineer who is wanting to learn about embedded systems programming. I feel a whole new world has just been opened up to me and I can't wait to jump in.



4. If you are just getting into embedded systems and you want to understand the myriad of interacting concepts, this book is a good start. You will get a solid overview of the basic elements, such as hardware, software tools and techniques, memory and peripherals, processing controls and design strategies.
   
   As with any embedded systems book, there has to be some alignment with specific hardware and application examples. The author uses these examples to tie together embedded elements, but the integration is a bit choppy.
   
   The book is organized as a general introduction to embedded systems. About half the book describes the system elements and about half provides full system examples. A single book cannot cover all topologies and development platforms, so I wouldn't recommend it for someone who is trying to solve a specific problem on his/her embedded application. For cases like that, your vendors and FAEs are probably your best bet.
   
   So if you are trying to learn embedded systems development, this is a great resource. If you intend to use it to guide a current project or debug an embedded problem, it may become more of a distraction.

3 comments about Foundations of SQL Server 2005 Business Intelligence.

1. This book is indispensable. It will help expand my limited knowledge in the business intelligence space from FICO scoring and SAS programs to a wider universe.



2. I am new to BI. I needed a book to explain BI and the toolset in the SQL Server 2005. As I have been developing applciations for the last 8 years using Microsoft only technologies therefore I wanted to use SQL Server 2005 for BI path. I found this book very valuable for a new commer to BI like me.
   
   I have gone through only some of the chapters but it has started to make sense. The explanation is very clear and it shows that the writer knows the subject very well. Good arrangement of chapters. Not a boring book. I think after reading this book and going through all the excercises one would have a very good understanding of the subject and how to use to SQL server 2005 BI toolset.
   
   I would say this book puts you above the intermediate level from where you can understand the more complex books. Essential for someone wanting to choose BI as career path. Top work Lynn.



3. Lynn definitely knows the material. I have had the occasion to sit in on a couple of live presentations from her on this subject and she truly knows the topic from a real-world perspective. Although BI is a deep and complex subject, Lynn gets right to business to help you start building your reports and dataviews in a practical and productive manner.
   
   This is a great starting point for people wishing to get up to speed on BI using the Microsoft tools as well as a good review for those already comfortable in these waters.

5 comments about ARM System Developer's Guide: Designing and Optimizing System Software (The Morgan Kaufmann Series in Computer Architecture and Design).

1. In the ARM tradition of charging for everything, the firmware guide by Sloss is easy to read, and comprehensive up to ARM10/StrongARM XScale/926/940. That said, the book looks like the notes from a firmware lecture delivered by an Arm Apps engineer. The book is strongest in coverage of MMU and cache, but weak on ARM11 (1136 only and as a final chapter) and essentially non-existent in Jazelle coverage. Nice features are the toy RTOS which appears early at reappears with more features (memory protection, and MMU, for example). That this book is so quickly out of date brings the point that MDR bulleted last year, that the ARM family needs birth control but that is a topic for another discussion. Sloss' book has 'non-commercial license' for all the sourcecode. huh? Regarding this book, Freescale for example publishes equivalent information (old ESS manuals) in the 860/8260 training manuals for free, on their website. If your company pays for your books, by all means have them get the sloss book for you it makes a great read on the john, but if you are a student or independent developer, you would be as well served by studying the ARM ARM and applicable ARM source code for U-Boot, Redboot and the L4 microkernel, or even Ed Sutter's book, with the added benefit that you would have a license to use the code in your project.



2. This book covers many aspects of programming the ARM familiy, including a surprisingly thorough discussion on fixed-point DSP computation.
   
   Having come from another architecture, this book really got me going on ARM. It complements the documentation manufacturers usually provide for their ARM chips in that it covers the ARM core much more in-depth.
   
   The book discusses everything from register usage to memory management units. If you want to become an expert programmer in C/Assembly on ARM systems, you must buy this book.
   
   Also included is a nice comparison of the ARM and Gnu assembler directives, which came in handy when I converted an ARM assembly file to the Gnu syntax.



3. Product came in faster than expected and it was in new, excellent condition.



4. You know C, you know pointers, you know how to program. But what you need is something to teach you more about creating firmware applications. How to actually make something work! What actually goes on inside this black-box that we call the ARM core? How do you make it do some simple DSP?
   
   There should be a course in every college that basically teaches the information contained in this book!



5. This is the best book I've seen for the ARM series of processors. I have developed with many processors, on and off the Job and am now planning to develop for the ARM7 and ARM9 processors; particularly the AT91 and the AT91SAM7 series of processors by ATMEL. Base on the processors' hardware specs they are perfect for the small time developer. But, when looking the ARM's instruction set, it appears that programming them requires a steep learning curve.
   
   This book will easily reduce my learning curve, at the very least, by more than half. It is clear, comprehensive, and to the point.
   
   In a world that has strict requiresments on performance, power, as well as development time, a developer has to ARM himself. This book will show you how to do just that.

5 comments about Pro C# with .NET 3.0, Special Edition (Pro).

1. Many of us IT professionals by these thick books for use as reference, without intending to work our way from cover to cover. As I read this book, it became clear I needed to read the entire volume. It is well-written, and stays on track and focused. I have learned many useful things that I will be able to use in my daily tasks.



2. I have 4 books about .Net framework 2.0 and I even have a book about Windows Workflow Foundation, so I bought this book "judged by the cover" and title "Pro C# with .NET 3.0"
   The truth is that only 17 percent of the book (194 pages of 1151) is concerning 3.0.
   That's not good enough.
   The reason for the 3 stars, is that the book is a very well written 2.0 book, but buy it only for that, and wait for the framework 3.5 books, with an greater insight the new technologies, to come.



3. Clear and well presented book. Easy to read and seemingly covers most aspects. Experienced programmer but starting first C#.NET project and certainly best book I have purchased on this subject



4. Andrew Troelsen is an excellent author and knows how to explain things. The book covers in a detailed way the phylosophy of .net and the C# programming language. This is it's strength.
   On the other hand, I do think that the later chapters are misguided. We have a chapter about .net remoting, another one on Windows forms, and then a short introduction to the .NET 3.0 stuff like WPF, WF and WCF. Well, I bought the book for the 3.0 material. Why didn't they call the book:
   
   "Pro C# 3.0 with short intro to .NET 3.0"?
   
   Best regards,



5. This book allowed to literally give away 3 rows of programming books. Apress always does a good job on their publications. This book is really all an experienced C# programmer needs in his library (aside from a good ASP.net) book for web design techniques

5 comments about Computer Graphics: Principles and Practice in C (2nd Edition) (Systems Programming Series).

1. It's an all-time classic in computer graphics world. I bought this in 1997 and i could learn a lot from it. Though it hasn't been updated, one can gain all the fundamentals about CG.



2. This book is a great book for general knowledge but all of the chapters that deal with talking about hardware is badly outdated. I got this book mostly for algorithms. I got much more then what I expected but most of everything I needed was there. Its a very good book for learning about line drawing, and polygon rasteration algorithms. Don't expect anything up to date like shaders though.



3. Except for the chapters on raster algorithms, this book is just an extended bibliography. It has no material on texturing, for example, just a reference to the original paper on it. The math isn't that mature either, and the chapter on Perspective Projections is a pedagogical atrocity. Instead of buying this book, just go to your local univ. library and xerox the bibliography; then, lookup the articles on topics you're interested in.



4. If you're a beginner looking for a book which has example code you can test out and try, either forget it or be prepared for some headache.
   
   I can speak on my experience, I have a GNU/Linux system, the SRGP library which is used by this book only supports a display depth of 8bpp, which means you'll most likely need to reconfigure your X server to some extent - the examples/library will crash at higher display depths.
   
   But there is no doubt that the techniques and principles explained throughout can be applied using other toolkits, as the book explicitly says that the facilities contained in the example libraries are common to many other graphics libraries.
   
   A quick note on the quality of the library code, it appears to be pre-ANSI C and contains a few modern no-nos, which can lead to crashes.
   
   If you're looking for a book to merely use as a reference or for theory then this is what this book is, and as one other reviewer said, you could probably just borrow a copy of the book and xerox the bibliography to refer to the papers it sources information from.



5. This is a bible for computer graphics. I recommend this book to anyone who wants to learn computer graphics knowledge base.

5 comments about Essential SNMP, Second Edition.

1. I hadn't seen a new book on SNMP come out in some time, and the older ones I had read were so abstract and unhelpful that I was reluctant to try another one. This book, though not perfect, is much better than the older books I have looked at on the subject. For one thing, it just didn't dive into the subject with a bunch of confusing graphs and object trees assuming I already knew the big picture.
   
   Chapter one is just a general introduction to SNMP and network management. Chapter 2 goes into details on both SNMPv1 and SNMPv2. It talks about how SNMP sends and receives information, how to read MIB files, and about SNMP communities. It looks in detail at three MIB's - MIB-II, Host Resources, and RMON. MIB-II is a very important management group because every device that supports SNMP must also support MIB-II, thus objects from MIB-II are used in examples through the whole book. Chapter 3 introduces SNMPv3, which addresses the security problems present in v1 and v2.
   
   Next the book introduces the idea of a network management architecture. It stresses that you need a plan that helps you use Network Management Stations (NMS's) effectively in order to effectively manage your network. This section includes how to properly choose your hardware and what questions you need to ask yourself. Next the book discusses actually installing and running your software. Specifically HP's OpenView Network Node Manager and Castle Rock's SNMPc Enterprise Edition are discussed. Included are detailed instructions along with screenshots of the application. Next there are instructions on how to configure SNMP agents. You are walked through some standard configuration parameters plus some advanced parameters that sometimes crop up. Once again there are plenty of screen shots to help you know you are on the right path.
   
   Now that you've been walked through the configuration of your system and the installation of software, the book shows you how to use the three basic SNMP operations of snmpget, snmpset, and snmpwalk. A group of Perl scripts are shown that set, get, and walk objects. Next HP OpenView and Net-SNMP are used to perform the same operations from the command line. A third alternative is demonstrated that uses OpenView's graphical MIB Browser. Next is a discussion of how to set up SNMP to poll your devices at certain intervals and to set thresholds that require action if crossed. Again Perl scripts enter the discussion for configuring this set-up. SNMPc and OpenView screen shots show you how to configure this using graphical interfaces, and what to expect. Next the book discusses traps, which are how an agent sends a monitoring station asynchronous notification about certain key conditions that may require action. The book demonstrates how to handle traps using OpenView and Perl scripts. Next the book shows how to read, configure, and even define your own traps.
   
   The book now turns to the problem of agents that need to be extended in their abilities. The book discusses the answer to this problem - extensible SNMP agents - and three of them in particular - the OpenView, Net-SNMP, and SystemEdge agents. Next are some interesting scripts for automating common system administration tasks. Issues covered by these little scripts include determining who is logging into your machine, a port monitor, service monitoring, and switching port control, among others. There is then a discussion on MRTG (Multi Router Traffic Grapher), a trend analysis tool that generates image files and whose output is viewable from a web browser. Complete instructions on installing and using the tool are given. The next tool discussed is RRDtool, which in network management will most likely be used to store and process data collected via SNMP. However RRDtool can be used for many diverse purposes that have nothing to do with computer networks. The last chapter in the book is an odd one on using Java with SNMP. Specifically, the book presents the Java SNMP API known as SNMP4J. It doesn't really seem to add any functionality other than being an alternative for people who don't like to use Perl.
   
   I liked this book very much. It had many good examples and it answered all of the questions I had previously had on SNMP starting from the beginning with what is SNMP and what can it do for you? I would highly recommend it to any network administrator who is planning on workng with SNMP.



2. This book is good up till you get 1/4 of the way through it. The first quarter of the book is good and it goes over general SNMP stuff then history different versions etc. The last 3/4 of this book cover configuring proprietary monitoring systems like open view and solar winds.
   
   I dont care about open view.. or solar winds.. i wanted to learn about snmp... not some vendors software package. Im suprised that this got published with such a general title.. when really the book is an snmp intro, followed by how to setup a proprietary monitoring tool.



3. Most of the books in this series are very technical and go into serious details. This one reads like a compendium of owner's manuals. A really good book on SNMP is needed and this one is not it.



4. Essential SNMP didn't quite hit the nail for me.
   I needed introductory documentation on the design of MIB files and the implementation of agents, but this book provides more of a quick overview of the usage of SNMP from the perspective of a network manager.
   There are lots of basic examples on data collection, but researching on the internet helped me much more than this book. Especially the Net-SNMP website covers much of the internal workings of the SNMP protocol and the advanced usage of OIDs, like tables, octet string indexes and multiple indexes. But I still had to search and experiment a lot before finding the relevant information.



5. i knew nothing about the protocol. great resource in explaining from the ground up.

5 comments about Microsoft SharePoint: Building Office 2007 Solutions in C# 2005 (Expert's Voice in Sharepoint).

1. I was assigned on a project where I should be using MOSS 2007. I had not used MOSS before and I needed a book that will give me a jump start. This book does that. For a beginner it is a very good book. However the instance you need more detailed information this book is not that useful.



2. I remember when I was learning MTS I bought Scot's book, MTS Programming With Visual Basic, and was truly amazed at what an easy read it was on such a technical subject. The reason is very clear. Scot knows what he is wrting about not only from a technical perspective, but also from a business perspective. His insights are priceless.
   
   I thoroughly enjoyed his MOSS 2007 book and recommend it highly. Personally, I am very thankful that people like Scot take the time to write valuable books like this one. He makes up for other authors, who write huge books, that are painful to read and contribute nothing. One such author, and apparently his editors, does not even know that he is the "principal" not "principle" author of his book.



3. This is a very good book from C# developers point of view. It covers most of the features that you want to customize in SharePoint. I like the presentation of ideas first and then exercises. It gives you a starting point on how to do it and it's up to you to go to a more complex level but at least it already gives you an idea what to look for.
   I highly recommend it and it is easy to carry as it has only around 500 pages.
   After this I will read the SharePoint Administrators Companion book by Bill English from Mindsharp.



4. Wow! I like the way Scot Hillier wrote this book. For experienced .net developers new to sharepoint, this book must be on your book shelf.
   
   Scot Hillier walks you through fundamental aspects of Sharepoint, and shares his insightful thoughts along the path. At first, I do not understand why he solves problems using a variety of Microsoft technologies such as Visual Studio, InfoPath, Sharepoint Designer. To me, isn't that Visual Studio enough? Later, I realize that his way is the best since he picks the right tool for the right moment.
   
   However, I do not see an enterprise sample in his book. I do expect that. Second, web part security is a tough topic. I expect more explanation. In the exercise, a medium trust level is used. According to the context of that chapter, a minimal trust level should be used.



5. As the author states in the book, this is basically a written version of what he would say in a class. And as with 95% of the training classes out there, it isn't worth anything. He doesn't cover things to make you understand how SharePoint works. He does even write much about C# SharePoint development. Most of what he writes steps you through setting up SharePoint servers/services, and many of the steps don't work. This is the first SharePoint book I have purchased, and I am looking for one that is accurate and useful... ...again... ...still.

1 comments about Simple Architectures for Complex Enterprises (PRO-best Practices) (Best Practices (Microsoft)).

1. I have managed to talk to quite a few good software/enterprise architects over the years. When I do, the issues that we often talk about most are simplicity of design and how to manage complexity. In general, understanding that the management of complexity is the fundamental task of architecture is what defines a good architect. This book indicates that Roger really gets this issue. He also seems to get the business alignment issues that are sometimes lacking from architecture texts.
   
   From Roger's advice on partitioning a solution to his advice on implementing a system using an incremental approach everything here is sound and well articulated. This book is a short read but almost definitely worth your time if you are building anything in software from an enterprise down. Much of the principles he professes are the same principles that are important in regular software architecture. Components and object oriented design are merely methods of figuring out internal equivalence classes and appropriately partitioning solutions. Iterative development and some of the new agile principles are based on the same idea he advocates for the enterprise, incremental delivery.
   
   If for nothing else, this book is useful because Sessions is very successful in mathematically proving that many of his ideas should work. Most texts advocating incremental methodologies or problem decomposition can sound evangelical. This book does not.
   
   Overall, SIP sounds like it is a very good foundation for a company's enterprise architecture.
   
   That said, I am sure my advice would mean more if I did enterprise architecture. I hope that it is merely enough to say this.. I am in software development. I have helped provide or provided the technical architecure on quite a few projects. I feel that in general Roger has the core concerns nailed with his book.