Bookmarks for September 3rd

  • Shalla Secure Services - "Shalla's Blacklists is a collection of URL lists grouped into several categories intended for the usage with URL filters like SquidGuard or Dansguardian. But the usage is not limited to this. Some people use the lists to include them (that is parts of them) into their Squid installation without using a redirector or other webfilters or use them for their IPCop installation. "
  • Squid whitelist and blacklist (controlled kid browsing) | Screaming Penguin - "A simple tutorial or explanation of setting up Squid so that multiple users are present via an auth mechanism, and some are limited to a whitelist (kids), and others have either all access (or optionally whatever limited access you want, different whitelist, blacklist, etc). "
  • SCons: A software construction tool - "SCons is an Open Source software construction tool—that is, a next-generation build tool. Think of SCons as an improved, cross-platform substitute for the classic Make utility with integrated functionality similar to autoconf/automake and compiler caches such as ccache. In short, SCons is an easier, more reliable and faster way to build software. "

Related posts

Tagged with: , , , , , , , , , , , , , , , , , ,

Bookmarks for August 21st through August 22nd

Related posts

Tagged with: , , , , , , , , , , , , , , , , , , , , ,

Vacation Learning - PHP and Smarty Templates

I’m on vacation this week and next week. Since I rarely have time to learn anything technical (or blog for that matter anymore), I thought I would take some time during my time off to learn something new around development.

We have a system at work that is essentially a small portal. The core of it was written by me to learn PHP about 8 years ago and has been augmented by me and one other guy at workKeith and I over the years. Over that time, as we added new functionality to it, I used it to experiment with other languages as I was learning it. Other pieces were written in Java out of convenience. In total, we have pieces written in PHP, Java, Python, and PERL.

As I usually use this system to learn new things, I figured it would be a good candidate to use to learn how to use the Smarty templating system for PHP. I became interested in this templating system after working with Eventum over the last few weeks and figured that if I am going to do further work with Eventum, it would be helpful to understand the templating framework it uses.

So I’ve started using the system to take our 8 year old PHP code base and separate some of the presentation logic out. Smarty is pretty flexible and easy to use at a high level (I haven’t gotten into any of the really advanced stuff yet).

Here’s an example of how nicely the use of a templating system simplifies your code. Take this example, which enumerated entries from our internal wiki via an RSS feed into a section on the home page:


function getWikiEntries($url) {
   $theHTML = "";

   $rss = fetch_rss($url);

   $theHTML .=  "<table cellpadding="0" cellspacing="0" align="center"><tr>";
   $theHTML .=  "<th CLASS="header-title" colspan="2">";

   # get the channel title and link properties off of the rss object
   #
   $title = "Recent Wiki Entries";
   $link = $rss->channel['link'];

   #$theHTML .= "<a href=$link>$title</a>";
   $theHTML .= "$title&nbsp;&nbsp;&nbsp;<a href="$url"><img border="0" src="" . APP_URL . "/images/rss.png"/></a>";
   $theHTML .=  "</th></tr><tr><td colspan="2" class="modifications-sectionheader">&nbsp;</td></tr>";
   
   # foreach over each item in the array.
   # displaying simple links

   $rowCount = 0;
   $className = "modifications-evenrow";
   
   foreach ($rss->items as $item ) {

      if (($rowCount % 2) == 0) {
        $theHTML .= "<tr CLASS="$className">";
      }
      $theHTML .= "<td CLASS="modifications-data">";
      $theHTML .= "<a href="$item[link]" title="" . $item['title'] . "">";

        # truncate item title to 28 characters 
        $myTitle = $item['title'];

        if (strlen($myTitle) > 28 ) {
            $myTitle = substr($myTitle, 0, 28) . " ...";
       }

      $theHTML .= $myTitle;
      if (($rowCount % 2) == 0) {
          $theHTML .= "</a>&nbsp;&nbsp;</td>";
      } else {
          $theHTML .= "</tr>";
      }
      $rowCount++;
   
      if ($rowCount == 20):
         break;
      endif;
   }
   
   $theHTML .= "</table>";
   
   return($theHTML);
}

I’m sure you can appreciate how hard this would be to maintain, and all of the cruft that has accumulated over the years …

Now take the simplified version (sans error checking), written today in about 10 minutes:



