Microsoft Silverlight Books

Required reading for serious .NET development

I read this book several years ago and have since returned to it every two years or so for a light re-read. I consider it a member of a very small group of elite .NET development books and often recommend it, along with "CLR via C#" and "C# in Depth", to young .NET developers looking to take the next step in their careers.

Jeremy Jarrell
06 October, 2009

A great conceptualcookbook reference for any intermediate .NET developer

I think of this book as a cookbook without the fat, or a concept book with some meat. The book discusses topics that are often glossed over in introductory books; exactly the types of things that a responsible .NET developer needs to understand to write efficient and stable .NET applications.

S. Wolfe
12 February, 2009

Can be considered a general, concise book on Software Programming...

Microsoft technology has generated some really good books on software programming over the years. This book is definitely one of them. The difference between this book and the others may lie in the fact that it is published by O'Reilly. This book is devoted to the latest Microsoft technology, but it is really a book that explains the basic principles behind all software programming.

You can read this book and substitute any other language, for example Java, to implement the principles elucidated. Of course, the set of software principles is much vaster than in this book, but there are not too many tomes that concisely and clearly explain the fundamental principles that have to show up in any software application.

And it also shows how elegant a job Microsoft has done with DotNet to implement these ubiquitous principles and make their usage incredibly easy. After the pain and torture of their earlier technology (eg. COM), this shines in contrast. Took me back to the joys of programming in plain old Basic and Visual Basic once upon a time. They must have done something right when the open-source advocates jump to implement their own version of DotNet.


Jake Gay
28 December, 2008

.Net on Steroids !

A Classic Book that begins it's journey, where all books end. The true difference between a casual programmer and a disciplined programmer is more prominent in his/her code when they start using advanced features of the framework. A true programmer knows his stuff in and out and knows how to leverage the features of the framework effectively in every line of code. And to get to that level of proficiency it takes reading and practicing the concepts on daily basis. And if at all, there is any book out there, that will help you, then it is this book. A definite YES. 5 Stars.

S. Devasundaram
25 April, 2008

One Of A Kind On .NET Components And C# Programming

Without any second thought I will place this book among the best books on the subject ever published. I hope everybody will agree that there are only a few books that worth reading from the beginning to the end without skipping a page. To me this is one of those rare books.
The author manages to reflect on broad architectural concepts and yet be extremely specific. He was able to present the most complicated aspects of component oriented programming and the C# language in a very simple, yet concise manner. Many complex issues that may turn off even experienced programmers are described in a way that not only are very well understood, but could easily be migrated into a working program. The author has found an absolutely perfect balance of presenting general architectural aspects of the subject he is discussing and real life implementation techniques.
I truly believe that anybody who is dealing with such aspects (to name but a few) as serialization, asynchronous invocation, multithreading, reflection, events, delegates, deterministic finalization, etc., MUST read this book.
By the way, this author has published another wonderful book on Windows Communication Foundation - "Programming WCF".


Armen Jamkotchian
27 February, 2008

Great, but....

This book is incredibilly well written and has a very comprehensive way of explaining the ways of Component oriented programing. Explains its differences betweent COP and OOP. You can easily understand what the author has in mind, BUT, I found one big flaw on this book. Not that this flaw will make the book less comprehensive, but it will make it less fun.
In all concepts it presents Examples, but not exercises. It explains the features and then give a short example to it. It doesn't stimulate the reader to actually build a code within a major context. You read, see the example and move on to the next topic. It is not fun to just stay around and read and read and read without actually working with the book. It is still a great book, but the approach to the reader could be better.

Fabio Santos Franco
24 August, 2007

Excellent book with an eye for Component Oriented Design

While going over component and control design, this book teaches the principles of the component-oriented design philosophy. The author doesn't pander and isn't overly verbose; getting to the point and explaining his meaning efficiently and succinctly. Definitely worth the read.

William Klar
16 August, 2007

Good for Newbies

Book goes through the entire process of building controls, nothing is untouched. It dwells however much too long on the 'standard' topics of installation, distribution, setting up etc and is rather lite on the the real stuff like building controls that look and feel like commercial controls. Would be a good book if it had 20% of the pages.

