Listen to the Audio (MP3)
[Dan] Thanks for having me, Fritz.
[Fritz] And then the revealing module pattern, how does that differ from the prototype pattern and what problem does that solve differently?
[Dan] Yeah, so the prototype pattern and there’s another one that’s kind of really closely lined with revealing module pattern called the revealing prototype pattern and it also uses the prototype key word but it’s very similar to the one you just asked about the revealing module pattern.
[Fritz] Yeah, that’s interesting. So it’s almost, you can either go private by convention just by using a standard naming convention or you can actually enforce it by using the prototype pattern.
[Dan] Yeah, that’s exactly right.
[Dan] Yeah, it’s a great question. In fact, I just had a company ask me about that. So which one do I pick and, of course, there’s not one answer fits all.
[Dan] So it really depends what you just said is absolutely in my opinion correct, which is I think as a, especially if you’re on a team or even if you’re just an individual a team of one, you should go through and pick out which pattern for this particular project you think is best. Now if it were me, here’s kind of the way I think of it. If I were writing a let’s say base library that several web apps are going to use or even one, but I know that there’s going to be some pieces that I’m not really sure on right now as I’m writing I and I know people might want to hook in that and have some better extension points, then I would look at either the prototype pattern or the revealing prototype. Now, really just a real quick summation between the two the revealing prototype also gives you that public/private stuff like the revealing module pattern does whereas the prototype pattern does not but both of the prototype patterns do give you the benefit of that extension or that hook capability. So, if I were writing a library that I need people to override things or I’m not even sure what I need them to override, I want them to have that option, I’d probably pick a prototype, one of the prototype patterns. If I’m writing some code that is very unique to the app and it’s kind of a one off for this app which is what I think a lot of people are kind of in that mode as writing custom apps for customers, then my personal preference is the revealing module pattern you could always go with the module pattern as well which is very close but I think the revealing module patterns a little bit cleaner and we go through that in the course and explain kind of the syntax there and the differences.
[Fritz] Great, that makes a lot of sense.
[Dan] Thanks for having me again.
About the Author
Paul Ballard is a Chief Architect specializing in large scale distributed system development and enterprise software processes. Paul has more than twenty years of development experience including being a former Microsoft MVP, a speaker at technical conferences such as Microsoft Tech-Ed and VSLive, and a published author. Prior to working on the Windows platform, he built software using a vast array of technologies including Java, Unix, C, and even OS/2.
- Meet the Author: Joe Eames on jQuery Advanced Topics
- Meet the Author: Kate Gregory on C++ Fundamentals Part 2
- Meet the Author: Matt Milner on Developing OData Clients
- Meet the Author: David Chappell on Cloud Computing: Seeing the Big Picture
- New Patterns for the Design Patterns Library: Builder & Prototype
- Meet the Author: John Sonmez on Introduction to Objective-C
- Meet the Author: Richard Seroter on Microsoft StreamInsight Fundamentals