Agile Eye for the Opportunistic Guy
An opportunistic programmer's metamorphosis into an agile programmer
Object Oriented Programming Fundamentals in VB.NET
Learn the fundamentals of Object Oriented Programming (OOP) with the features of Visual Basic .NET. We’ll demonstrate how Visual Basic .NET provides support for all four of the key tenets behind the OOP paradigm – abstraction, encapsulation, inheritance and polymorphism - leading to code that is easier to test, maintain, extend and reuse.
You can register at http://www.microsoft.com/seminar/events/inperson/default.mspx. Since these are next month's events, you'll need to use the “Find an event and register today” link next to the map.
I'm looking for a good VB.NET/OOP book, even a VB.NET book with a few excellent chapters on OOP would be good. Please let me know what's worked for you.
Topics I'd really like to learn more about are inheritance and design patterns. I'm familiar with the basics from my (very long ago) days of C++ and articles on the Internet.
For testing ASP.NET pages (.ASPX), which tool has been better--RUnit or NUnitASP? Or, is there another one that's better. Comments greatly appreciated!
RUnit: http://www.ruxp.net/runit.asp
NUnitASP: http://nunitasp.sourceforge.net
After spending about 10x longer developing simple tests and a class than I would have using “opportunistic” methods, I got all the dots and progress bar to run green. 'Tis a good feeling indeed. I'm sure it will be routine in time, but the first time is always special. Ho[pefully coding speed will increase as I become more familiar with the methodology.
NUnit is a much faster testing environment that the old “fix code--reload web page--fail--debug” method was. That alone will speed development.
Developing Automated Tests Using NUnit and VB.NET
source: http://www.byte-vision.com/NUnitAndVBPrint.aspx
This article describes how to write unit tests in Visual Basic .NET using the market standard automated unit testing tool NUnit 2.0.
So Day 1 of my agile metamorphosis has passed, and I can pretty much sum it up by saying "Boy, that makes you think."
The major hurdle to me was overcomming that nagging thought of “This is stupid--I could be done by now if I did it the other way.” And that thought, maybe more than any other, may be the dividing line between improving oneself and staying opportunistic.
It's very tricky to write tests around code that doesn't exist. I had to outline class structures carefully, and create a skeleton with properties I thought I needed. As I planned the tests, I did find myself adding or changing a couple properties--a habit I hope to break as I get better at planning.
In his webcast Thursday, Jim Newkirk said he likes to separate programming tasks into what he can complete in 4-8 hours, and spend as much time writing and running tests. That's about how these things seem to go--as much time doing one as the other. At first blush it looks like you're doubling the amount of time it takes to do something (and at this stage in my learning, that's about the case), but it becomes apparent that this deliberate, thoughtful progression will actually speed up the process.
link to Jim's on demand webcast: http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032256315&Culture=en-US
It appears that one of the characteristics of an agile developer is that you can use FLA (four or five letter acronynms), rather than the TLAs the rest of us use.
What do 'SCRUM' and 'CRUD' mean?
Reading the posts of Darrell, Brendan, et al, I was starting to catch the TDD bug. I read with great interest Sandy's post Software Socialism, which hit the mark. I am opportunistic. I am a scientist turned programmer. One CS class in my life--intro to OOP using c++ in '97. Then, Jim Newkirk's TDD webcast today (no on-demand link yet). I need to improve. I need to get better. And I'm excited to do so, realizing it will be a lot of work. Looking up the hill to climb, it's almost overwhelming. Where do I start?
This isn't going to be an overnight transformation. I don't have too much spare time right now, with one full time contract and two freelance projects going on, plus two site upgrades later this year. Full time contract includes learning Win2k3/IIS6 and SharePoint Portal Server.
So where to begin? Is it best to learn NUnit/NUnitASP (most of my work is web-based)? Start with NDoc immediately? FxCop? What's the best tool to start using? And incorporate others as I go on.
Books, too. Obviously Jim Newkirk's. Then what? Code Complete? Pragmatic Programmer?
This will be an interesting project--the conversion of one opportunistic to agile.
MSDN Architecture Webcast: patterns & practices Live: Test Driven Development – Level 200
Thursday, July 15, 2004 11:00 AM - Thursday, July 15, 2004 12:30 PM (GMT-08:00) Pacific Time (US & Canada)
Language: English-American
Live Meeting Webcast
Online Event United States
In Kent Beck's book titled Test-Driven Development, by Example he defines Test-Driven Development (TDD) as driving software development with automated tests. He goes further by stating that TDD is governed by two simple rules: write new code only if an automated test has failed and eliminate duplication. The implications of these two simple rules can be a profound change to the way that software is written. Most of the literature to date has bundled TDD along with Extreme Programming (XP). However, the benefits of using TDD are not limited to XP, and can be realized in any programming methodology. This webcast will provide an introduction into TDD, demonstrating how it works and what benefits it provides when used with Microsoft® .NET. The examples shown will use Visual C#® and NUnit.