Overview

Web development incorporates all areas of creating a Web site for the World Wide Web. This includes Web design (graphic design, XHTML, CSS, usability and semantics), programming, content management, marketing, testing and deployment. The term can also specifically be used to refer to the "back end", that is, programming and server administration.

ref: Wikipedia: Web Development

Lately I've been working on ‘Den’ and other things relating to the E programming language.

Interesting draft paper on the History of Haskell by Simon Peyton Jones, Phil Wadler, Paul Hudak, and John Hughes.

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

This paper is aimed at History of Programming Languages - HOPL III to be held in June 2007.

In 1978, the first History of Programming Language Conference (HOPL) described the development of 13 computer programming languages, the people who participated in that work, and the context in which it was undertaken. In 1993, HOPL-II contained 14 papers on the genesis and evolution of programming languages. It is time for HOPL-III, to be held with FCRC 2007 in San Diego. Each HOPL-III paper should detail the early history or evolution of a specific programming language. Preliminary ideas about each language should have been documented by 1996 and each language should have been in use by 1998.

A Core Calculus for Scala Type Checking, is a new paper by the Scala team.

Abstract. We present a minimal core calculus that captures interesting constructs of the Scala programming language: nested classes, abstract types, mixin composition, and path dependent types. We show that the problems of type assignment and subtyping in this calculus are decidable.

The paper revolves around the question of decidability of type checking in Scala. The following quote summarizes the background of this question.

Scala?s approach to component modeling is based on three programming language constructs: modular mixin composition, abstract type members, and explicit self-types. All three have been studied in the vObj calculus. A key concept of the vObj calculus, path-dependent types, is also present in Scala. However, some other constructions of vObj do not correspond to Scala language constructs. In particular, vObj has first-class classes which can be passed around as values, but Scala has not.
First-class classes were essential in establishing an encoding of F<: in vObj, which led to a proof of undecidability of vObj by reduction to the same property in F<:. However, since Scala lacks first-class classes, the undecidability result for the calculus does not imply that type checking for the programming language is undecidable.

Ehud: Given current interest in Scala and its more or less unique (don't want to raise controversy here) position as being both a functional and an OO language, furthermore being much more than a toy language, would it be a good idea to give Scala a place in the Spotlight section?

History of LISP (software collection committee) edited by Paul McJones. Abstract:

The goal of this project is to locate source code, design documents, and other materials concerning the original LISP I/1.5 system, and as many of its follow-ons as possible. LISP was one of the earliest high-level programming languages and introduced many ideas such as garbage collection, recursive functions, symbolic expressions, and dynamic type-checking. This is a pilot project of the Computer History Museum's Software Collection Committee to develop expertise in the collection, preservation, and presentation of historic software. Comments, suggestions, and donations of additional materials are greatly appreciated.

I ran across this page by accident while googling for 'lisp assembler lap' because I'd recently learned LAP was the standard acronym for lisp assembly program (ie a lisp based assember), which also described what I was currently trying to do. It's funny how often a new idea is just the Nth repetition of many old ideas. :-)

Anyway, this page links a wealth of interesting material on early Lisp implementations. (Unfortunately a number of the PDF documents don't open on my current machine, so I can't read several of the items I find most interesting, including everything L. Peter Deutsch authored.)

Peter Selinger. A brief survey of quantum programming languages.
In Proceedings of the 7th International Symposium on Functional and Logic Programming, Nara, Japan. Springer LNCS 2998, pp. 1-6, 2004.

A brief but useful survey of quantum programming languages (six pages), that I think wasn't mentioned here before.

Section 2.1 describes the common target hardware models (the quantum circuit model, QRAM, and quantum Turing Machines).

Section 2.2 is about imperative quantum languages (e.g., QCL), and section 2.3 discusses functional quantum languages.

Event-Based Programming without Inversion of Control. Philipp Haller and Martin Odersky.

Scala is different from other concurrent languages in that it contains no language support for concurrency beyond the standard thread model offered by the host environment. Instead of specialized language constructs we rely on Scala's general abstraction capabilities to define higher-level concurrency models. In such a way, we were able to define all essential operations of Erlang's actor-based process model in the Scala library.

However, since Scala is implemented on the Java VM, we inherited some of the deficiencies of the host environment when it comes to concurrency, namely low maximum number of threads and high context-switch overhead. In this paper we have shown how to turn this weakness into a strength. By defining a new event-based model for actors, we could increase dramatically their efficiency and scalability. At the same time, we kept to a large extent the programming model of thread-based actors, which would not have been possible if we had switched to a traditional event-based architecture, because the latter causes an inversion of control.