function getWikiEntries($url) {
   $rss = fetch_rss($url);

   $template = new TemplateEngine();
   
   $firstComµçVÖâÒ'&•÷6Æ–6R‚G'72Óæ—FV×2“°Ð¢G6V6öæD6öÇVÖãÒ'&•÷6Æ–6R‚G'72Óæ—FV×2“°Ð¢ТGFVׯFRÓæ76–vâ‚&f—'7D6öÇVÖâ"ÂFf—'7D6öÇVÖ⓰ТGFVׯFRÓæ76–vâ‚'6V6öæD6öÛ^umn", $secondColumn);
   $template->assign("link", $rss->channel['link']);
   
   return($template->renderString("wikiEntries.tpl"));   
}

… along with its corresponding Smarty template:


<table width="80%" cellpadding="0" cellspacing="0" align="center">
<tr><th class="header-title" colspan="2">Recent Wiki Entries&nbsp;&nbsp; 
       <a href="{$link}"><img border="0"  src="{$applicationURL}/images/rss.png"/></a></th>
</tr>
<tr><td colspan="2" class="modifications-sectionheader">&nbsp;</td></tr>

{section name="entries" loop="$firstColumn"}
    <tr>
    <td class="modifications-data">
    <a href="{$firstComµçVÖå¶VçG&–W5ÒæÆ–æ·Ò"F—FÆSÒ'²Ff—'7D6öÇVÖå¶VçG&–W5ÒçF—FÆWÒ#ç²Ff—'7D6öÇVÖå¶VçG&–W5ÒçF—FÆWÇG'Væ6FS£#ƒ¢"âââ'ÓÂöâfæ'7²fæ'7°Ð¢Â÷FCàТÇFB6Æ73Ò&ÖöF–f–6F–öç2ÖFF#àТÆ‡&VcÒ'²G6V6öæD6öÇVÖå¶VçG&–W5ÒæÆ–æ·Ò"F—FÆSÒ'²G6V6öæD6öÛ^umn[entries].title}">{$secondColumn[entries].title}</a>
    </td></tr>
{/section}
</table>

I don’t know about you, but I think thats quite a difference in maintainability. I’d much rather modify the html in the template than in the original function. Not only that, but the code is actually code, not a bunch of code with a lot of simply horrid markup stuck in the middle of everything.

I’m pretty impressed with how much I’ve been able to use in a short amount of time this week. The libraries are obviously thought out and ramp up time for me was really minimal. I like libraries like that. It also addresses something that has annoyed me for a long time. Embedded HTML is a pain to maintain and I’ve dreaded going into this over the years just because of that.

At some point, I’ll investigate what it takes to write custom plugins, a functionality that the libraries also support.

I think I’ve been able to get a really good start at getting something maintainable. My goal over the next few of weeks is to templatize the whole system, then start taking the non-PHP pieces of the system and rewrite them in PHP. I’ll also add the ability to change configuration in one place, so that we can cut some of the pain that we have in keeping things maintained down - and perhaps be able to install the application in other places.

Should be fun. I’m definitely feeling productive over the past few days. I’ve always liked working in PHP over other languages. I definitely have to do work like this more often.

Related posts

Tagged with: , , ,

Video: How Open Source Projects Survive Poisonous People (And You Can Too)

Since getting a 80G iPod about a month ago two weeks ago, I’ve been really getting into watching the Google Tech Talks on Google Video. I recently watched How Open Source Projects Survive Poisonous People (And You Can Too), a lecture given by Brian Fitzpatrick and Ben Collins-Sussman from the Subversion team (now both Google employees) that summarizes a lot of information in Karl Fogels book Producing Open Source Software: How to Run a Successful Free Software Project.

If you haven’t had time to pick up and read Karls book, this video would be a good primer to some of the concepts in it and could very well motivate you to pick it up. Its an excellent book and one that I thoroughly enjoyed reading.

Related posts

Tagged with: , , , , ,

Jon Udell Screening Room Screencast on IronPython

Episode 8 of Jon Udell’s The Screening Room features Jim Hugunin, creator of Jython and now IronPython, a .NET implementation of Python. For Python fans, this is a fascinating screen-cast to watch. They’ve done some great work on IronPython, which just hit its 1.0 release this week.