H. Alles
07 June, 2007

Excellent in what it covers

Pros:
Material that was covered was done an a very concise, clear and justfied manner. More so than just about any other computer book I have read. As others have mentioned, the explanation of the mechanics of remoting are excellent. The coverage on the other topics was incredibly informative as well its just that Remoting stands out since the topic is not covered as well elsewhere. Several helper/extension class examples are included which help to enforce good practices. I found the coding practices addendum to be a helpful summary of the topics discussed in the book.

Cons:
While remoting is discussed, it defers discussion of the EnterpriseServices namespace (object pooling, transactions, lifecycling, etc) to a previously published book. I find these features a necessary consideration in component design. Instead of feeling like I know everything about dot NET components, I now feel like I have to read another book. Having said that, WCF, at least at first glance, appears to be among other things a rework of ServicedComponents into an attribute driven dot NET framework and less reliant on COM+. I hope that is the case because JEE has already proven that inhertance based component mangagement such as ServiceComponent cramp system architectures. I also feel like the book does not adequately cover the use cases appropriate for designing a distributed application. It covers the mechanics/how fine but it doesn't address the when and where portion of distributed components.

Juval's latest book covers WCF and I am looking forward to reading it and hope it will address the areas I felt still needed to be addressed by this book.

Richard Collette
08 March, 2007

Interfaces Factoring

On page 73 of this book the author wrote:

" An in-depth discussion of how to decompose a system into components and how to discover interface methods and properties is beyond the scope of this book".

I would encourage the author to write a book that discusses specifically about interface factoring and to provide more examples on how components should be decomposed and organized in large scale applications.

Twain Mark
02 February, 2007

Best book on .NET ever readed.

Yes, I am always very demanding on programming books and this title taught me more of all the others.

I definitely suggest it.

Alberto Bencivenni
10 November, 2006

Simply Awesome

This is the my first review on Amazon. This book is so nicely written. The examples are short and precise. All the Advanced topics are covered in a great way. Highly recommend it to all developers who want to gain more expertise.

The book is good if you want to have a solid information about the .net Assemblies,Remoting, Async. Programming, Delegates. The best thing I like about this book is that every line has a lot of weight. You can read about remoting in say 30 - 50 pages and will get a deep insight of remoting. Then you can read a advanced book on remoting to get the fine details. If you directly read the advanced book on remoting it would take a while to get an idea about the complete picture of remoting..

Ravi
14 July, 2006

The best .net book I have read so far

this book brought will take you into the light. this is a fairly small book with a lot of info
It explains how and why thing are done...interface base programming brilliant !! go and buy this book and your competition will be saying "thats very difficult to accomplish" and you leave them saying.."how you do that??"

Paul R. Elliott
09 May, 2006

Great coverage of complex material

Löwy's book does a great job covering some complex, arcane topics. He nicely lays out fundamentals on interface-based design and development, then moves on to clearly cover tough topics like remoting and multithreading.

There's a wealth of information on implementing .NET 2.0's generics throughout the book, including a nice introductory appendix.

I also liked Löwy's emphasis on identifying potential error conditions and discussing how to deal with those conditions. This seems especially strong in the sections on remoting and threading.

Löwy discusses pros and cons of various choices one might have to make; something I think is great since it's critical to make informed decisions for design and implementation.

A great book!

James Holmes
31 March, 2006

The Best .NET book

This book is just excellent. With only 500 pages, it covers many advanced topics and explains each topic really well. I am impressed by both the depth of the coverage and the excellent writing style. If you want to be an advanced .NET developer, you don't want to miss this book.

Besides, my advice to those authors who do not know how to write effectively and constantly produced books inundated with confusion and errors: before you write the next book, make sure you read this book from cover to cover and learn how to write from Juval Lowy.

Mike Davis
04 March, 2006

Good Introductory Book on Certain .NET Topics

At first I was a bit put off with this book, the first three chapters seemed elementary, slow, and redundant. Also just a bit too much of the "beauty of .NET for .NET's sake" garbage. The discussion in chapter 1 about components / Interfaces vs. object heierarchies / inheritance is overdone, and gee, yah, I get the Microsoft Mantra, Dude. Save it for the computer science academic wannabes -- you know, the same weenies that were all excited beyond reality about OOP and C++ just a few years ago. A few years from now the weenies will be telling us how components and interfaces miss the boat, and come up with a new bunch of terms using English words twisted beyond meaning.