(There's not really a proper abstract. The above is from the conclusion.)

I enjoyed this paper. It's a quick read and a nice demonstration of some of Scala's cool features. It's also a good example of using exceptions as delimited control operators, and in fact the one substantial restriction is imposed by the lack of the more powerful operators. They use Scala's type system to reduce the burden of this restriction, however, since they're able to state that a particular statement never returns normally (and thus must not be followed by more statements).

Those interested in the language/library boundary will also find it interesting for this reason:

The techniques presented in this paper are a good showcase of the increased flexibility offered by library-based designs. It allowed us to quickly address problems with the previous thread-based actor model by developing a parallel class hierarchy for event-based actors. Today, the two approaches exist side by side. Thread-based actors are still useful since they allow returning from a receive operation. Event-based actors are more restrictive in the programming style they allow, but they are also more efficient.

They have some fairly impressive empirical scalability results as well.

Socially Responsive, Environmentally Friendly Logic
by Samson Abramsky

We consider the following questions: What kind of logic has a natural semantics in
multi-player (rather than 2-player) games? How can we express branching quantifiers, and
other partial-information constructs, with a properly compositional syntax and semantics?
We develop a logic in answer to these questions, with a formal semantics based on multiple
concurrent strategies, formalized as closure operators on Kahn-Plotkin concrete domains.
Partial information constraints are represented as co-closure operators. We address the
syntactic issues by treating syntactic constituents, including quantifiers, as arrows in a
category, with arities and co-arities. This enables a fully compositional account of a wide
range of features in a multi-agent, concurrent setting, including IF-style quantifiers.

This paper seems to unify multiple interesting directions - logic, game semantics, concurrent constraint programming (and concurrent programming in general).

At the same time it remains very accessible, without overwhelming amount of math, so can be hopefully useful not only for academics. I, for one, was waiting for exactly this kind of paper for two years (and my interest is very practical).

Multiplayer Curry-Howard correspondence, anyone? Or Curry-Howard for web services?

CLPython is an implementation of the Python programming language in Common Lisp. It is developed by Willem Broekema with support from Franz Inc. CLPython is released under the LLGPL.

You might enjoy browsing the source code.

Programming Languages and Lambda Calculi looks like a comprehensive treatement of the semantics of typed and untyped call-by-value programming languages. I imagine if one had a basic undergraduate education in programming language theory and wanted to get up to speeed in a hurry this would be a great resource.

Registration is now open for the 9th Annual ICFP Programming Contest. The ICFP contest is an event that traditionally raises interest in the LtU community.

A more detailed announcement found in the forum mentions that this year's theme is 'computational archaeolinguistics.' Intriguing.

Pluvo is a functional and imperative programming language intended to be highly practical for scripting and CGIs, interpreted using a just-in-time compiler. Its hybrid dynamic and strict typing is flexible enough to allow duck typing. Its functions are, more specifically, closures, and it allows object orientation using prototypes.

From Sean B. Palmer.

Knowing he's a big fan of Python I expected a fair bit of influence - and there is, in fact the implementation is written in Python. Flexibility over typing was to be expected too, Sean's done a lot of work around RDF. Slightly surprising was Pluvo's syntax, which owes more to Bash.

The first 10 Prolog Programming Contests took place in Ithaca (1994), Portland (1995), Bonn (1996), Leuven (1997), Manchester (1998), Las Cruces (1999), Paphos (2001), Copenhagen (2002), Mumbay (2003) and Saint-Malo (2004). The contest organisers have written this book, containing the (slightly reworked) questions and an answer (in Prolog of course) for each question... The book is now also freely downloadable on this page.

For your enjoyment...

Last night was our fourth hockey game of the season. We lost the first two, both by a single goal; the first one we really should have won, the second was just a hard-fought game. We won the third game, 7-1. To be honest I felt kind of bad about that one. You’d think it would be fun to have a game like that, but I always remember the times I was on the losing end of those games and it’s hard to enjoy it.

Anyway, like I said, last night was the fourth game of the season. We ended up coming back from a 2-0 deficit to tie it, but it felt like a win, the way we played. Our opponents were the best team in the league (same team that won the championship last season), so a tie isn?t bad at all (we can do better, though. ;)) After the game, our goalie stood up in front of everyone and announced that I had had a ?monster? game, my ?best game of the season, by far?, and that I was ?absolutely everywhere on the ice?. I think I blushed. :) Anyway, it was a really good game; I had lots of great defensive plays, stopping breakaways, cutting off passes, etc.

I did have one big fall, though, which everyone teased me about mercilessly. The captain said he was taking up a collection to have my skates sharpened. :) We had the puck in their zone, 2nd period, we were getting lots of good pressure. Curry, one of the forwards, got the puck at the left wing and saw me completely open at the blue line. He passed it to me, perfect pass, and right as he did my legs just shot out from under me. Nobody within 20?, a perfect pass, and I just BAM! fell down. What?s worse is that, as I was laying on the ice, the puck was coming straight towards me. I mean, STRAIGHT towards me. If I hadn?t moved it would have hit me right in the middle of my stick. Of course, like a total idiot I tried to lift my stick (as I?m laying flat on the ice) to take the pass with the blade, and the puck goes under the stick, under me, and out of the zone. Brilliant!

Anyway, like I said, I had a good game—almost had a goal. I had the puck all alone against 3 defenders, I faked past one, ended up right in the center of the ice with the 2 defenders in front of me. I seem to find myself in that situation about once a game, so I’ve been trying to make it work for me. My current move is to cut right just a bit to get the defender between me and the goalie, and then shoot the puck through the defender’s legs, so the goalie has trouble seeing the shot at first. This time, I?m pretty sure the shot hit the post on the far side, it was a really nice shot and I don?t think the goalie really saw it. Eventually one of those shots is going to go in, it just didn?t happen that game.

I’ve also noticed a number of Spoonerisms coming out of my mouth lately. After the game I wanted to talk about the fact that especially in the second period, it’s important to keep our shifts short so we don’t get tired and caught out of position (which is why we were down 2-0), only I said it was important to keep our “shorts shifted”. You can guess what kind of jokes were made at my expense at that point. ;) I actually really like this team. Everyone on it is always in a good mode, there’s teasing and camaraderie in the locker room. Jen says she approves of their teasing me all the time, and frankly I agree; it’s a really great group of guys and I’m glad to be a part of it. What’s even better is that I know other guys on nearly every team in the league (last nights’ opponents are pretty much the exception), so there’s always someone to say hi to or trash talk before the game. It’s a lot of fun, and it makes me wish I could play hockey every night. :)

Playing games without Jen in the audience is kind of weird. She’d only missed a few games before this season, and I was pretty used to looking up and seeing her in the second or third row, reading her book at period intermissions or cheering during play. I keep looking for her, and of course she’s not there. She’ll get to see my game this Saturday, though, so hopefully I’ll have another good game. :)