Some of the cool things I liked about what I saw:

  • Integration of the Python language with the Visual Studio IDE (including the Debugger)
  • Full access to the .NET framework (The Avalon demo was cool)
  • Optional integration of CLR methods into Python objects (String.Trim() vs. String.strip())
  • The PowerShell demo was also pretty cool
  • In the early part of the screen-cast, Jim takes a benchmark program and increases performance of the program dramatically by refactoring one function into C#. Shows off the optimization opportunities possible with the platform, along with the great integration between IronPython and other .NET languages

IronPython looks like a really fun thing to start playing with and could be a really great addition to a Windows development group for prototyping. I am a big fan of dynamic languages and think this is a great addition to the .NET tool set.

Related posts

Tagged with: , , , ,

Interview with Dave Thomas on Agile

I found a really good podcast called The Agile Toolkit Podcast, in which the host, Bob Payne, attends agile conferences and interviews people there. Some of the interviews include people like Bob Martin and Mary Poppendieck among many others.

The most interesting show I’ve listened to so far is an interview with Dave Thomas (of Pragmatic Programmer fame) about agile development.

For me, I think I found it interesting just in the fact that it is nice to hear someone that has the same views on development issues as I do. I’ve always been a big believer that methodologies are limiting and that each methodology should be tailored to the project team. One part of the conversation that I found extremely interesting was when Bob and Dave were talking about the dogma attached to many of the methodologies.

Recently I had attended an Agile Development training in which the instructor stated that if you weren’t using all of the components of XP, you weren’t doing Agile development. A good point that Dave made was that as XP was being developed, the teams it was being developed with actually evolved into using all of the practices at different stages of their team development. In other words, they didn’t start using all of the practices specified in XP - because they didn’t exist yet. Dave makes the point that teams need to evolve into all of the practices - and that its very difficult to implement all of them at one time. I actually think that each team will be sufficiently different enough that you may not need all of the practices, but only a core set of practices. Bob Martin also makes this point in his interview and lists the minimum set of practices that include very short cycles, an open office (a room which holds the identity of the project), test driven development (both unit and acceptance tests). He also mentions that its extremely difficult to do test driven development without continuous integration, so there are other practices that will be necessary as you begin to implement the minimum set. I actually believe that source control and automated builds are another of the core minimum practices that should be put in place before anything else - but thats just me.

Another area that Bob and Dave talk about extensively is the necessity of developers to look at other languages in the industry other than the core language they use day to day. One statement Dave makes is that he looks forward to the day that developers refer to themselves as “developers” rather than “Java developers”. I wholeheartedly look forward to that day as well.

I’ve always enjoyed learning new languages. If you run through the articles in this blog, you’ll see that every time I find some language that I don’t know - and understand the practical reasons why they exist, the chances are I start working in it right away (most recently, this language is Objective-C). I enjoyed this part of the conversation a lot, because Dave articulates very well how learning new languages can give you new insights as to how to implement things in different ways.

I’m a firm believer that in software development, you have to have a pretty large tool box. The right tool should be used for the right job. This is why in many of the things I’ve done over the years, different components are written in different languages depending on what I am doing. A web piece might be written in PHP, scripts done in PERL or Python, while other components could be written in C / C++. I’ve made a conscious effort over the years to expose myself to as many different languages as possible.

In order to have the flexibility to use the right tool for the right job, you really have to make an effort to get at least a high level understanding of the different tools available and what their strengths are. Thats the really nice thing about the conversation with Dave is that he articulates the idea that you don’t necessarily have to be an expert in all languages, but know enough to use them and glean knowledge from them and their design.

I have found each of the shows I’ve listened to from the Agile Toolkit Podcast very informative and totally worth the time investment. In the very least, I want my teams to make this a part of their learning program moving forward. There’s no better place to learn about Agile practices than from the people right in the middle of it.

Related posts

Tagged with: , , ,

New Things To Learn!

Learning Objective C

One of the really nice things about switching platforms is the plethora of new things one now has the capability to learn that you might not have found a reason to learn before.

I’m a stickler on having something practical to do when learning something. If I don’t have a real thing to shoot for when learning a language, its pretty much a guarantee that I won’t be able to learn it.

The conversion to the Mac platform, the availability of the development tools through the Apple Developer site, and some time spent reading iCon Steve Jobs: The Greatest Second Act in the History of Business has given me a lot of motivation to dig down and learn Objective C.

Free tools have been around for Objective C programming for quite a long time. The GCC compiler has supported Objective C as far back as I could remember. But frankly, I saw no reason to learn it when I had all of these scripting languages available and most of my Unix work has been either web based, or command line driven tools.

