• Big Contact: Feed Player - Create My Shareable Podcast Player
  

  

  A Flash podcast player that you can instantly embed into your web site, blog or social network.

  Tags: podcast, player, mp3

He retired from Atlantic in 2001 and a few months later he went into the studio with an unknown young woman for his pals at Blue Note Records. The result was the Grammy-winning, multi-platinum debut by Norah Jones, COME AWAY WITH ME. And our song tonight is my favorite from that album, a cover of Hank Williams[base '] classic "Cold Cold Heart."

In honor of Arif[base ']s passing I have 2 brand new box sets called WILLIE NELSON[^] THE COMPLETE ATLANTIC SESSIONS. If you wanna play this game, be sure to include an e-mail address. Just send us your top 10 songs (could be "my top 10 songs of all time," "my top 10 songs by women singers," "my top 10 songs with a political message," "my top ten songs with an alto sax," "my top 10 songs from the 80[base ']s"[sigma] anything). Tomorrow morning I[base ']m going to look [OE]em all over and pick one and John[base ']s gonna look [OE]em all over and he[base ']ll pick one too. And the two winners are going to each get a box of Willie.

Enjoy Norah!

(guest blogged by Howie Klein)

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?

Simply put, flash memory will enable a revolution in improving computer performance in daily utilization scenarios. Your computer will boot up faster. It will launch applications significantly faster. (Hey, it will shutdown faster as well.)

The problem

To see why we will have this dramatic performance improvement, let's remember how harddisks work: whenever you have a mixture of random I/O requests, the actuator moves across different tracks to read/write the corresponding data. Switching tracks is a slow operation. For an average SATA drive, this is around 9 milliseconds. This might not seem much, but a few milliseconds per seek means that you can have at most a few hundred random I/Os per second. And this feels like light-years compared with the performance of other components in the system like RAM access speeds or even CPU frequency. So, just to give you an example, a random I/O with 4 KB requests and average of 4 ms seek time per request would mean around 1000/4 * 4 KB = 1 MB per second disk transfer rate. Pretty small, don't you think? Especially when you compare it with sequential I/O, where you can get a much faster transfer rate (say, 60-70 MB/s on a regular harddisk, depending the rotational speed, data density, etc).  

One trick to alleviate this performance issue is to minimize seek time by reordering writes and/or serving reads from cached memory. Memory caches can greatly help in this regard, but here is a little problem: applications, the OS, and other components do not expect writes to be reordered. When you a write reordering is detected at the application level, then a data corruption can appear, especially when you reboot the machine in the middle of performingg a set of reordered writes.

For example the applicaiton is performing Write(block1) followed by Write(block2) in one thread, and Read(block1) followed by Read(block2) on a different thread. In the sequence above, the application expects block1 to be written always before writing block2. Having this guarantee simplifies for example applicaiton recovery semantics, assuming that the computer can crash between writing block1 and block2. But if we perform write reordering, and only write to the disk block2, then our application recovery logic cannot be done in any way. And so we get to corruption.

Still, storage controllers perform today all sorts of tricks like maintaining a write-through cache in volatile RAM, coupled with limited reordering. More advanced controllers, or SAN equipment use persistent caches (battery-backed volatile RAM) to perform write reordering, complementing advanced storage features like RAID configurations, etc.

The solution - why flash is good

By now it should be clear how flash can be used in this picture: you can use inexpensive flash as a persistent write-through cache for reads/writes. Also, the fact that this flash is persistent enables reordering I/O requests at an unprecedented level, therefore greatly reducing our nasty seek time bottleneck:

The new 2Gb OneNAND chip doubles the capacity of a OneNAND memory device (from 1Gb) and increases the chip's ?write' speed from 9.3MByte to 17MByte per second.

?We're seeing a rapidly widening market for our OneNAND memory because of its outstanding performance and capacity that has become even more noteworthy with the application of 60 nm technology,? said Don Barnetson, Director, Flash Marketing, Samsung Semiconductor. [...]

Because of its exceptionally high performance, OneNAND can serve as a catalyst in the development of new product markets. A much-discussed example of this application-creating role is in how OneNAND memory is now being specified as the buffer memory inside a hybrid hard disk.

Samsung successfully demonstrated a commercial Hybrid-HDD prototype for the first time at the MS Developer Conference (WinHEC: Windows Hardware Engineering conference) in Seattle last month.

[source: http://www.physorg.com/news70899414.html]

Flash-based I/O optimizations - already present in Vista 

One more thing worth mentioning: Vista already benefits from Flash-based optimization. The feature is called EMD (External Memory Device), and can boost the performance of your computer by simply adding a USB thumbdrive and designate it as an EMD device. Under the cover, it works in a similar way with the technique described above.

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.

I've been working with Jason Levitt (from Yahoo) recently to iron the wrinkles out of my Flash-based technique for making cross-domain requests. The main focus was to extend the reach of the technique to a larger audience, by adding support for Flash 7, which is more widely deployed than Flash 8.

Try the new FlashXMLHttpRequest demo.

Brad Neuberg's awesome work on DojoExternalInterface gave us a major boost. It emulates the most recent javascript to flash communication API (ExternalInterface, in Flash 8) accross platforms including Flash 7. The library hides differences with browsers and flash versions as much as possible, and works around various performance limitations.

Thanks again to Jason for his interest, feedback and support. I'm pretty excited to see what cool stuff he'll cook using this and the new web APIs from Yahoo.


If you only want to deploy this component, you can download the 'binary' package.
To modify the flash source files and re-build them, get the 'source' package.

As you can see in the demo/index.html file, after including dojo.js and FlashXMLHttpRequest.js, you'll need to initialize dojo and the flash object by calling InitFlash with the name of a function. That function will be invoked once the flash object is loaded and ready to make requests.
From there on, you can create FlashXMLHttpRequest instances and use the 'open', 'onload' and 'send' methods almost as you would with a regular XMLHttpRequest object. You can also call 'setRequestHeader', but only to set the content type request header.

More generally, FlashXMLHttpRequest still has some limitations, due to the native Flash capabilities.
First, access to other domains is restricted by use of a crossdomain.xml file.
Second, you can only make GET and POST requests. It will become possible to support other verbs, such as PUT, DELETE or HEAD, with the new APIs provided by Flash 8.5.

Let me know if FlashXMLHttpRequest is useful to you and if you encounter any bugs. Here's a more convenient permalink to this post: http://blog.monstuff.com/FlashXMLHttpRequest.