As far as work goes, it’s pretty busy right now. We have our second-most-major deadline of this entire release coming up, and everyone’s scrambling to get ready. I’m in the middle of a really frustrating problem (been working on it about 14 hours thus far, with no resolution). It doesn’t help that making brand new code work exactly like the old code did six months ago—which is what we’re doing—is one of the more tedious, uncreative jobs in programming. It has to be done, and it will be worth the effort at the end, but any programmer will tell you that solving new problems and writing new code is much more fun.

Aside from work and hockey I haven’t done much; I have a million things to do to the house that I just haven’t had the time to do, and we’re supposed to hang out with some friends for July 4th, but other than that my social life is essentially nonexistant. :) Sorry. No new baby news, either; we won’t know the sex for another 5 weeks, and that’s really the next big milestone. I’ve actually only told 3 people at work, partially because everyone who knows Jenny is pregnant seems to only talk to her about that sometimes, and I don’t want that to happen. Of course I’m also a pretty private person in general.

An update, at last! :-P

Anyway. Last weekend Jen and I went with some friends to see Over The Hedge. Jen and I both had qualms about seeing it; from the trailers, we both expected it to be not-very-good. We were wrong. It was said afterwards that it’s the best animated movie Dreamworks has made; better than Shrek, and while I don’t know that I’d necessarily give either the nudge myself, OTH is definitely a worthwhile viewing experience. The Grand Theft Auto sequence in particular is awesome, as is the movie version of Ben Folds’ “Rockin’ the Suburbs”. And stay through the credits—it’s worth it (partially because the end credits themselves are well-done and interesting), unlike the ending of X-Men 3.

I also watched the first part of Robots this week. Despite the program guide’s generous four star rating, I found it completely uncompelling and deleted it after about twenty minutes. I, Robot, on the other hand, was entertaining if not particularly thought-provoking. It’s Will Smith, what do you want? ;) Constantine was not terrible, for a comic-book movie. If I see it in the $5 bargain bin at Wal-Mart, I might pick it up. I’m a sucker for storylines involving an eternal war between Heaven and Hell with humans as proxy combatants, though. Tomorrow should result in Resident Evil: Apocalypse (which I had watched approximately half an hour of, while programming on a laptop in a client’s home at my previous job) as well as The Maltese Falcon (which I’ve never seen, but I like noir and Bogart, so…) and even more excitingly, the first episode of the new season of Deadwood. I’ve missed Al Swearengen’s poetical utterances, truly I have. I find it interesting that Robots was something I deliberately Tivoed, while I, Robot was a Tivo Suggestion—I submit to you that perhaps the Tivo knows me better than I know myself. Of course, it also recorded Prince William and Hide and Seek—so perhaps not, after all.

This week we also moved Jenny to College Station for the next two months, more or less. Which isn’t much fun. I have plenty to keep me busy, including lots of work stuff (enough that I worked for a few hours today, which is not usual for me at all) and yet more home improvement Activities™, but I am accustomed to intense Jeopardy duels, and it takes all the fun out of an entire category devoted to the Oz books (not the movie!) if Jen’s not here. :-P

Our parents banded together and gave us an anniversary present of a digital camcorder (for obvious reasons), so if I can manage to lay hands on a DV cassette sometime soon perhaps I will encourage the pets to do goofy things I can put on the site. Or something. I dunno. It seems like a wonderful piece of equipment, though; I can understand why people do things like this or this, when digital film technology is so accessible. I even know a few people who I’m sure would be happy to be extras in a Firefly fanfic… ;)

The hockey draft was this last week as well. One of the players from my spring team is a captain in the summer league, and had intended to try to keep the team together as much as possible. This is complicated by the fact that aside from himself, he only gets to “protect” a single player, and further by the fact that three of our players got drafted into the next league up (including my defensive partner, all unwitting). Still and all, it looks like the core is there, and it should be fun regardless. I got a little bit of an ego boost when I found out that apparently I was selected in either the third or fourth round of the draft, which seems fairly early for someone in their second season. Not that any OHL or NHL scouts are likely to be darkening my door anytime soon. And it’s only a small ego boost, as I can depend on Jenny for a realistic (by which I mean occasionally depressing ;)) appraisal of my “mad hockey skillz”, as it were.

This weekend’s project, aside from “entertaining the dogs” (via early morning trip to the dog park) and “dealing with crunch time” (viz., working today) is “cleaning the garage”. Anyone who has lived in a house with a garage for more than ten minutes knows precisely what I mean by that. :)

Last night I had a bout of insomnia, and ended up out on the hammock in the back yard at about 2am. It’s worth noting that, by 2am, the mosquitos appear to have quit for the day and, in June in Austin, the temperature is literally perfect. I almost slept out there, but it on further reflection I supposed that to be a bad idea and merely enjoyed it until I felt sleepy. :)

A final thought: reading the Baroque Cycle sure does turn me into a wordy son of a gun, doesn’t it?

Latest LINQ CTP released for download.

The list of goodies is here:

What?s new?

Enhanced DLinq Support: This CTP adds support for Inheritance, Stored Procedures, User-Defined Functions, and Optimistic Concurrency Conflict Resolution (OCCR).  The new DLinq Designer provides a visual design surface for creating DLinq entity classes from database tables.

LINQ over DataSet: The full power of LINQ can now be applied to the DataSet, allowing you to use the Standard Query Operators and some DataSet-specific extensions to query against DataRows.

?Group By? Query Comprehensions: The compiler now supports ?Group By? as a valid clause in LINQ Queries. 

Outlining support for XML Literals in the Editor: In this release, we added outlining support for XML literals. You can now expand or collapse any Xml element literal that spans across more than one line. 

