CodeBetter.Com
CodeBetter.Com
RSS 2.0 via Feedburner
           Do you Twitter? Follow us @CodeBetter

Darrell Norton's Blog [MVP]

Fill in description here...

September 2003 - Posts

  • Agile concerns with responses

    Our very own Steve Eichert recently posted on the skeptics' view of agile.  It has taken a while, but I have compiled responses to each of the original concerns, in order.


    Too disorganized

    I’ve always been a little leery about using XP to manage projects.  To me, XP is much more of a development-focused methodology.  Scrum, on the other hand, is well-suited to handling the business side of things.  There is even an XP @ Scrum (Scrum with XP) methodology that uses Scrum for management and XP for development.  If you present Scrum to business managers, it is very clear, consistent, and well-organized.  It also requires significant discipline on the part of everyone, so that should dispel any doubts about disorganization.

    How does the customer really make out any better?

    I must defer to Ron Jeffries’ excellent article Take a Card, Any Card.  This excerpt should explain how the customer does make out better.

    Pick up a deck of playing cards. Value the Aces low, at one point, and the Kings high, at 13. Now lets do some project management.

    Think of the 52 cards as representing the 52 features you want in your next project. And suppose that, like most projects, you want the product in six months, but your programmers can only do about one feature a week. There are 364 points of value in your project, and the project is going to take a year to get all those points.

    What will happen at six months? Well, if your programmers work as many do, there won't be anything useful implemented in six months. Even if they could ship something in six months, it will probably only have half the value, or about 180 points. That's not very good. We need a better deal.

    What if you didn't have to ship randomly? What if you could ship any 26 cards: what's your possible score then? It's 266! That's right, you can ship 266 points out of 364 in the first six months!

    What if software development could be like that? Almost three-fourths of the value in half the time? Well, software development can be like that.

    Won’t it cost the customer more?  How can we really control and manage changes in this environment?  Won't we just be going back over and over to change what we've already done?

    If you look at the card example, the same amount of stuff (the value of the cards) is completed in the same amount of time (1 year).  That doesn’t cost the customer any more, and in fact allows them to start using the most useful parts of the application (the higher value cards) first. 

    The way to control and manage change is through discipline.  Most people think agile means little or no discipline, but to be able to pull off things like daily builds and 100 percent automated unit test code coverage take a lot of discipline.  There will have to be a configuration management/change control process in place and it will have to be followed.  If a decent process is in place, then things will work.  Otherwise, they won’t.

    Perhaps the last complaint, about redoing stuff, is the real issue.  As both part of Scrum and XP, during the planning stages the developers estimate how long each story or feature or whatever will take.  This estimating is not done with the tasks isolated.  There is always the opportunity to do things several ways.  Say feature X is estimated at 3 days and feature Y is estimated at 2 days.  The customer wants to do X, but X would be much easier to do if Y was done.  So the developer would change the estimate to do features X and Y in 4 days, instead of 5.  The customer can then make an informed decision on whether the extra effort (1 day) is worth it to get both X and Y.  The key to the whole process is that the user, who has the most information about the value to the business, makes the decision given as much information as possible.

    Will the developers go back in and change things?  Perhaps.  But wouldn’t the business user prefer to wait until they are sure they need to go back in and change things before actually committing to do it?

    Do you need to have Attention Deficit Disorder (ADD) to be a fit with agile?

    No.

    It's too difficult to sell that type of process to clients.

    This sort of objection is pulled out when other objections fail.  It is kind of like telling someone not to do something because it is “unprofessional.”  All you are really saying is that you have not tried yet. 

    Our clients won't want to have that level of responsibility, they just want to hand us a document describing what they want and have us come back in 3 months with a finished “product”.   Our clients our too busy with other things, they won't be able to give us the time and energy needed.

    Some customers may decide to go the agile approach, others may not.  It is really up to the customer to decide.  If the customer does decide to try an agile approach, they must abide by the rights and responsibilities.  Either way,  the development team can still use it internally.  Or, if you are sufficiently well off, you can turn down the work.

    So what happens to our QA staff?

    Brian Marick has written an excellent series of articles on agile testing.  Read his weblog and some of his writing to see where he is taking the idea of testers/QA staff.

    I think that there will still be testers available to help the programmers and the business customers write good, accurate tests. 

    So if a client has the ability to end a project after an iteration, how do we schedule resources and forecast revenues?  Doesn't that add a lot of risk and uncertainty?

    Technically, you cannot schedule/forecast with 100 percent certainty.  The problem is that scheduling and forecasting will no longer have the “crutch” of fixed-scope fixed-length contracts.  This is a standard staffing problem, and seasonal jobs offer some interesting possibilities.  Another possible response is to make sure that there is sufficient work in the “hopper” so that there is always more work.  And if there is a regular sizable backlog of work in the hopper, then it is time to hire more people.

    Short iterations work against a lot of current management practices.  For example, discounting initial work to get a customer could result in that customer getting a bunch of quality work done for cheap, and then taking their business to the next low bidder.  The easiest way to avoid this is to avoid making the initial discount.  I think, and a small amount of experience has proven me right so far (I am not making any definitive claims yet), is that this type of arrangement will self-select customers that want a relationship.  According to Crossing the Chasm, the pragmatists want a single supplier anyway, so once you have proven you worth, they will stick around.  And these are the kinds of customers with money that you want (compared to the visionaries).

    Certainly there is some risk and uncertainty. I believe the risk is nullified by the elimination of fixed-price contracts that go over budget and leave the development organization eating the cost.  The customer also wins by avoiding situations where the fixed-price contract covered 2 weeks worth of work that was finished in 2 days!  This can go a long way toward crossing the divide between the business people and the technical people.

    See The Predictability Paradox, by Mary Poppendieck.

    Sounds too risky?  Waterfall is much more conservative and stable, I like stability.

    You are trying to equate stability with a desire not to change.  Waterfall may seem to be conservative and stable, but in reality it fails to meet the customer’s needs the majority of the time.  You can run and hide behind your contract, saying that the customer signed off on it and you built it exactly according to spec.  I know where the customer is going to tell you to put that spec.  And in the long run, customers will eventually gravitate toward those companies that deliver results faster. 

    It all depends on the nature of the project.  If the requirements are going to change very little between the beginning of the requirements definition phase and final delivery (including bug fixes), then sure, waterfall is great.  But if not, which is usually the case, then sorry but it ain’t gonna cut it.

    Don't resources need to be able to do everything?  Isn't it hard to find people like that?

    First of all, people are not resources.  They are people.  You cannot substitute one person for another in software development.  Joel Spolsky notes, “Programmers are not interchangeable. It takes seven times longer for John to fix Rita's bug than for Rita to fix Rita's bug. And if you try to put your UI programmer on a WinSock problem, she'll stall and waste a week getting up to speed on WinSock programming.”  And yes, they need to understand a little bit about a broad range of things, and know a few things in extreme depth.  Today’s business world is moving toward generalizing specialists.

    Second, yes it is hard to find people like that.  There are not many good developers out there.  So if you want to hire mediocre people paid a decent US wage and hope to compete with good offshore developers paid a small US wage, good luck.  Please email me your company’s stock ticker so I can short it.  Also, agile development has only been proven to work with good developers.  Do not try it if you are staffed with average developers.  That is what a heavy methodology is for (bringing all projects to the same level of underperformance).  Only try agile if you want good-to-great performance and are willing to pay for it with hard work, discipline, and giving your developers room to work.

    How do you know when you’re done?

    When the customer says you are done.  However, according to the Secrets of Consulting, there will always be a #2 problem that you should promote immediately after you fix the #1 problem.  It all depends on how good you are at marketing.

    How do you handle changes in scope?  I know it’s embraced but how do you actually manage all the changes?

    In Scrum, the customer is not allowed to change the work for the current sprint.  The same for XP.  The customer can make small changes, clarifying current requirements, but no big ones.  The reason is since you are delivering in a couple of weeks to a month at most (Scrum sprints are 30 days), then the customer can wait that long.  This rule also prevents the “requirement of the day” syndrome, where someone gets a brilliant idea that just HAS to be in the product.  Two weeks later at the beginning of the next iteration, the idea will still be around if it is good (or if the idea’s sponsor is tenacious) or will have quietly faded away if it was bad.

    Technically you could allow the customer to make a 180-degree turn.  You just get yourself to a stable code state and then end the iteration.  This is like slamming on the brakes while going 55 mph (88 km/hr).  The customer is going to pay for it since it will take a while to get back up to speed.  This is not recommended except for extenuating circumstances.

    Customers will want more documentation.

    Customers usually ask for documentation because they’ve been left holding the bag before.  Politely tell the customer that you need very little documentation to support development and there are too many problems with documentation.  If the customer wants more documentation, make it an XP user story or use case, and let the customer decide how to prioritize it.  After all, it’s their money.

    Concluding Remarks

    One of the best overviews of agile methodologies, especially suited to business managers, is Martin Fowler’s The New Methodology.  You probably know most of this stuff already, but Martin brings up important customer and management points which will help you sell agile.

  • Name that Product

    Here is a quote from an "exceptional" leader in a particular industry (extra credit goes to the first person that can name the product (no googling!)):

    "I suggest you look at both what you are building and how you are operating and challenge yourself. Are you really doing anything exceptional? And here's the catch: Whereas it used to be truly exceptional to build a fantastic, near-zero-defect [product] and provide great customer service, these are no longer major factors in differentiation. We aren't yet to the level of the auto industry, for example, where compared with what we were buying 20 years ago, it's becoming hard to buy a bad car (although service still could improve.) But high quality and customer service are now "table stakes" in [this product's industry]. It's getting to be like [old product reference]. You need it just to be in the game."

    I can tell you that the industry is not closely related to the software industry.  However, look how much of what he says applies to it (and us)!  What are you doing to challenge yourself?

  • What is a requirement?

    Brady Gaster asks what is a requirement?

    It is hard to define a requirement.  I can say that a requirement is something that is required for (in this case) a software system, but that is a circular definition.  So instead, I'll say that a requirement is something that reflects a business need.  By this definition not all requirements will be satisfied in code, some could be satisfied by a defined process or some sort of external intervention.

    Most people have an intuitive sense of what a requirement is.  But what most people do not necessarily know (but want to know!) are the attributes that a good requirement should have.  These are the attributes a good requirement should possess:

    • Atomic - cannot be broken down into smaller pieces
    • Correct - technically and legally possible
    • Complete - expresses a whole idea or statement
    • Clear - unambiguous
    • Consistency - does not conflict with other requirements
    • Necessary - addresses an actual business or technical need
    • Verifiable - you can test whether the requirement is implemented correctly or not
    • Traceable - uniquely identified, and thus trackable
    • Feasible - can accomplish it within cost and schedule constraints
    • Design independent - does not impose a specific implementation
    • Prioritized - the list is ranked in order of importance, taking into account dependencies amoung groups of requirements
    • Modular - can be changed without excessive impact

    Like all systems-oriented things, some of the attributes a good requirement has are defined in relationships with other requirements.  For example, a requirement all by itself cannot be consistent with other requirements, it is only when compared to another requirement that it can be consistent.

    Check out Karl Weigers book Software Requirements (2nd ed.). This book alone makes Microsoft Press a legitimate publisher. Also note that at the time of writing, this book is #5 in Kirkland, Washington (a couple of miles from Redmond).  I'm guessing it is popular there for a reason.

  • Crossing the (Microsoft) Chasm

    I was reading Geoffrey Moore’s excellent book Crossing the Chasm the other day and it describes the situation between Windows and Linux exactly.

    The section on competitive positioning shows that early in a technology products' life the focus is, appropriately enough, product-centric.  This is good for getting the techno-enthusiasts and early visionaries to buy into your product.  To cross the chasm and get a foothold in the lucrative pragmatist market, the focus has to shift to a market-centric view.  The following table is straight from the book (page 137):

    Product-Centric Market-Centric
    Fastest product Largest installed base
    Easiest to use Most third party supporters
    Elegant architecture De facto standard
    Product price Cost of ownership
    Unique functionality Quality of support

    Probably the easiest two to compare are product price and cost of ownership.  Supporters of Linux like to brag that the software itself is free.  What I have not seen is the cost of supporting Linux.  If the software is free, then the only way RedHat and others can make money is through support charges.  On a related note, lately Microsoft has been touting reports that show the overall total cost of ownership (TCO) is lower for Windows servers than for Linux servers, if you take into account all related costs.  See how that falls right into line?

    I've also heard that Linux has the best architecture, since thousands of people worldwide have looked over every line of code something like a bajillion times.  Whether these arguments hold water or not remains to be seen, but there is this general perception.  And on the other side, Microsoft of course claims the de facto standard on the desktop, and is way up there with servers too.

    You could continue with fastest product and largest installed base or with unique functionality and quality of support, but the results would be more of the same.  The interesting one is with ease of use versus most third party supporters.  Here, Microsoft is covering both sides, product and market centric!  What is the significance of that?

    Well, first Microsoft realizes that ease of use is subject to increasing returns.  As Joel points out, making software 10 percent easier to use doubles the number of potential users.  And without supporters to fill in the gaps in your whole product offering, you're hosed.  To really satisfy the pragmatists, a whole product has to deliver 100 percent.  Most people will agree that Microsoft comes closer to delivering 100 percent than any other group does, especially Linux.  Second, Microsoft has also been very big on supporting developers and ISVs.  Developers and ISVs make the software that make people want to buy your operating system.  And now we understand why.  This will be the biggest hurdle for Linux to overcome.  Without at least one of these factors, Linux will remain a niche player, used by techno-enthusiasts and Microsoft-haters like Scott McNealy.

    Linux fans, please don't flame me.  I'm not picking on Linux, even Giga says to hold off until 2005.  The product just isn't mature enough yet.  It's still focusing on itself (product-centric view) rather than on the business problems (market-centric view).

  • Help with wbloggar?

    Anyone know how to setup w.bloggar on DotNetJunkies?  I tried using Scott's directions, but I keep getting the following error:

    w.bloggar: -1072896766
    Unable to parse the XML response. Parser Reason:A string literal was expected, but no opening quote character was found.

    What?

  • For those who refuse to reuse or refactor

    “We will never catch up. We will never fill all the capacity that Moore's law is heaping on us. The way we get more functionality these days is by doing more and more leveraging of existing infrastructure and existing applications. As systems are becoming longer lived, versioning is becoming more important.”  [Anders Hejlsberg, Part IV of the Artima series of interviews]

    Finally, someone who is very smart refutes those who demand that software be rewritten from the ground-up.  Remember, don't do what Netscape did.

  • Code Reviews

    For reasons I’ve mentioned before, I think that at some point during the project, when things are fairly well understood, developers should work individually. On a recently completed project, our early efforts were almost exclusively pair programming. In the later stages of the project, we split up and worked individually.

    During deployment, we encountered several errors, all of which were related to stored procs developed after pair programming stopped. The errors were all easy to fix once the offending proc was found (it took longer than normal since our project was a data warehouse reporting solution crunching gigabytes o' data). In helping to debug these errors, I noticed I could easily have spotted them before deployment, when you want things to run very smoothly and not have to deal with minor issues.

    Code reviews in this case would really have helped, and will certainly be part of future projects for any individually developed code. Reviewing the stored proc would have taken about 5 minutes. That 5 minutes spent earlier in the development cycle is much better than 30 minutes later in the cycle (especially during deployment!).

    But why not pair program the entire time? For this project, the majority of the time spent was in understanding the domain around the requirement. The time it took to figure that out dwarfed the time it took to write the stored proc. However, it was in the writing of the stored proc where the error was introduced. So the easiest and quickest way to fix that is to introduce a set of “fresh eyes” to look over the writing portion.

    The fresh eyes test is the key to why I think code reviews are still important, even if a team is pair programming. Two programmers, even if one is thinking strategically and one tactically, might still miss the forest for the trees. In a previous project, our team did pair design followed by peer review. For the parts of the project that were done this way, very little was ever found to be fundamentally flawed. Code reviews in that project also took very little time and caught a lot of omission errors (one of the hardest types of errors to catch).

    Michael Hamman explains, in a blog dissertation on cognitive breakdowns, the exact reason why I think pair programming teams need to stop and have their work reviewed by an external party (external meaning anyone other than the two members of the pair):

    Because sometimes our flow needs to be broken—we need to be awoken from our “circumspective” slumber. [Breakdown, Not a Problem]

    There are several important characteristics to the code reviews that I promote. First, they need to be informal. Formal tracking, review by a panel of other developers and a facilitator, etc. is just too much for most agile projects. Second, the reviews need to cover all non-pair-programmed code. This is the absolute minimum, with more to be added as you see fit. I also code review (or peer review, whatever sounds better to you) anything that has been pair-designed, because these are usually the key parts of the system. Third, the reviews should be relatively quick, and the turnaround time should be quick as well. Simply pick a time once, twice, or three times per week (whatever works for your team) and do it. 30 minutes has always been plenty of (if not too much) time. And the changes are made immediately.

    That’s about it. The overall quality of the code will go up as bugs are reduced. Fewer bugs mean a more predictable schedule. Both of these make customers happier, which is vitally important as a consultant in the current IT environment.

  • Business Cards

    Paul Vick's post on ordering small batches of business cards reminds me of a story from my former company.  You see, for the entire 2 years and 2 months I was there, I never got business cards.  Not that I didn't want them, but I was actually prevented from getting them.

    It all started when, as a new employee fresh out of the MBA program, I figured that it would take a few months for my employer to make sure I was a good enough employee before they would order me little cards with their fancy logo.  (As an aside, the lamer the logo, the fancier the description of what it represents in order to justify how expensive it is.)  After 3 months or so, I figured out they weren't going to can me, so I went around trying to learn how to get business cards.

    It seemed simple enough at first.  Just fill out the form and get your manager to sign it.  Not too hard.  So I fill in the form and take it to my manager.  Now my former manager, a guy named Kenny, was great.  He did not even look at the form he just signed it how's it going have a nice day thank you very much.  So I sent it off to some department via inter-office mail and I was done.  Total elapsed time so far: 30 minutes.

    A week later I get a the form back with a little yellow sticky note that said the form was not filled in correctly and see form AB-12753 (form name changed to protect the innocent).  As a side note, if your company has more than 10,000 forms, that is a sign of what I like to call bureaucracy.  Whoa!  I had tried searching the company intranet and even found the web page relating to ordering business cards and it never mentioned AB-12573.  So it took me about 15 minutes to find this form, another 10 to read it (it was 5 pages long!), and 1 minute to make the actual change.  Total elapsed time so far: 56 minutes (just me, not everyone else!).

    Now I had to get Kenny to sign a new form, but he was out on vacation for the rest of the week.  So I cool my heels until next Monday, then go upstairs.  Oh  by the way, he was on the 5th floor while all of us were on the 1st floor, a real hierarchical company.  He signs it, I have to explain why he is signing the same form twice in two weeks (he does pay that much attention), and then head back downstairs to send the form, again, via inter-office mail.  Total elapsed time: 67 minutes.

    Two days later I get the form back.  It seems, due to political reasons about our company possibly getting bought out, they did not want to give anyone business cards.  A few weeks later I was going to Boston for Essential ASP.NET training at DevelopMentor with Fritz Onion, and I would be going sans business cards.  The company saved a breathtaking $4, but lost a whole bunch of technical contacts with people who were also using ASP.NET back when it was in Beta and many hours were wasted trying to do seemingly simple things as part of the bitter Beta kool-aid.  So I only gave one person my contact info, and it took me about 3 minutes to write it down.  Total elapsed time: 70 minutes.

    To make a really long story only kind of long, my company was eventually bought out 10 months later, and then there was a freeze on business cards until our new parent company could send us the regulations.  I found out that the regulations were in a document that dwarfed the formidable AB-12573, plus an image file that I could get from the company's home page at any time.  New business cards were not approved to be issued until 6 months after that.

    About the time that I could have gotten business cards, I would have had to throw them away since I got promoted and company regulations prohibit incorrect business cards.  So 2 months later I get my promotion.  18 months after I started looking for business cards, I could finally get them.  If I had gotten them, and assuming everything went properly the first time (ha!), this would have taken a total of about 75 minutes of my time.  Assuming an average developer's salary, 75 minutes costs a whole lot more than $4!

    But more than that, it made me feel like the company really did not appreciate anything the developers did.  Not getting business cards is not the reason why I left, but it is indicative of the company culture that was squeezing all discretionary effort out of its work force.

    My new company is different.  The HR person requested my information in an email and has ordered my business cards, along with cards for a few other recent hires, and will deliver them to us once they are done.  None of my time was wasted and I feel like the company is interested enough to let me have business cards, not to mention the fact that I could make up whatever title I wanted, short of executive titles like CEO and COO.  Pretty cool!

  • Odd Todd on PrimeTime Monday

    Just a warning that this post way far off from any .NET-related topic.  My apologies in advance.

    I don't know if anyone watched PrimeTime Monday tonight (9/15/03), maybe you did because it was right before Monday Night Football, but the cartoon at the end was made by a guy named Odd Todd.  I didn't see the credits, but have seen his work on his web site and knew he created it.  If you watched it and thought it was funny (it was very funny), or if you want some entertainment, check out all his Flash cartoons at http://www.oddtodd.com/cartoons.html.  Especially funny are the "Laid off" series and the Matrix spoof "The One."  Enjoy.

  • Milk carton bug reports

    Raymond Chen writes a particularly humorous post about whimsical bug reports.  Paul Vick follows it up.

    Then Paul posts another one on the C++ build chime.

  • Being successful doesn't make you evil

    Rory rants:

    “I think that it's [Microsoft] often misrepresented by people who haven't done even the slightest bit of research into the place, and all too often the negative aspects are considered without any attention at all paid to the good things that MS and its employees do.”

    “MS is not a bad place, and its employees, in spite of what Slashdot might have you think, are people. Being successful doesn't make you evil.” (bold emphasis is mine)

  • Code Access Security blogs and posts and security goodness

     Two good CAS-related blog posts:

    Code Access Security is, in my opinion, an underrated .NET feature.  I don't know if it is the firewall fallacy or that developers have just become used to developing with admin privileges (ha! fooled you with that link!).  I have tried, in a security-conscious way, to move my web applications to a semi-trusted security model.  Since I use SQL Server and a separate dll for data, it's not too bad.  But I realize that users of other databases have more issues, and certain requirements dictate less stringent security needs.

    As a side note (or maybe I'm just late to the party), but finally there is an OPML file for GotDotNet blogs.

  • How to make your customers' customers happy

    "Make your customers' customers happy."  This is one of those big hand-wavy statements that big consulting firms spew out at $250 per hour, or big research firms spew out at $10,000 per report, but nobody knows what it really means.  So, entirely for free, I'm going to show you how to apply this statement in practice.

    On a recent project, my team was helping our customer, a health services company (our clients actually make money, which is why we are still in business right now), create a report that they would sell to their customers.  It is a good idea to actually help your customers make money.  If you help bring in millions of dollars you are less likely to get the ax when times are tight.  If you only help your customers with "strategic reports" on the state of their industry, Joe Middle-manager is gonna save the company millions by getting rid of you.  But I digress.

    Now, we work in an agile manner, i.e. in close collaboration with our customer.  We send emails and have weekly meetings regarding requirements clarification (if you had seen the requirements, you would realize that calling it clarification is being generous) and pre-delivery customer acceptance testing.  The standard is for a one-business-day turnaround on business decisions.  Sometimes, however, our customer cannot do this since he is asking his customers.  And it is generally considered bad form to tell people that are giving you money to please hurry the heck up!

    The amount of the application subject to these delays is small, no more than 5 percent of the application.  By luck, these parts were also able to withstand late-breaking requirements changes and still be ready on time.  This has made our customer quite happy. 

    The lesson to draw from this is not to treat all requirements as needing the same amount of flexibility.  Parts of the application that are more subject to change (from customers one level removed, for example) should have extra flexibility designed into them (we will definitely be doing this in the future).  Now I know this flies in the face of YAGNI, but I have to side with the Pragmatic Programmers on this one.  If you know that the application might be modified in a few small areas, then take the small amount of time up front to make sure your design is flexible enough to accommodate the change.  Your customers' customers will appreciate it, which will eventually make its way back to you in the form of bigger and juicier contracts.

  • Shirky on Micropayments

    Clay Shirky, with his usual insight, talks about the trend toward free content and how the latest micropayment service, BitPass, will fail just like all the rest.  About all of us bloggers he writes:

    Weblogs, in particular, represent a huge victory for voluntarily subsidized content. The weblog world is driven by a million creative people, driven to get the word out, willing to donate their work, and unhampered by the costs of xeroxing, ink, or postage. Given the choice of fame vs fortune, many people will prefer a large audience and no user fees to a small audience and tiny user fees. This is not to say that creators cannot be paid for their work, merely that mandatory user fees are far less effective than voluntary donations, sponsorship, or advertising.

    It is interesting to note that micropayments were once hyped by usability guru Jakob Nielsen.  I never agreed with them.  In my personal opinion (and in Shirky's essay), why pay for something when you can get it free elsewhere?  There are many direct substitutes for content.

  • All TechEd 2003 Material available online!

    You can get access to all of the material from TechEd 2003.  Not just PowerPoints, but also an audio recording of the live session with the PowerPoint presentation in sync!  Very cool.  [via Peter Provost]

More Posts Next page »