However, the last three or four weeks sitting with the Mac and working within the Mac UI has gotten my curiousity peaked on this odd little language that really gets no visibility until a few guys from NeXT choose it as the basis of their development tools. I really want first hand experience to understand why the guys at NeXT chose this language as the basis of their platform.

Now, I’ve done a lot of C and C++ programming in the past, so one might think that learning Objective C would be no big deal. I have to tell you, I’m struggling a bit. One thing I do think is pretty cool is the dynamic nature of the language. To me, it seems very Python / Ruby - ish in that respect. However, its a lot to learn and I’m really going to have to spend some quality time with some books to get familiar with the concepts. Its very different than C++.

I’ve got three books on order from Amazon: Programming in Objective-C, Learning Cocoa with Objective-C, 2nd Edition, and Building Cocoa Applications : A Step by Step Guide. Unfortunately, I received #2 before #1, and #1 is definitely the book I need first.

I think its pretty cool that I have the excuse to learn something completely different. The past four weeks on a new platform has been interesting to me. Its really like starting all over again with a whole new world available to me — which is what attracted me to this field in the first place.

Objective C Resources

Related posts

Tagged with: , , ,

List of Languages I have coded in …

Tom the Architect’s latest posting details a list of languages he has coded in. I thought this would be a pretty interesting exercise, so thought I would throw one together as well:

  1. BASIC (quite a few flavors from old school CP/M up to Windows)
  2. xBase
  3. DataFlex
  4. C
  5. C++
  6. x86 Assembler (light, but still counting it)
  7. Pascal (Turbo / Quick)
  8. Unix Shell (BASH. KSH, etc)
  9. Java
  10. JavaScript (light, but I think it still counts)
  11. Perl
  12. Python
  13. PHP
  14. Ruby

You know what? That wasn’t a very interesting exercise. Thanks a lot Tom …

Related posts

Tagged with: ,

Ruby on Rails - WOW

Over the last couple of weeks I decided to re-familiarize myself with the Ruby programming language. I was first introduced to it back in 2002-2003 at OOPSLA (or was it the Software Development Conference?) when I took a full day workshop with the Pragmatic Programmers, Dave Thomas and Andy Hunt.

Back then I loved the language, but decided not to focus on it since the support in the form of libraries just weren’t there like they were for Python at the time. I wrote a few programs in Ruby, but left it to the side and focused on Python.

Well, those days are over. When I started with Ruby, I decided to take a look at Ruby on Rails as well. Over the last couple of weeks all of my spare time has been focused on learning the Ruby language and this completely awesome framework, even at the expense of regular podcasts.

First off, I’m absolutely enamoured by the language. So much so that with Rails piled onto it I couldn’t imagine programming in any other language. For quite a while I’ve hated Java and the complexity that it brings to projects. There’s just too much work involved in doing Java development anymore.

Ruby combines complete object orientation with the flexibility of a scripting language. Some of the features it has baked into it, such as iterators and blocks make life so much easier.

Now pile Rails on top of it. Rails is an elegant MVC framework written in the Ruby Language by the folks over at 37 signals. These two things combined make for the perfect programming environment for web applications.

I’m still on the steep end of the learning curve. I’ve got the Programming Ruby : The Pragmatic Programmers’ Guide and Agile Web Development with Rails : A Pragmatic Guide (The Facets of Ruby Series) constantly at my side as I pull my hair out trying to learn all of this stuff.

But the cool thing is, even with my unfamiliarity with the language I’m still productive. If that isn’t the sign of a great development environment, I don’t know what is.

I’m working diligently to become proficient in the language. Rails is a little complex and I’m still struggling to learn all of the conventions. However, I think most of my programming moving forward will be with these tools. Its just a lot easier to spend time thinking about the problems you are trying to solve and being able to express them eloquently rather than struggling with the complexity and code/compile/run process baked into Java development.

Related posts

Tagged with: , , ,

  • OnLamp had an excellent article yesterday called What Corporate Projects Should Learn from Open Source. The articles pretty long, but well worth the read. While there are obvious differences in the two types of projects (like budgets and deadlines), I still believe that corporations can move closer to the OSS model of development and get major productivity increases. Comments Off
  • I found a reference to this on Slashdot - BusinessWeek has a really good article describing the goofiness that is the U.S. patent system. Comments Off