Value extension property for XML axis properties: We added a Value extension property to the collections that are returned from the XML axis properties (i.e. IEnumerable(Of XElement) and IEnumerable(Of XAttribute)). This extension property does two things, it first picks up the first object in that IEnumerable, and if this object exists, it calls the 'Value' property on this object (either XElement or XAttribute). The following code show the use of this Value extension property:

       Dim contact = <Contact City='Seattle'>

                         <Name>Joe</Name>

                      </Contact>

        Console.WriteLine(contact.@City.Value)

        contact.@City.Value = 'Portland'

        Console.WriteLine(contact.@City.Value)

        Console.WriteLine(contact.<Name>.Value)

        contact.<Name>.Value = 'Sam'

        Console.WriteLine(contact.<Name>.Value)

 

        Results:       

                Seattle

                Portland

                Joe

                Sam

Global Xml namespace support: XML namespaces that are declared using the Imports statement can now be used in the XML literals. The following is an example:

Imports ns = 'http://www.w3.org/1999'

 

Module Module1

  Sub Main()

    Dim book = _

      <ns:Book>

              <ns:Title>Learning Programming Using VB</ns:Title>

             </ns:Book>

    Console.WriteLine(book.<ns:Title>.Value)

  End Sub

      End Module

What?s changed?

Select/From syntax: The previous tech preview supported using Select before From.  In an effort to provide better IntelliSense?, we?re switching to the From/Select format for this CTP.

Joins don?t require ?It?:  You don?t need to use the iterator variable ?it? anymore when performing a join operation, though it?s still required for grouping operations.

Xml axis properties syntax: The late bound Xml feature has a new name and a new distinct syntax where we wrap the element name with angle brackets. This new syntax makes the Xml axis properties visually distinct and solves problems that the previous CTP syntax had. See more information in this blog

Design and programming activity as a profession is better performed with mathematics and applied logic concepts as first-class tools in the hands (heads) of practitioners.

There are a significant number of factors to take care of in order to improve design and programming skills that last. Two of those are: essential mathematics and, first-order logic (also known as first-order predicate calculus). If you are serious about a design and programming career, you know that already.

This is another trait of the current youthful state of mainstream software development industry where many, many people delude themselves into thinking that formalism means tons and tons of paperwork or (not kidding) a dress code wearing mandatory suit and tie. Then, some of them will say: 'we are formal here'.

Regardless of what people are wearing, good and needed formalism in our industry is the kind of formalism related to useful software specifications, that is to say, class interface design and programming by contract.

In other words: 'Talent Mandatory, Suit Optional' as stated in Quinn Emanuel?s philosophy towards law.

Bertrand Meyer in his book, Object-Oriented Software Construction-2nd Edition, page 400, in a section entitled 'The expressive power of assertions' said:

'Including a full specification language into the language of this book would have completely changed its nature. The language is meant to be simple, easy to learn, applicable to all areas of software construction, and implementable efficiently (with a final run-time performance similar to that of Fortran and C, and a fast compilation process).

Instead, the assertion mechanism is an engineering tradeoff: it includes enough formal elements to have a substantial effect on software quality; but stops at the point of diminishing return ? the threshold beyond which the benefits of more formality might start being offset by the decrease of learnability, simplicity and efficiency.

Determining that threshold is clearly a matter of personal judgment. I have been surprised that, for the software community at large, the threshold has not moved since the first edition of this book. Our field needs more formality, but the profession has not realized it yet.'

Assertion-first design, also known as test-driven development represents a powerful and reasonable tool at the hands of more and more designers and programmers, hoping the level of mathematic formalism in software development increase in a positive way.

As part of the same preparation I really enjoyed to program a classic:

Which are the 92 solutions to the 8 queen problem?