I decided to hope this book was at least another "one chapter wonder", and skipped to chapter 10 on remoting. That was a far more valuable read, and convinced me to back track and pick off the other chapters.

After finishing the book in it's entirety, I feel it is one of the most worthwhile .NET programming books I've read (which is a couple dozen in the last 6 months as I'm finally moving more into C#/.NET instead of C++/Win32 SDK/MFC.) It's saying a lot that I read the entire book, as there are not many I've bothered to complete among the hundreds I've read over the years. I'd say 1/3 get tossed aside after a quick review terminating in disgust.

The pace is a bit slow throughout the book, but I consider this a justifiable side effect of Mr. Lowy's style, which is extremely clear. You'd have to be a complete moron to not understand the points he makes. A number of the items covered in the book are a bit arcane and not something you're likely to make use of everyday, and the repetition can be helpful when doing quick re-reads of parts of chapters later on when using the book as a reference.

I bought the book mainly for the information on remoting, and would have been happy enough with it for just that chapter as I needed to get up to speed on it fast. Chapter 10, on remoting, is the best description of the three I read this week. I was pleasantly surprised to also get the lucid review on assembly versioning and delegates, plus clear information on some new .NET 2.0 API's and language elements, plus a nice treatment of programmatic role and component based security. Turned out the book wasn't a "one chapter wonder" after all.

I do NOT feel this is an "advanced" programming book, and no one with lesser experience should be put off by reviews saying that. This book has fairly broad coverage, with simplistic and easy to understand source code examples for illustration of the topics covered. Between the simplicity of the examples, and the clarity of text, I think relatively inexperienced .NET programmers would have few problems with the content. It is a good intermediate book that provides a very lucid treatment of exactly the topics presented in the table of contents. I think any programmer who has gotten past the total .NET newbie phase will benefit from this book as they find need for full information on any of the topics it presents. It's also a great book for people in my situation, with 30 years programming experience, 20 in Windows, needing to get up to speed fast on some .NET topics.

Christophe Besant
10 February, 2006

A great book for understanding how and why works the JVM (I mean, the CLR ;-)

I guess this entry is kind of late: I've been meaning to write it ever since I got my copy of this book several weeks ago. Let me tell you that Juval has a deep understanding of the .NET Framework, he's also an accomplished teacher and this shows in his writing: detailed yet readable. One pearl: it's easy to say you never have to (actually you can't) destroy an object instance, you just loose all references to it and wait until the garbage collector does its thing, the truth of course is darker and more convoluted, you have to understand things like finalizers (or destructors), the IDisposable interface, the Dispose pattern, the GC passes, etc. Fear not, in Section 4.5 Deterministic Finalization, Juval masterly explains the why's and how's of a bullet-proof object disposal implementation (by the way, do yourself a favor and read the whole Chapter 4. Life Cycle Management). This book will especially appeal to people creating a business layer but have information valuable for programmers working in any other layer. I think that it will be particularly illuminating for Java experts trying to understand the inner guts (as they very much like doing) of the .NET Framework. Highly recommended.

Edgar Sanchez Gordon
09 February, 2006

Excellent Book

This is an excellent book. It covers many of the more advanced features of .NET and C#. The presentation is always crystal clear and augmented with code samples that are not only illustrative, but also useful in their own right.

Frank DeRose
11 January, 2006

VERY HIGHLY RECOMMNDED!

Do you have the skills to design and develop component-based .NET applications? If you don't, this book is for you! Author Juval Lowy, has done an outstanding job of writing a great book that teaches you the skills you need to understand .NET component programming and related system issues; as well as, information that is relevant to design options, tips, best practices, and pitfalls.