Build Google and Yahoo Maps Without Coding

I stumbled across MapBuilder as I was browsing the Google Code site today. MapBuilder was referenced as one of the sites featured projects. The application is pretty interesting, allowing you to visually create a map using either the Yahoo Maps or Google Maps API and then to export the source code for inclusion on your web site. There is also an option to host your maps directly on MapBuilder and reference them from your site with a button that links to a list of all of your available maps.

There are quite a few things that are really cool about the site:

  1. Supports both Yahoo! Maps and Google Maps.
  2. No need to learn the details of the mapping API’s - just create your maps and go.
  3. MapBuilder does geo-coding, using the Yahoo! Geocode API’sand geocoder.us while Google Map API’s require lattitude and longitude in order to do anything with them.
  4. MapBuilder does the “driving directions to / from here” for you. No need to create custom code for this functionality.
  5. MapBuilder will also do custom development for you if you want something different from what the basic services provide. I’m assuming there is a fee involved, but I couldn’t find reference to it.
  6. The site facilitates building communities around maps that people create on the site.
  7. Best of all, it allows the “common man” to include mapping capabilities on their web sites without having to know how to code in Javascript and HTML.

MapBuilder is a really good example of new, unintended possibilities that are exposed when web applications are designed as a set of API’s using the web as a development platform rather than the siloed approach that we have used historically. This application was written by a third party not affiliated at all with Google or Yahoo!, but because of the way their applications were written they have the possibility of an audience that they did not originally target by allowing someone to build applications around their base functionality.

One should note that creation of a user account is required in order to use the full functionality of the MapBuilder site. They basically ask you for a username, password, and your email address. Thats it. Registration for either a Google Maps API key or Yahoo! Maps API key is also required if you would like to host your map on your own web site rather than hosting it on MapBuilder directly.

Related posts

Tagged with: , , ,

“Prioritizing Design Decisions”

"Prioritizing Design Decisions"

Photo by cote

From Apple’s Apple Human Interface Guidelines, Appendix B.

I found this diagram on Coté’s Flickr account and liked it, mainly because we have been trying to explain the idea of minimum requirements vs User Expectations (both of which are required before you can get to the differentiation). There is no short-changing the bottom two pieces of this triangle.

Related posts

Tagged with:

Too Much Object Orientation?

Ed Gibbs has an article entitled Spaghetti OOs Code in which he talks about a conversation he had with his brother about “too many objects” vs. more “meaty” objects and it reminded me of a position I was in once, and hopefully a lesson that makes sense.

I’ve always ahered to the idea to have enough objects to get things done in an understandable way, without having 4000 objects to keep track of in order to get something done. I’ve seen many applications written where there are several layers of indirection that you have to traverse in order to figure out whats going on, as you have objects that perform certain actions on other objects such as rendering its contents as HTML or XML. These would all be great if they worked on a base class of the actual object being rendered, however they work on specific derivitives, requiring a reimplementation of a rendering object for each specialization of the original object.

Here’s an example. I worked at a place once that had a general rule (big red flag here) that each piece of functionality had to be made up of four separate components:

DA (Data Access)
This object was responsible for retrieving data from a database or other data source.

BO (Business Object)
This object was normally a result of retrieving data through the DA object and represented a business object.

BS (Business Service)
This object was responsible for performing services related to the BO.

BA (Business Access Object?)
I know we had something called a BA, but I can’t remember what it was used for (second red flag). However, it was a required component.

These components had no base classes or framework around them (third red flag), they were just required components that had to be used. Now, for some, this doesn’t seem like a big deal, but try writing some simple code that renders a pulldown in HTML off of a database query and then multiply that work by 10 and you’ll see where this becomes problematic. No framework in place, but all objects were required.

When I first came on, I had to write code that rendered a pulldown box in HTML and I wrote something like the following (Editors note: This was written to illustrate a point and most likely will not execute - its been a while since I’ve written Java):


/** 
 * Yes, this should or could have been an interface.   I was a beginning java programmer at the time, coming from C++ - so
 * this made much more sense to me at the time!
 */
public abstract class PulldownData {
   /**
    * Generate a hash table from a query in which the keys are the select values and the values are the descriptions to appear
    * in the pulldown
    */
   public abstract Hashtable getData();
}