First, the usage intentions and conditions of satisfaction:

    [TestMethod]    public void validSolutions()    {      List<ChessBoard> boards = ChessBoard.AllQueens();      foreach (ChessBoard b in boards)      {        IList all=b.Pieces;        Assert.IsTrue(all.Count == 8);        for (int k = 0; k < 8; k++)        {          IList l = b.Rank[k];          Assert.IsTrue(l.Count == 1);        }        foreach (char c in 'abcdefgh')        {          IList l = b.File[c];          Assert.IsTrue(l.Count == 1);        }      }    }    [TestMethod]    public void allSolutions()    {      List<ChessBoard> boards = ChessBoard.AllQueens();      Assert.AreEqual(92, boards.Count);    }

    public static List<ChessBoard> AllQueens()    {      ResultKeeper keeper = new ResultKeeper();      ChessBoard board = new ChessBoard();      board.OnNewSolution += new ChessBoard.OnNewSolutionHandler(keeper.OnNewSolution);      board.GetQueens();      return keeper.Results;    }

  class ResultKeeper  {    List<ChessBoard> results;    public ResultKeeper()    {      results = new List<ChessBoard>();    }    public void OnNewSolution(int count, ChessBoard board)    {      results.Add(board);    }    public List<ChessBoard> Results    {      get      {        return results;      }    }  }

  public class ChessBoard  {    private char[,] board;    private int hit_count;    public ChessBoard()    {      board  = new char[8, 8];      reset();    }    private ChessBoard(char[,] b)    {      board = b;    }    public delegate void OnNewSolutionHandler(int count,ChessBoard board);    public event OnNewSolutionHandler OnNewSolution;    public IList Pieces    {      get       {        ArrayList result = new ArrayList();        for (int k = 0; k < 8; ++k)          for(int j=0;j<8;++j)            if (board[k,j] == 'X')              result.Add(board[k,j]);        return result;      }    }    public FileLine File { get { return new FileLine(board); } }    public RankLine Rank { get { return new RankLine(board); } }    public char[,] InternalState    {      get { return board; }    }    public static List<ChessBoard> AllQueens()    {      ResultKeeper keeper = new ResultKeeper();      ChessBoard b = new ChessBoard();      b.OnNewSolution += new ChessBoard.OnNewSolutionHandler(keeper.OnNewSolution);      b.GetQueens();      return keeper.Results;    }    public void GetQueens()    {      find_safe_positions();    }    void reset()    {      for (int k = 0; k < 8; ++k)        for (int j = 0; j < 8; ++j)          board[k, j] = '-';    }    private void find_safe_positions()    {      int rank = 0;      find_safe_position(rank);    }    private bool find_safe_position(int rank)    {      for (int file = 0; file < 8; ++file)      {        if (is_safe(rank, file))        {          board[rank, file] = 'X';          if (rank == 7)          {            NewSolutionFound();            board[rank, file] = '-';            continue;          }          if (find_safe_position(rank + 1))            return true;          else            board[rank, file] = '-';        }      }      return false;    }    bool is_safe(int rank, int file)    {      bool safe = empty_rank(rank) && empty_file(file) && empty_cross(rank, file);      return safe;    }    bool empty_rank(int rank)    {      for (int k = 0; k < 8; ++k)        if (board[rank, k] == 'X')          return false;      return true;    }    bool empty_file(int file)    {      for (int k = 0; k < 8; ++k)        if (board[k, file] == 'X')          return false;      return true;    }    bool empty_cross(int rank, int file)    {      for (int k = rank, j = file; k >= 0 && j >= 0; --k, --j)        if (board[k, j] == 'X')          return false;      for (int k = rank, j = file; k < 8 && j < 8; ++k, ++j)        if (board[k, j] == 'X')          return false;      for (int k = rank, j = file; k < 8 && j >= 0; ++k, --j)        if (board[k, j] == 'X')          return false;      for (int k = rank, j = file; k >= 0 && j < 8; --k, ++j)        if (board[k, j] == 'X')          return false;      return true;    }    void NewSolutionFound()    {      ChessBoard b = new ChessBoard(board.Clone() as char[,]);      ++hit_count;      if (OnNewSolution != null)        OnNewSolution(hit_count, b);    }    public class FileLine    {      private char[,] board;      internal FileLine(char[,] b) { board = b; }      public IList this[char c]      {        get        {          ArrayList result = new ArrayList();          int j = (int)c - 97;          for (int k = 0; k < 8; ++k)            if (board[k, j] == 'X')              result.Add(board[k, j]);          return result;        }      }    }    public class RankLine    {      private char[,] board;      internal RankLine(char[,] b) { board = b; }      public IList this[int n]      {        get        {          ArrayList result = new ArrayList();          for (int k = 0; k < 8; ++k)            if (board[n, k] == 'X')              result.Add(board[n, k]);          return result;        }      }    }  }

In preparation to write some papers about software design techniques, I am planning to illustrate those techniques with a variety of examples. As part of the effort I will document my thoughts while doing reflective practicum, identifying and documenting patterns of thought while programming solutions to several kinds of problems; including implementation of simple algorithms like insertion sort, selection sort, bubble sort and more complex ones. By now, let?s see the code so far.

Consider the following main function:

#include <iostream>#include <vector>#include <iterator>using namespace std;void main(){  sort( sort_by_selection<vector<int> >() );  sort( sort_by_insertion<vector<int> >() );  sort( sort_by_bubble<vector<int> >()    );}

template<typename T>void sort(T sort_algorithm){  int v[]={100,80,70,70,60,50,40,40,20,10,-1,-2};  vector<int> V(v,v+sizeof(v)/sizeof(int));  ostream_iterator<int> out(cout,' ');  copy(V.begin(),V.end(),out);  sort_algorithm(V);  cout << endl;  copy(V.begin(),V.end(),out);  cout << endl;}

template<typename T>class sort_by_selection{public:  void operator()(T& v)  {    T::size_type length=v.size();    if(length<2) return;    for(int k=0;k<length;++k)    {      int min=k;      for(int j=k+1;j<length;++j)        if(v[j] < v[min])          min=j;      T::value_type t=v[k];      v[k]=v[min];      v[min]=t;    }  }};template<typename T>class sort_by_insertion{public:  void operator()(T& v)  {    T::size_type length=v.size();    for(int k=1;k<length;++k)    {      T::value_type key=v[k];      int j=k-1;      while(j>=0 && key < v[j])      {        v[j+1]=v[j];        --j;      }      v[j+1]=key;    }  }};template<typename T>class sort_by_bubble{public:  void operator()(T& v)  {    T::size_type length=v.size();    for(int k=0; k<length-1; ++k)    {      for(int j=length-1; j>k; --j)      {        if( v[j] < v[j-1] )        {          T::value_type t=v[j-1];          v[j-1]=v[j];          v[j]=t;        }      }    }  }};

If, and only if, MDA proponents articulate a new kind of general-purpose source code at a higher level of abstraction such as we never ever need to see again third generation programming languages source code.

If you need to see it again, then MDA is just CASE fallacy resurrected.

Very good article in IEEE Software January/Februry 2006 magazine:

Looking for Powerful Abstractions by Rebecca J. Wirfs-Brock

'Finding the right level of abstraction
takes practice and experimentation.
There are times when both concrete
classes and their common abstraction
add value to a design, and there are
times when they don?t. To find good
classes, experienced designers make
distinctions based on significant behavior
differences.'

There are words and phrases from experienced people in our industry of software design and programming that just feel right, it is like they are describing a higher level of truth I need to aspire.

Another example from How do we tell truths that might hurt?:

'Besides a mathematical inclination,
an exceptionally good mastery
of one's native tongue
is the most vital asset of
a competent programmer' -Edsger W. Dijkstra

That is a reason why these people are pillars of our trade.