Lowy begins by providing the basic terminology used throughout the book. Next, the author describes the elements of .NET. such as the Common Language Runtime (CLR), .NET programming languages, the code-generation process, assemblies, and building and composing those assemblies. Then, he examines working with interfaces. The author continues by dealing with the way .NET manages objects, and the good and bad implications this has for the overall .NET programming model. In addition, the author next describes the .NET version-control policy and the ways you can deploy and share its components. He also shows you how to publish and subscribe to events in a component-based application. Next, the author describes .NET's built-in support for invoking asynchronous calls on components, the available programming models, their trade-offs, when to use them, and their pitfalls. Then, he explains in depth how to build multithreaded components. The author continues by showing you how to persist and serialize an object's state. In addition, the author demystifies .NET support for remote calls. He also describes a powerful and useful facet of .NET: its ability to provide ways to define custom services via contexts and call interception. Finally, he addresses the rich topic of .NET code-access security.

With the preceding in mind, the author has also done an excellent job of writing a book that helps you start developing .NET components immediately, taking full advantage of the .NET development infrastructure and application frameworks. In other words, this book takes advantage of what both .NET 1.1 and .NET 2.0 have to offer.

John R. Vacca
16 November, 2005

A good guide to the intricacies of .NET Component-oriented programming

One of the benefits of .NET is that is makes component-oriented programming much easier and efficient, building on previous technologies that were forbidding in complexity and limited in scope. Programming .NET Components by Juwal Löwy from the fine O'Reilly publishing house provides an excellent guide through the intricacies of component programming in .NET.

It begins with a look at the differences between component-oriented versus object-oriented programming. The author then addresses the principles of component-oriented programming such as binary compatibility, language independence and location transparency, showing how .NET adheres to these principles. He discusses .NET basics from a detailed perspective, covering assemblies, deployment and metadata, providing a Visual Studio 2005 perspective.

Next, aspects of interface-based programming are considered with VS2005 features like the ability to generate skeletal implementations and refactoring. Interfaces are collections of methods that provide access points to the component from external clients. Components can implement any number of interfaces, providing the ability to extend functionality easily without breaking existing clients. Again, generics provide a means of defining an abstract template for an interface and using it on multiple components with different specifications. This reduces code bloat while preserving type-safety.

The next chapter looks at the niceties of garbage collection in .NET, which deals with the disposal of managed objects created while a program is run. Pre-managed code, memory leakage was commonplace because of programs that did not clean up after themselves. The garbage collector takes care of that for the programmer, although abstruse features such as non-deterministic finalization mean that one cannot be really sure when the garbage collector will come around, although patterns to mitigate this are covered.

After an overview of versioning, including a look at side-by-side execution of multiple .NET CLR versions, the book moves into a set of chapters dealing with critical elements of component-oriented programming - events, asynchronous calls and multi-threading. Events and asynchronous calls are mechanisms to allow components to notify their clients when a specified condition occurs. These could be Windows-type events like Mouse-clicks or custom events. The introduction of generic delegates opens new vistas for event management. Some of the concepts presented here should be part of the .NET framework for their simplicity and brilliance.

Since all .NET programs are multi-threaded, they allow concurrent execution of multiple code contexts. A multi-threaded application is more responsive to users. In the past, development of such applications has not been a task for the faint-hearted. Tthis thorny problem is mitigated in .NET by a number of convenient features for concurrency management, increasing developer productivity. The book looks at the various elements of synchronization, even providing a convenient helper class.

Subsequent chapters cover serialization, remoting and security, with weighty appendices on generics, web services and a C# Coding Standard based on the best practices in this book, itself the de facto standard for C# coders. This is a book with much meat, enough to serve a feast of ravenous developers, starved from nights of toil at the desktops of the giant software factories. The author was recognized by Microsoft as a Software Legend - one of the world's top .NET experts.

Aaman Lamba
10 November, 2005

A must read for every .NET architect and developer

This is a must read for every .NET architect and developer that is doing any type of Product Line Engineering or Framework building. Component-oriented development is the heart of both and this book teaches you how to do it correctly.

Mr. Lowy has done a great job of putting everything you need to know about how to do Component-oriented development in .NET 2.0 into one place. I highly recommend this book.


T. Anderson
30 September, 2005

All you will ever need on .Net

