Customer Reviews

Professional DotNetNuke Module Programming (Wrox Programmer to Programmer)

5 star:		(3)
4 star:		(2)
3 star:		(1)
2 star:		(0)
1 star:		(1)

 

 

I'd say the other reviewers are harsh bordering on unfair. I found the book very useful in picking up the fundamentals of DNN module development. It provided a good number of topics on which to search for more information; topics I would not have known existed (with any ease) without first reading this book.

I am no newbie to .NET development (10 years in the trade) but like many others out there, new to DNN. I needed something more than the documentation provided by DNN, which is patchy at best and useless at worst, and this book provided it.

I believe DNN is growing as an application and the literature support it will no doubt improve. Criticisms I would make of this book are as follows. At around 300 pages, there is scope to add more detail ... come on Mitchell, it's clear you know more, put it down on paper. Second, there a few careless errata (my favorite are VB files given a .cs extension) but on the other hand, this is by no means uncommon in Wrox books; I've read a few, I know.

So if you're interested in knowing more than the sdk documentation can tell you (and not just interested in showing off what you know already, other reviewers!) then this is pretty much your only option in book form. Buy it, search the forums and blogs, and you will be doing ok.

Professional DotNetNuke Module programming falls in-between targeting beginners who need to know how to do things in the simplest way possible, and targeting professionals, who need a comprehensive overview of the API and best practices for using it.

The author stresses using the Web Application Project model rather that the Web Site Project model, and while this may be best practice for professional module developers wanting to distribute pre-compiled code, it is much more difficult to debug and is an overall slower development process.

At only 306 pages including the index it doesn't feel like as good a value as other wrox books in the same price range. For instance, Professional ASP.NET 3.5: In C# and VB (Programmer to Programmer) which I would highly reccomend has 1673 pages including the index and costs about the same amount.

Overall, being new to DotNetNuke programming, I found this book to be usefull to get an overview of the way the framework works and reccomended practices for integrating new modules into the existing framework. However, this book fell short in providing the level of quality and detail I have come to expect from Wrox books. 3 stars.

This is a shallow book. It lacks the depth one is looking for when doing serious module programming. The book spends too much time on basic issues - including how to install DotNetNuke and a comparison of versions 3/4/5.

But when more interesting topics arise, the author much too often simply writes 'XXX is beyond the scope of this book'.

The structure already shows the shortcomings: The author introduces module programming by example, e.g. by creating a simple, basic module (chapters 4-9). This is the kind of information you easily find browsing the web.