Consistency, although taken for granted, smells like morning fresh something that smells good when fresh in the morning. 

I pretty much committed to buying a piano today. I've wanted one in the house since we had 2 kids.  I'm giddy with consumerism and a sunny melting snow Friday afternoon. Moving it 1 mile across town tomorow's challange.

Zwiki BugDay seemed to go well. First one, to boot! I was at work then had unexpected company so didn't contribute more than the usual wiki gnoming.

Some thoughts on WikiWords:  They are odd, but seem to extract an extra amount of mindshare (kind of like TLA's). Don't overuse them, but they have their place. When trying to name something, they seem to require effort, but when you're stuck in a meeting and topics and buzzwords are flying around reminding you that you haven't got a handle on them, they seem very easy to come up with. Write them down.  Look up or create a page. (I wonder if a wiki can serve like the blank pile of paper used in Getting Things Done)  My literary educated wife tells me we name things to feel in order to feel control over them. Makes sense. God told us to have dominion over the beasts and what-not and to name them. If knowing is half the battle, naming is the ....to be filled in later, along with links. Suggestions and thoughts, as always, welcome.    ...consistent naming is another matter.

Greetings Python world. You've grown since I last blogged in your direction. So much that when if I sit on a topic more than 3 days, you've got it spread throughout the land.  Jarno, doing well? Consistency factors keep me from adding to this fun driving analogy.  Although I still think Apple is following the Volkswagen history, analogically speaking.

Very fun thread on the Python Firework.

A few submissions from my history:

• COBOL: A fully automatic cap gun. Does it's job, quite understandable, pain to load, tedium makes it quickly uninteresting.
• Old School BASIC: Simple fountains. POKE them in the side to make it interesting, or gibberish and quite sporatic.
• dBase: Snap-Pops. Works fine. Sure, you can tie a bunch together to make a somewhat powerful app, kind of like putting them under a toilet seat (tee-hee), but it's sure a pain in the
• DOS Batch: Jumping jacks. Quick fix, tied together you should probably be ready to run, and expect a few duds.

Modern languages have already been covered....wait....there is one:

• XML: Static pictures drawn from colored fireworks. Pretty, looks way customizable, everyone likes it, but IT'S NOT A FIREWORK--there's no BANG, It's not a Language...sorry, got a bit carried away. Kinda like kids who wrote ANSI-Mations and claimed it was programming. Not something to rant about, but one does make mistakes.

I wish I could remember where I clicked this from, but I saved it due to this line:

The golden rule of programming has always been that clarity and correctness matter much more than the utmost speed. Very few people will argue with that. And yet do we really believe it? If we did, then 99% of all programs would be written in something like Python. - James Hague

Such is reality.  Now to learn how to build mental callousness to the reality of coded cleverness, grand organizational and pattern schemes pilfered with 3 line functions, all embodied in auto-typed documentation headers reading completely as 'Summary of ClassName'.

I can't buy a micro-sized economy car for fear of the 4 wheel-drive gargantuans zinging around central Wisconsin and into my family. But today, to spite them all, I drove my face-in-the-windshield speed-limit-cruising designed for simplicty 1973 Volkswagen Bus to work. :-)

'When a box-on-wheels is the basic need, a box-on-wheels is the perfect answer.' - Heinrich Nordhoff

The Observer Pattern in Python

I find that the best way to get a deep understanding of a programming concept is to code it up yourself.  Here's my take on the standard Observer Pattern.  I wanted to fully understand it, because I expect to need it shortly.  This also gave me the opportunity to learn about the handy-dandy weakref module.

This implementation is a bit different from the standard GoF one.  For one thing, I wanted a clean way for an Observer to be able to observe multiple Observables, while being able to easily know which Observable was sending it an update notification. That's why, when registering an Observer with an Observable, the Observer tells the Observable the name of the Observer's function to call for the update notification.

Another difference has to do with the methods that the Observer base class provides.  Now, strictly speaking from a Python perspective, the Observer base class is unnecessary.  Any class that provides a method with the right signature can be used as an Observer.  But when I was talking out this design in my head, I kept using phrases like 'The observer tells the observable that it is interested in it.'  This really seemed like an action performed by the Observer, so I wanted that behaviour in an Observer base class.

The last big difference has to do with the way an Observer subscribes and unsubscribes to update notification by an Observable.  The standard GoF implementation has the Observable class having 'attach' and 'detach' methods.  I have an 'attach' method (named addObserver), and a 'detach' method (named removeObserver).  But I'm also using weakref.WeakKeyDictionary as the way that an Observable keeps a list of its Observers.  This means that the fact that there's a reference to the Observer in the Observable does not keep the Observable alive if it goes out of scope or is deleted.  The weakref to the Observer will be automatically deleted from the Observable's list (I know, a dictionary is not a list.  I'm using the word 'list' here loosely.)  So, the 'removeObserver' method is not strictly needed; just delete an Observer, and it gets removed from the list kept by any Observable it subscribed to.

Here's the code.  It should go in a file named observer.py:

import weakref
import types

##
# The Observer Pattern in Python
#
# Design goals:
# 1. An Observer should be able to observe multiple Observables.
# 2. An Observer should be able to tell an Observable what kinds of
# events it is interested in observing.
# 3. When an Observer is deleted, all Observables that it is observing
# should be notified to remove that Observer.
# 4. When an Observer is notified of an event,
# it should be able to tell which Observable is calling it,
# and which event occured.
##

##
# The abstract Observable Class.
#