This book is a must have for your collection on the study of .Net 2.0. Juval is a super resource on all subjects covered in this book and backs them up with clear examples. He is a well respected and often quoted expert in his field. I would highly recommend this book to all those who are serious about mastering the more lofty concepts of this technolgy.

Paul W. Forney
24 September, 2005

Earned a place in my back pack

I used to carry two or three books in my pack along with my laptop. Now I only carry this book. It is an outstanding resource for advanced .NET programming.

Alfred Broderick
04 September, 2005

Item delivered on time in a very good condition

Item delivered on time in a very good condition

Araya E. Kebede
01 September, 2005

Nice update to a solid work

I liked the original and this a good update that covers the migration requirements and new language features. This book will walk you through everything you need to know to build a well designed .NET component with C#. Visual Basic isn't covered. There is a little reference to that in the beginning which is disparaging to VB.NET. But that's ok. I'm sure that anyone doing this type of work in VB will get a lot from this book and can do the language translation.

Jack D. Herrington
27 August, 2005

Excellent best practices reference!


Programming .NET Components
Author: Juval Lowy
Published by O'Reilly Press
ISBN: 0-596-00347-1

Reviewed by Andre Beier, HuNTUG Member

A lot of computer books nowadays teach you how to program, but they hardly ever give an explanation why things should be done in a certain way. This book starts right at the point where other books usually end.

It has in-depth chapters about Interfaces, Lifecycle Management, Version Control, Asynchronous Calls, Multithreading, and many other commonly used .NET technologies. The author has done a really good job explaining even some of the most advanced .NET features.

I would give this book 4.5 (out of 5) stars. My only real criticism is that some concrete programming examples would have made it easier to understand some of the more complex parts of the book. Altogether you can say that this book is an excellent reference of best practices for the advanced programmer. I definitely would not recommend this book for .NET beginners. However, if you ever got frustrated with books that were only scratching the surface, this book is for you. It might be especially useful for former COM programmers since the author takes the time to point out the differences between COM and .NET.



reviewer at HuNTUG
24 May, 2005

The Book for .NET Component Design...

I have the two "big book" on Interoperability by Nathan and Troelsen but when I sat down with them ready to write some .NET component with the desire to make them compatible with COM, I was awash in pages and pages of details!
Those two book are great to cover very deep "gotchas" but I wanted a simple guide to .NET component development.

I read all the reviews here and ran out to 3 bookstores looking for the book - I was so happy when I had it in my hand at the 3rd store!

Everything said here about this book is true - as proof, I'm writing a book review here on Amazon - something I hardly ever do!

If you want to build .NET components, BUY the book!


W. Bell
19 May, 2005

A real gem of a book

After a very long time I have come across a book that is really fabulous. Most of the programming books are too bulky and they waste all the pages in explaining only the documentation rather than the architecture. Most of this documentaion can be obtained on the web. This book explains the principles and the architecture behind all the commonly used .net concepts. I highly recommend this book. However, do not buy this book if you are planning to learn .net and have never used it before. This book caters to programmers who have had at least some programming experience in .net previously.

Utkarsh Narvekar
27 February, 2005

Fantastic Book

If you want a real reference book for .Net programming, this is it. He goes into depth in explaining how things work. Especially liked his chapter on Multithreading. It is a gold-mine for a professional C# programmer.

PS. The guy who gave this book a low rating, probably hasn't done anything sophisticated with .Net yet. Hey, its a reference book and his writing style is clear and to the point.

CrCr
03 February, 2005

Worth every cent!

I have been developing software for 20+ years and am very particular about programming books. This book is my premier C# reference. Juval Lowy covers the topic thoroughly and offers best practices and many well written useful classes.

P. Gulotta
19 January, 2005

A rare gem

Programming .NET Components is a rare gem of .NET programming books. I found the content in this book to provide much-needed perspective related to general .NET programming tasks, answering questions like: best practices for interface and class heirarchy design, in-depth coverage of the .NET garbage collector and how to prevent it from hurting your application's performance, and a thorough explanation of delegates and their more evolved counterparts called events.

Many .NET texts explain "how" to do things, but generally don't explain "why" things are done a certain way. This text gives you the breadth of knowledge you need to make optimal use of .NET technologies, and to understand when to use a particular approach to solve a problem when there is more than one possible option.

