A series of posts providing proven
guidance for developing ASP.NET MVC applications from idea to well-designed
So you’ve landed your first project! Just days ago your client came to you and said “I’ve got a great idea and I want you to build it!” With unwavering confidence, you quickly retorted “And I’ll build it, and it’ll be friggin’ awesome!” You agree to a price, you put all the business paperwork in place, and you’re ready to get coding…you sit down at the computer, raring to go, and think to yourself “Now where the hell do I start?”
To begin with, you’ve already gotten ahead of yourself. Before a single key stroke of code is developed, it’s time to do some planning. And once the planning is done - and only after that - it’ll be time to turn those plans into maintainable, tested code.
While there are plenty of coding samples of design patterns and "best practices," it’s sometimes difficult to figure out how the developer got from an empty directory in Windows Explorer to an implemented piece of architectural and functional beauty. This series of posts will walk you through the basics of the project life cycle, from project inception to project completion, turning ideas into requirements, requirements into plans, and plans into code, with a clear and blatantly unfair bias towards the developer’s perspective.
This isn’t intended to discuss a particular project management methodology or advocate the principles of any specific development methodology. Instead, this series’ focus is on using a number of tricks of the trade of traditional Object Oriented Analysis & Design (OOAD) and various development techniques to turn ideas into working code. In other words, bits and pieces from UML, design patterns, OOAD, Domain-Driven Design , Test-Driven Development , etc…you know, like what you’d do on a real project.
Although we’ll be using S#arp Lite as the project starting point and architectural infrastructure, most of the principles and techniques we’ll be using will be applicable to just about any development implementation you’d prefer.
The project activities will be examined over seven “days” with each day focusing on a distinct element of project production. Note that each day, when mapped to a real project, may represent an hour, a day, a week, or perhaps even a month(s) depending on the activities involved and the size of the project. (So don’t take "day" too literally.)
The seven days of the project will cover three major themes of project delivery:
- Part I focuses on the planning and design elements of project delivery; i.e., turning project ideas into a workable design. Part I is split into three days:
- Part II focuses on the implementation phase of project delivery; i.e., turning the design into a working project. Part II is split into four days:
- Day 4 – Setup the Project & Security Infrastructure
- Day 5 – Develop CRUD & Data Management Capabilities
- Day 6 – Provide Reporting Capabilities
- Part III focuses on extending the project to integrate with third-party, external services with an appropriate separation of concerns.
- Day 7 – Integrate with External Services
While this series of posts walks through the development of the project in a seemingly waterfall fashion, it does not intend to promote such a methodology; indeed, an agile/iterative approach to development is recommended but is beyond the scope of this series to discuss. If you find them useful, I'd encourage you to adapt some or all of the described techniques into your organization’s preferred methodology.
At the end of the series, you should have a basic understanding of how to turn a project idea into a well-designed, maintainable deliverable using real-world techniques, starting from nothing but an idea.
Who is the Intended Audience?
While I am attempting to write this series to be understandable by any skill level, you're expected to have basic knowledge of UML (specifically class diagrams and sequence diagrams) and to be familiar with ASP.NET MVC and C#. For materials on these subjects, refer to Pro C# 2010 and the .NET Platform [Troelsen 2010], Professional ASP.NET MVC 3 [Galloway 2011], and UML 2.0 Pocket Reference [Pilone 2006]. Other references will be provided along the way to help fill in any missing gaps and secondary subjects.
Developers of experienced-beginner to intermediate levels will gain the most from this series.
The next post in this series is Day 1 – Define the Requirements & Actor/System Interactions...
08-02-2012 3:08 PM