class Observable(object):
    
    def __init__(self):
        # A WeakKeyDictionary is one where, if the object used as the key
        # gets deleted, automatically removes that key from the
        # dictionary.  Thus, any Observers which get deleted will be
        # automatically removed from the observers dictionary, thus having
        # two effects:
        # We won't have references to zombie objects in the dictionary, and
        # We won't have zombie objects, because the reference in this
        # dictionary won't stay around, and so won't keep the deleted object
        # alive.
        self._observers = weakref.WeakKeyDictionary()

    ##
    # Add an observer to this Observable's notification list.
    # @param observer The Observer to add.
    # @param cbname The name (as a string) of the Observer's
    # method to call for an event notification, or None for the default
    # 'update' method.
    # @param events The events the Observer is interested in being
    # notified about.  None means all events.

    def addObserver(self, observer, cbname=None, events=None):
        if cbname is None:
            cbname = 'update'
        if events is not None and type(events) not in (types.TupleType, 
                types.ListType):
            events = (events,)
        self._observers[observer] = (cbname, events)

    ##
    # Remove an observer from this Observable's list of observers.
    # Note that this function is not strictly required, because when a
    # registered Observer is deleted, the weakref mechanism will cause
    # it to be removed from the notification list.
    # @param observer the Observer to remove.

    def removeObserver(self, observer):
        if observer in self._observers:
            del self._observers[observer]

    ##
    # Notify all currently-registered Observers.
    # Each observer must have an 'update' method, which should take
    # three parameters (in addition to self): the Observable, an event,
    # and a message.
    # This method will be
    # called if the event is one that the Observer is interested in,
    # or if event is 'None', or if the Observer is interested in all
    # events (it was registered with an event list of 'None').
    # @param event The event to notify the Observers about.  None
    # means no specific event.
    # @param msg A reference to any data object that should be passed
    # to the Observers, or None.

    def notifyObservers(self, event=None, msg=None):
        for observer, data in self._observers.items():
            #print 'data is', data
            cbname, events = data
            #print 'cbname is', cbname
            #print 'events is', events
            if events is None or event is None or event in events:
                cb = getattr(observer, cbname, None)
                if cb is None:
                    raise NotImplementedError, 'Observer has no %s method.' % 
                        cbname
                cb(self, event, msg)

##
# The abstract Observer Class
# This class is a mix-in to add Observable registration methods to
# a concrete Observer class.  It is not strictly required.
#

class Observer(object):

    ##
    # @param observable The Observable to observe.
    # @param The events this Observer is interested in being
    # notified about.  This should be a tuple or list of events.

    def __init__(self, observable=None, cbname=None, events=None):
        if (observable is not None):
            observable.addObserver(self, cbname, events)

    ##
    # Inform an Observable that you would like to be notified when
    # an interesting event occurs in the Observable.
    # @param observable The Observable this Observer would like
    # to observe.
    # @param cbname The name (as a string) of the Observer's
    # method to call for an event notification, or None for the default
    # 'update' method.
    # @param events A tuple or list of events this Observer would like
    # to be notified of by the Observer, or None if it would like to
    # be notified of all events.

    def subscribeToObservable(self, observable, cbname=None, events=None):
        assert observable is not None, 'Observable is None'
        observable.addObserver(self, cbname, events)

    ##
    # Inform an observable that this Observer is no longer interested in it.
    # Note that this function is not strictly required, because when a
    # registered Observer is deleted, the weakref mechanism will cause
    # it to be removed from the Observable's notification list.
    # Use this function when you want to unsubscribe an Observer
    # without deleting it.
    # @param observable The Observable that this Observer no longer wants
    # to observe.

    def unsubscribeToObservable(self, observable):
        assert observable is not None, 'Observable is None'
        observable.removeObserver(self)

Here's the code for the unit tests, which also serves as usage examples.  It should go in a file named test_observer.py:

#! /usr/bin/env python

import unittest
from observer import Observable, Observer

EVENT_FOO, EVENT_UPDATE = range(2)

class Stuff(Observable):

    def __init__(self):
        Observable.__init__(self)
        self._data = None

    def setData(self, data):
        self._data = data
        self.notifyObservers(None, data)

    def setDataWithUpdateEvent(self, data):
        self._data = data
        self.notifyObservers(EVENT_UPDATE, data)

    def setDataWithFooEvent(self, data):
        self._data = data
        self.notifyObservers(EVENT_FOO, data)

class StuffWatcher(Observer):

    def __init__(self, observable=None, cbname=None, events=None):
        Observer.__init__(self, observable, cbname, events)
        self._data = None
        self._updateData = None
        self._reportData = None

    def update(self, observable, event, msg):
        self._data = msg
        self._updateData = msg

    def report(self, observable, event, msg):
        self._data = msg
        self._reportData = msg