I have not read all chapters of this book, but what I have read so far has already more than justified its purchase price. And I know it will be a valuable reference book for me in the future, as I explore threads, remoting, etc.

Daniel Robbins
10 January, 2005

Excellent

This is an excellent book and one that should be on the shelf of every experienced .NET developer. Although I use C# and C++, I primarily use VB.NET. The book is in C#, but it is easy to read, as you might expect. You might have heard the author on DotNetRocks. If so, you probably already expect a lot from this book. So far, I have been impressed. It is a book I plan to keep and refer to occasionally. By contrast, there are so many that I buy, read, and then shelve and never use again. Look at the table of contents and enjoy.

Randy Given
16 December, 2004

Excellent programming resource

Fabulous book that digs into useful, but not widely talked about .NET functionality. It is really a "best-practices" book by a highly respected figure in the development community. I am only half way through the book and will have to read it a couple more times due to the amount of valuable information contained therein. His writing style is clear and concise.

I highly recommend this book to any serious .NET developer.

LikeToCode
17 November, 2004

I'd give it a TEN but they won't let me!

This is the best book I've ever read in this industry. If you are doing .NET, want to learn from where Microsoft leaves off, and have more than a couple of years experience just buy it.

Michael W. Schellenberger
27 September, 2004

Great information.....

Juval knows his stuff! The book could have been even better if more concrete examples of code usage had been given (saves the reader alot of time from having to write experimental code) and more details of component-oriented programming were provided.
Other than that, this is a great book.

BT


developer-exp
14 August, 2004

Best of the best.

I just want to make one point. I bought and read about 40+ books over the last couple of years on .NET, and I am a proffesional programmer working on .NET every day. I will rank this book as the number 1 book among all those 40+ books I have. 6 stars!!!

W. Hwang
08 August, 2004

Take the next step

This book is about half the size of many of my other .NET programming books, and yet I've used about twice as many concepts from it than the bigger books. Computer books are just bloated today because publishers know we knowledge hungry programmers are drawn to the supersized books. Well, this book breaks the mold. It is clear, concise, potent and modestly sized. For example, chapter 11 on context and interception and the logging component example is awesome. If you want to take the next step as a .NET programmer, read this book.

dannomite
08 August, 2004

Programming .NET Components

This book has good coverage of a lot of details you'll need to be aware of to properly program .NET components. Unfortunately, it does not give any indication of how to properly integrated your components into the VS framework. As a result, it cannot be considered a complete reference, though it is valuable for other reasons.

T. Robinson
27 July, 2004

Excellent Book for those who are serious about object design

This book is surely not for beginners, but it is great for those who have at least a few years of experience in the industry and serious about component oriented programming. I have had this book for a while and I go through this book whenever I get time. Everytime I go over samples, I learn something new and make me have better understanding in object oriented (author reiterates it as component oriented) programming. Juval Lowy is a respected person in the software engineering industry and his book speaks for itself.

Hayato Iriumi
14 July, 2004

It's a kind of magic

First of all, this book is like a package og toys you would say weights 5 kg but somehow when you try to bear it it's lot heavier, say 10 kg. And when you open package excited about that there is more toys then expected you find that toys are both so easy to play with and advanced. I would say that in stead of a 400 pages book you get 800 pages book, but you don't have to spend as double amount of time on it as you would with a 800 pages book. The book is all about Components in .NET and how you write components in .NET. But the magic part is not that you get a mountain of clear,usefull, real-life and advanced information on the subject, but that you somehow indirectly learn .NET technology from a 'right' point of view, from a 'easy to compreheand and fun' view. somehow when you learn components technology you find your self knowning the answer on the question 'What is .NET really?'. You feal you get rich, you feal that somebody else couldn't compite with you if you were to compite on what good programming is in .NET. You feal like an expert on the subject and it's not just a feal that comes and goes, it's real!Though i red first 6 chapters in the book i assume the rest is the same. there is not at all difference in qulity in these chapters, which is bit amazing, because when you're doing your own job you tend to get your job sligtly worse in quility as your deadline(finish) approaches. but that is not the case in this book, at least not in the first 6 chapters.This books also explain clearly these topics, which was so many times tried to be explain in other books i've red but with no succes:- What .NET is and why it is- Assemblies- Interfaces- Memory Mangegement in .NET- Delegates(For the first 6 chapters!!! - what about the rest of the book?!!)Ofcourse to get full advantage of this book you have to have some experinece with .NET (ASP.NET) and you have to have some of understanding of .NET and mentioned topics.With this background and this book you will finally get to the core of the mystery behind .NET and after that you will realize that the world has got a powerfull tool for you as a programmer, but you heard of this tool many places but really never was able to find it though everybody say it's there and there. but where you really should look for is in this book.i'm little speachless because i didn't know that man can become expert just of reading a book, we're talkin here about years of experince which is compressed in a single location(the book) and to get years of experience you only read the book in maybe couple of weeks (if you are slow reader, as i am )(...)

