Summer of NHibernate Feedback: this isn’t real!
During my production of the Summer of NHibernate screencast series, I have routinely received questions from viewers that tend to want me to dig into more real-world issues that come into play in the development of a non-demo/non-sample application. Since the focus of the code samples in the NHibernate screencasts was to demonstrate and reinforce the concepts of NHibernate in each of the installments, I didn’t apply much focus to the immediate applicability of the sample code to a real-world application. Questions like "how would you structure your solution?", "where is the best place for unit tests?", "shouldn’t you refactor that behavior into a separate class?", etc., etc. were intentionally not part of the focus of this series.
But the repeated requests for details in this regard has got me to thinking: would there be value in another more broadly-focused screencast series that actually took the viewer through our process of architecting and engineering a more real-world application?
As Summer gradually turns into Autumn (yes, this is a northern-hemispheric-centric view of the world) I am tentatively planning a follow-up series that focuses on demonstrating core Agile values and understanding the basic agile techniques and practices (for .NET developers, of course) that reinforce these values. The tentative context for this demonstration would be the building of a real-world application that would allow me to demonstrate for viewers how the ALT.NET principles guide our application development process in some detail. Just as with the Summer of NHibernate series, this screencast series would have broad value for our own internal training needs as well as benefiting the larger community.
I am tentatively planning on reviving the long-dead SkillsPortal project that I had begun the development process on some time ago using ASP.NET webforms and an MVP architecture and starting completely over again from scratch using ASP.NET MVC and DDD tactics to rework the project from the beginning.
A little bit different from the Summer of NHibernate where we took a deep dive into a single technology over the course of the entire series, this series is envisioned as a toe-in-the-water style introduction to the technology elements that are often employed to support an agile approach to development in the .NET ecosystem. There would certainly be code samples and practical development skills to be derived from viewing these sessions, but their primary focus would be on concepts rather than an explicit detailed how-to in the same way as the Summer of NHibernate series was designed to impart explicit coding knowledge into viewers.
The goal of this screencast series would be to lay the groundwork for better understanding the principles and values that define ALT.NET and lead to the adoption of the practices that we will investigate.
There are some significant challenges with this proposed approach of recording screencasts that attempt to document the development of an entire end-to-end project. The first one is simply the sheer scale of the effort involved in any real-world project. Let’s assume (for the sake of argument) that it takes 40-60 hours to build the application (this seems reasonable for the fairly simple application that I have in mind). There are two choices in this case: either every hour of work is recorded (resulting in 40 + hours of content!) or just the highlights are recorded similar in concept to what Rob Conery has been doing with his ASP.NET MVC Storefront series where he fades the video in and out a lot to eliminate our need to see some of the details of his process.
Personally, I think Rob is doing a tremendously valuable thing with his series and I have been learning plenty about the ASP.NET MVC framework from watching him work (and reading the MEAP version of the upcoming ASP.NET MVC In Action book), but IMHO I find the ‘jumps’ between content to be jarring and it makes his workflow generally harder for me to follow. As such, my first inclination is to not repeat that pattern in this new proposed content and instead to capture everything in my process, but I have to ask the question: would anyone actually watch even 20 hours of video where someone designs and builds a real-world application in real-time (never mind 40-60 hours)?
I’m interested in feedback from people re: the perceived value of this process and ideas about ways to get the right level of detail captured in the content without boring everyone with too much minutiae (or having the process take 40 weeks ).
Draft Topic Outline
Tentatively dubbed ‘Autumn of Agile’, the draft curriculum for this next series is as follows…
Agile Values and Practices Overview
- The Agile Manifesto (one of the worst names for something anyone could ever have chosen)
- The challenges of traditional software development methodologies
- Understanding Agile as a response to traditional methodologies
Basic OO Design Principles (lost in TLA hell )
- Agile Value: flexible, adaptable software
- SRP/SoC (Single-Responsibility Principle/Separation-of-Concerns)
- DIP (Dependency-Inversion-Principle)
- LSP (Liskov-Substitution-Principle)
- OCP (Open-Closed-Principle)
- ISP (Interface-Segregation-Principle)
- DRY (Don’t-Repeat-Yourself)
- YAGNI (You-Aren’t-Gonna-Need-It); ok, not exactly a TLA but still pretty important
- LRM (Last-Responsible-Moment)
- RDP (Reversibility-of-Decision-Principle)
Design Patterns In Action
- Agile Value: stand on the shoulders of those who came before us, learn from them, and don’t repeat their mistakes
- — your favorite design pattern here —
Unit Testing Basics
- Agile Value: tight feedback loop for each individual developer in isolation
- Tools and Technologies
- Structuring tests
- Positive and Negative Tests
- Code Coverage Tools
- Agile Value: decoupled software components must be tested in isolation
- Mocks, Stubs, TestDoubles, and Fakes
- RhinoMocks syntax options
- Agile Value: consider your design from the perspective of its consumers
- Intent, methodology, values, and approach
Project File/Folder Organization
- Agile Value: team flexibility to move from project to project
- Consistency of Project Folder Structure
- Segregation of Project Artifacts
- Structure to support CI efforts/build automation
Source Control Basics
- Agile Value: central storage and versioning of software project artifacts
- Exclusive Checkout Model
- Edit-Merge-Commit Model
- Trunks and Branches
- Commit Comments!
Continuous Integration / Build Automation
- Agile Value: tight feedback loop for the entire development team
Agile Project Planning Principles
- Agile Value: plan enough to manage yourselves, don’t overplan too far in advance
- User Stories
Overview of Domain Driven Design Core Concepts
- Agile Value: solve the problem and then select a technology
- Value Objects
- Aggregate Roots
- Bounded Contexts
This outline isn’t in any temporal order (e.g., the topics will be addressed as they come up in the proposed development of the SkillsPortal project, rather than as the organized and structured outline shown above). Instead, this is just a list of the topics that I would want to ensure were hit upon in the design and development process that would be captured in the screencasts.
I am soliciting feedback from people re: the level of interest in such a curriculum before I decide how to proceed (if at all). What are reader’s thoughts about this outline — too broad? too general? This would be tremendously valuable for me and I can’t wait? Nobody in their right mind would ever want to watch all this?
Please feel free to chime in about your feelings on the above list; feedback here will be my guide re: how (if at all) I would proceed with this proposed series.