public class PulldownRenderer {
   public String renderData(String name, PulldownData dataObject) {
      StringBuffer strHTML = new StringBuffer();
      String keyName = null;
      String itemDescription = null;

      if (dataObject != null)  {    /* still have arguments whether this is necessary in Java */
         strHTML.append("<select name="" + name + "">n");

         for (Enumeration e = dataObject.keys() ; e.hasMoreElements() ; ) {
            keyName = e.nextElement();   
            
            if (keyName != null) {
               itemDescription = dataObject.get(keyName);
               
               strHTML.append("<option value=""+ keyName + "">" + itemDescription + "</option>n");
            }
         }

         strHTML.append("</select>");
      }
   }
   return(strHTML.toString());
}

Once this framework was completed, all you had to do to create a new combo box was to derive a new class from the PulldownData object and pass this object to an instance of the PulldownRenderer class and voila! You had a pulldown!

Despite the decrease in actual work involved, I actually spent quite a bit of time arguing why this was a better approach than having four tightly coupled objects that could not be reused to render my combo box with an “architect” that was on staff at the time. I had violated the “general rule” and written something simple and useable.

All of this was written just to illustrate a point. The simpler the better. If you are decomposing things into 500 objects because “thats the way we do it” or “everything else here is written that way”, you are doing it for the wrong reasons. There has to be a reason to decompose things to a level that makes sense for the person coming after you, or the people you are working with. Object orientation has the ability to make your job a hell of a lot easier, but its a two edged sword. It can also make your life extremely difficult if you ignore the KISS principle and abstract for the sake of abstraction.

Related posts

Tagged with:

  • Joel Spolsky of Joel on Software fame has announced the completion of the movie Aardvark’d: 12 Weeks with Geeks, a documentary chronicling the development of a software product called Aardvark. DVD preorders are being taken now for a ship date of December 1. The trailer is available on the project page and I have to say, it looks really cool from a geeks point of view. I think I’ll be preordering this one. Comments Off

Coté : Make the Iteration Fit the Deliverable, and Other Thoughts on Becoming Agile

Coté from the DrunkandRetired podcast has written a very good article called Make the Iteration Fit the Deliverable, and Other Thoughts on Becoming Agile.

Key points I took away are:

  • Agile development doesn’t mean planning less; as a matter of fact, it takes more planning
  • Planning should happen as part of the team not apart from it.
  • There is no fixed iteration size. You should plan your iteration size based on what you are doing.
  • Two week iterations require a pipeline of planning in order to work effectively. This pipline is normally not present unless your organization has reached a level of maturity
  • Agile development doesn’t mean throwing away design

In my mind, one of the misconceptions that people have when switching to any methodology is that there are a set of rules and procedures you must follow in order to be “doing the methodology”. I don’t think this is the case. The great thing about agile development is being able to adapt to the situation rather than be “stuck” having to follow a set of steps no matter what.

When I think about this idea, the quote from Bruce Lee about Jeet-Kune-Do, his martial art, always comes to mind:

Absorb what is useful, reject what is useless, and add what is specifically your own.

Bruce Lee was annoyed with traditional martial arts because it had “too much form”. The martial artist was unable to adapt to the unexpected. Rather he was limited by the forms he used while learning. (Before any martial artists start posting comments - this was Bruce Lee’s philosophy - not mine). Lee thought that the martial artist, given a set of tools, should be able to react naturally rather than having to think before responding.

I view development “methodologies” in the same way.

Things are going to happen. We have to be able to respond to them in order to be effective, and not get caught up in “how” we get things done. This to me is the power of the “philosophy” of agile development. It has nothing to do with iteration size or any of the other “guidelines” in the methodology.

Shorter iterations, however, do not mean that we do not design or plan during the process. It doesn’t mean working randomly. It means that we should do what is necessary in order to plan, design, and execute - no more and no less.

I think it would be more useful to explain Agile development as a philosophy in this way rather than a set of “methodologies”. People get caught up in “doing the methodology” rather than executing what they have set out to do. I have seen this time and time again as people try to change the way they do things. Agile development methodologies provide a set of tools, like TDD and the idea of iterations. Its up to you and the needs of the project to decide which tools are appropriate to get the work done.

Anyway, I digress. Coté has obviously set off a whole train of thought in my head this morning with this article. Perhaps it will do the same for you.

Related posts

Tagged with: ,