05 July, 2004

Just another member of the fan club

This is one of the most clearly-written advanced .NET books that I have seen. My favorie chapter is the one on threading and concurrency management. Along the way the author educates on coding best practices and warns of many subtle pitfalls to beware of in the .NET implementation.

Daniel K. Stern
24 June, 2004

A must have for the weak developer.

This book goes against all practical uses of .Net. If you want to know how to turn .Net into old COM then Juval is the man for you. I love .Net and all of the benefits of using it. Forget COM and let it die like all of the other dinosaur technolgies. All hail .Net.

23 June, 2004

Excellent, as usual

As is customary with O'Reilly, this book is excelent. Obscure areas of .NET such as synchronization domains and contexts are explained very clearly.

Cesar A. Gonzalez Perez
09 June, 2004

WOW, he is a real Software Legend!

Unbelievable, this book shows you how to do things the right way! Awesome!

Yien Hoong Chew
28 May, 2004

Great Book

This book is simply a great book. I strongly recommend reading this book. Don't buy this book is you're intrested in COM+.

26 May, 2004

Juval Lowy is wonderful

This is a must have book. Although it doesn't talk about component oriented programming, it gives lots of details of .net internals. If you are mid-senior level programmer you must have this book.

Erol Bicioglu
27 April, 2004

A Software Engineering Foundation

Mr. Lowy does far more than provide a clear and concise explanation of component-oriented programming through disciplined software engineering practices. He simplifies developing enterprise software by narrowing the numerous design choices. Through code examples he demonstrates using the .NET framework in a manner that promotes defensive coding methods and loose-coupled interfaces. Programming .NET Components provides a knowledge base to build upon and a reference point for evaluating other author's material. The IDesign document of coding practices from his web site is extremely useful for reviewing the recommendations of Mr. Lowy and for extending with one's own lessons-learned when developing software.

Stephen T. Bethke
24 March, 2004

Deep & Clear

The adulations from the previous reviewers here are all well earned. In my opinion, this is well beyond just a great book; it's a must-have! The writing is very clear without being verbose; and it's depth is better than anything I've seen anywhere on .NET. The author not only provides many new insights, but refines and corrects existing ones found elsewhere, even correcting some guidelines from MSDN. For instance he advises in favor of using "lock" to make methods thread-safe, which MSDN does not advise. Given any doubt, I'd trust this author over MSDN. I just wish the book was longer, and covered more relevent topics. It's so good that I want more!

Mr. Raymond Ovanessian
26 February, 2004

Terrific Cookbook and Reference Work

Juval combines both an extensive reference work on the underlying mechanisms of the .NET system, and at the same time gives complete applications showing the abstractions he concisely presents.In addition, he is very friendly about replying to follow up emails on clarifications you may need on things discussed in or out of the book.I have used this book to build some sophisticated software, and highly recommend the book as to the professional programmer getting started in .NET programming, or to the seasoned programmer that may need to reference something in .NET.

26 January, 2004

Buy this book now, with express shipping!!!

I usually don't write book reviews. But, I had to give Lowy some props here. I've been coding .NET since Beta 1, and considered myself up-to-speed on the framework. However, I found myself learning something new in every chapter of this book. Sometimes the devil is in the details, and Lowy really gets into the nooks and crannies of .NET. A must read.

18 January, 2004