class TestCase_01_Observer(unittest.TestCase):

    def test_01_noMethod(self):
        observable = Stuff()
        observer1 = StuffWatcher(observable, 'foo')
        self.assertRaises(NotImplementedError, observable.setData, 10)

    def test_02_simple(self):

        observable = Stuff()
        observer1 = StuffWatcher(observable)
        observer2 = StuffWatcher(observable)
        self.assertEqual(len(observable._observers), 2)

        observable.setData(10)
        self.assertEqual(observer1._data, 10)
        self.assertEqual(observer2._data, 10)

        observable.setData(20)
        self.assertEqual(observer1._data, 20)
        self.assertEqual(observer2._data, 20)

        del observer1
        self.assertEqual(len(observable._observers), 1)

        observable.setData(30)
        self.assertEqual(observer2._data, 30)

        observer3 = StuffWatcher()
        self.assertEqual(len(observable._observers), 1)
        observer3.subscribeToObservable(observable)
        self.assertEqual(len(observable._observers), 2)
 
        observable.setData(40)
        self.assertEqual(observer2._data, 40)
        self.assertEqual(observer3._data, 40)

        del observer2
        self.assertEqual(len(observable._observers), 1)

        observable.setData(50)
        self.assertEqual(observer3._data, 50)

    def test_03_specificEvents(self):

        observable = Stuff()
        observer1 = StuffWatcher(observable, events=EVENT_UPDATE)
        observer2 = StuffWatcher(observable, events=EVENT_FOO)

        observable.setDataWithUpdateEvent(10)
        self.assertEqual(observer1._data, 10)
        self.assertEqual(observer2._data, None)

        observable = Stuff()
        observer1 = StuffWatcher(observable, events=(EVENT_UPDATE, EVENT_FOO))

        observable.setDataWithUpdateEvent(10)
        self.assertEqual(observer1._data, 10)

        observable.setDataWithFooEvent(20)
        self.assertEqual(observer1._data, 20)

    def test_03_multipleObservables(self):
        observable1 = Stuff()
        observable2 = Stuff()
        observer = StuffWatcher()

        observer.subscribeToObservable(observable1, 'update', EVENT_UPDATE)
        observer.subscribeToObservable(observable2, 'report', EVENT_FOO)
        self.assertEqual(len(observable1._observers), 1)
        self.assertEqual(len(observable2._observers), 1)

        observable1.setDataWithUpdateEvent(10)
        self.assertEqual(observer._data, 10)
        self.assertEqual(observer._updateData, 10)
        self.assertEqual(observer._reportData, None)

        observable1.setDataWithFooEvent(20)
        self.assertEqual(observer._data, 10)
        self.assertEqual(observer._updateData, 10)
        self.assertEqual(observer._reportData, None)

        observable2.setDataWithUpdateEvent(30)
        self.assertEqual(observer._data, 10)
        self.assertEqual(observer._updateData, 10)
        self.assertEqual(observer._reportData, None)

        observable2.setDataWithFooEvent(40)
        self.assertEqual(observer._data, 40)
        self.assertEqual(observer._updateData, 10)
        self.assertEqual(observer._reportData, 40)

if __name__ == '__main__':
    unittest.main()

A gracious reader in his comments noted that he wanted more New and Notables and I ensured him it was only for lack of  time, especially when your commute involves airplanes-). BTW, I know there are a whole lot more readers; please take a minute to give me some feedback (even if you have in person) so I can tailor this blog for you, the reader. NOTE: I have been getting feedback that the Longhorn Blogs mechanism is not working for people to give feedback because they must register, so I letting feedback to this email. This email is for feedback only and not for questions. BTW, this is all being posted from IE7 in Windows Vista 5270.

• I absolutely love Brian Marick's blog and every post in it. Brian is one of the giants of ourr Agile movement and especially as one of the co-creators of FIT. I highly recomend that you read his series, Working Yourself out of the Automated GUI Testing Tarpit, Parts 1-4
• Another blog discovery of mine is the Agile Management Blog, where again, I could recomend every single post, but especially notable for me is Estimation versus Analysis, and Is there room for professional estimating? Highly recomended!
• Speaking of great Agile blogs, Jim Shore is another giant in the Agile movement. It was my honor to have workedwith him closely for a 3 week Iteration in my group. He writes with authority and passion. Take a look at Cards, Table and Whiteboard: The Ultimate Planning Tool. To answer my reader's comment on Team System posts, we haven't (yet) find we needed or it was superior to Cards, Table and Whiteboard which puts all of our team's heads in the same game and is simple.
• Phil Chu of Technicat has published Seven Habits of Highly Effective Programmers.  [via Jim]
• Another great Agile poster is Jeremy Miller who has two nice pieces on Mock Objects: The Bottle Brush of TDD and Why and When to Use Mock Objects. We use Mock Objects to some degree in our project but we have found some confusion on them especially with people on the team not used to them.
• Scott Belleware on Failing Tests Meaningfully - TD Process and the Karate Kid
• Lest you think I am all about Process and Agile Management and no “tech“ -), I continue to profit from Clemens Vaster's master posts on Teaching Indigo to do REST/POX, now in Parts 4 and 5. Also see perhaps the best explanation ever of pieces of COM+/ES with the Jita Pool.
• Ok, I'm a bit tired of all the Ruby stuff from my best friends Brad, Peter and John and you too Steve. Indeed, you talk of nothing else Peter and Brad when I'm out west. I don't want to see another “Ruby is Cool“ post. We all know that. We know the advantages of dynamic languages in certain situations. What I want to hear instead Brad and John and this is a challenge to both of you my friends: tell me of a successful commercial software project that is being shipped with Ruby or better yet tell me how you personally use Ruby in your PAG and ObjectSharp deliverables. I want real projects not dreams and no this fictional one does not count-). I'm waiting-).
• Brandon LeBlanc, my Longhorn Blogs cohort on playing with Vista far too early-) has a nice post on IIS7. You should read Brandon's blog as he really digs into Vista.
• Speaking of Vista, I am continually adding to my post on what installs and works on Vista. So far its a good story with the exception of a certain control vendor-).
• My brilliant fiend Brian Noyes, has a lot of good stuff on his blog, two cited here; Interface-Based Programming example employing the Factory Pattern, and Slides and Demos from Boulder CO on WCF
• Adam Nathan's latest post reminds me of the immortal Pacino/Corleone line in Godfather III, “Just when I thought I was out, they drag meback in!,“ once again returning to the world of COM Interop, in Using COM Interop to Create a WPF Visualization for Windows Media Player. Also see XAML Playing Cards.
• Last, but not least, in the realm of the Architects, Stuart Kent on the Seven Stages of Models. As an Agile Architect, I subscribe to Agile Modeling as well as Software Factories and Code is Model. I don't want to produce useless UML “models“ that are nothing more than sketches, but real, live breathing models that are synomous with the CODE, ala DSM and Code is Model and only as NEEDED.