The book is short on fundamentals. As an example, take the definition of a module in the chapter on 'Under the DotNetNuke Hood' on page 31:
"Modules are the key pieces of functionality that exist inside DotNetNuke installations. Tabs create the page structures needed to house the functionality; and, in the end, modules actually implement the desired result. DotNetNuke has many core modules available... (list of some modules follows)"
Sorry, but this is supposed to be a book about module programming, the reader deserves much more precision and thoughtfulness (this section (and the whole book) really contains no more in-depth discussion of what a module is and what the guiding principles behind DotNetNuke's module architecture are).

Headings often sound better than their content. An example: Chapter 9 (Packaging, installing, debugging) contains a section titled: 'Distribution and Testing Considerations'. This could certainly be an important issue. But the author devotes 12 lines to it and mainly reiterates a single idea: Testing should occur on multiple DotNetNuke installations with varied settings.

I bought this book to overcome the shortage of information that is packaged with the DNN source code. DNN has been changing so fast that the documentation describing how to program (at least that I could find online) struggles to keep up. This book is useful, clear, and accurate - I would recommend it for anyone that already has C# / VB experience that needs to understand how to create and deploy modules under DotNetNuke. Worth the price.

Yes, there is some scope for improvement here. But it is ridiculous to criticize the author for not making the book longer. My shelves are groaning under the weight of huge computer books, bloated with information that is readily available elsewhere.

Instead of padding out his book, Mitchel tells you where to get the information you need.

What Mitchel does supply, that I haven't seen anywhere else (except his site), is a full treatment of the Web Application Projects (WAP) route to module development. WAP vs WSP is one of those stupid religious wars.

What Mitchel doesn't say (but probably should) is that the alternative Web Site Projects (WSP)route may not get you where you want to go. He merely observes that "there are ways to create compiled assemblies from WSP projects but they are very complex to complete". But, if you have a complex module or suite of modules, you may simply be unable to compile them as a WSP. I have learnt that the hard way.

His book is not just the best treatment of WAP development in DotNetNuke, but the only one. For that alone it is worth the bucks.

Professional DotNetNuke Module Programming provides a great overview of what can be done in DotNetNuke. By the end of the book you will know what module programming is used for, what sorts of techniques module programming employs, and when to use these techniques. The multitude of code examples in the book in both VB.Net and C#.Net also show you how to code your module and implement these techniques. One of the truly great things about the book is the choice of the GuestBook for the code example, referenced mainly in chapters 4-10. The example uses many different DotNetNuke module techniques in a scenario that makes sense, rather than just hacking together techniques for the sake of showing them in the book. So, while the coding can get tiresome, I encourage you to go through all of the example code and try to implement it yourself. You will learn a lot!

Where I find the book lacking is in the details. Oftentimes they forget to include the "why" or leave out important information in what seems like a hurried attempt to get the book out the door.

The coverage of the manifest (.dnn) file provides an excellent example of where details would have been helpful to the reader. The whole explanation of what the control-keys do is left out. Scattered throughout the book are explanations, but it never talks about the need to have the control key left blank for the primary view, for example. Also, nowhere in the book was an explanation of control-type and what that means. Later on when the authors discuss different techniques for Module Communication in Chapter 13, they do not say how the different techniques affect the manifest, nor do they mention the running GuestBook example and say which of the techniques it used. Further, in Chapter 13 the code examples are very light. Therefore, it becomes difficult to implement the different techniques for Module Communication given the information provided.

Localization techniques provide another example of where details are left out or come up much later. The dnn:Label control is presented, but there is no good explanation of all the ways it differs from the asp:label control. The definition of "implicit localization" is not clear in Chapter 8, though as you read through the book there are more clues, but nothing concrete.

Style display has a similar lack of detail in the descriptions. The authors use several different techniques for displaying components and it is not clear at the time they are used or why they were chosen. There are some CSS classes that they hard code such as "SubHead". There is no mention of why this technique is used. Further for both the hardcoded classes and the skin messages such as "Yellow Warning", there is no discussion as to whether or not these classes are part of all skins or just the DotNetNuke skins.

Another time saver in learning the material would be some more integration in the requirements explanation in Chapter 4 between the requirements and dotnetnuke. Perhaps, a diagram of what files /components were going to be created in the IDE, what each did, and which components could talk to which other components. The author goes right into building the DAL without giving us a real understanding of how all of the components fit together. Further, there was no picture of what the page looked like after writing. I only was given one "module" to install and "both" GuestBook controls showed up on the same page. But, this was not the effect that I wanted. I would have liked to have been able to add the two modules separately. No discussion was given on this.

There are other small issues that I would like the author to clean up. In Chapter 8, code listing 8-1-3, the authors should not be using this.ModuleId, but should instead be getting the ModuleId from the other module. Chapter 10, which is a great explanation of different module interfaces, falls short on the last interface IPropertyAccess . Unlike all other code examples in the book, it uses only a "VB" example for "space reasons". However, the example is not even in terms of the GuestBook as all other relevant examples are. The authors leave that exercise for the reader. I have to assume the authors were lazy and did not feel like writing this code example themselves, although it would have really helped the reader. I would have also liked an explanation of when in the lifespan of a page, when the settings collection becomes available and whether or not it is possible to share settings between modules in the same manifest.

So, while this book is a good overview of what DotNetNuke is capable of, it takes more time to weed through than I would have liked due to the lack of details, or details in places other than where I expected to see them. If you want an overview of DotNetNuke programming, that goes beyond the current free videos on the DotNetNuke site, this book provides a great introduction.

About the author: I am a technologist from Pittsburgh, PA that has performed all roles in a development organization. I believe that great people, processes, and architecture lead to great products. The example in this book was the first DotNetNuke module that I have written. I used the first release of version 6 of DotNetNuke Community Edition to write it.

This is a great book to familiarize yourself with developing in the DotNetNuke framework. You will need something more than the documentation provided by DNN and this book is IMO your best option. What the book lacks, it makes up for by telling you where to find the answers. First rate effort, and thanks for your hard work!