Let’s go over the affected browser features one by one, and discuss ways of getting them working in Silverlight apps.

Feature 1: Bookmarking and deep linking

Users like to be able to copy the link from the address bar, email it to a friend, bookmark it, or post it on Twitter or Facebook.

A Silverlight app will typically transition between different views without redirecting the user to a different URL. This makes the user experience smooth and polished. As an unfortunate consequence, a user that copies the URL from the address bar or bookmarks the page will not get a link to the current active view, but instead a link to the initial view of the app.

Thankfully, there is a solution in Silverlight. A Silverlight app can modify the “bookmark” section of the URL, which is the part of the URL following the # character. The app can update the URL each time the user transitions to a different view, and read the bookmark on startup. See this article for details on how to implement this.

The Navigation Framework feature in the upcoming Silverlight 3 release will provide an easy-to-use solution to this problem.

Feature 2: Search engine discoverability

If your Silverlight app links to another page, that link is invisible to search engines. As a result, pages on your site that cannot be reached via traditional HTML links will likely not get listed in search results.

The solution is simple: list all pages on your site in an XML document called a Sitemap. Host the Sitemap on your site, and submit the Sitemap link to search engines. Once you do that, the search engines should include all pages on your site in their indexes.

For details, see the Wikipedia article on Sitemaps.

Feature 3: Back and Forward browser buttons

The Back and Forward browser buttons do not work in Silverlight apps. Switching to a different view in a Silverlight app does not insert a bookmark into the browser history, so the user can’t go to the previous view by clicking the Back button.

The problem is similar to the bookmarking issue (Feature 1), except that the solution is more complicated. If the Silverlight app modifies the bookmark part of the URL, the previous bookmark does not get recorded in the browser history, so the user still cannot use the Back button to return to the previous view.

It is in fact possible to get the Back and Forward buttons working. As of SP1 3.5, ASP.NET exposes a History Control that simplifies the solution significantly (see Control Silverlight by Using Browser Back and Forward Buttons). There is a variety of solutions available online in case you are not using ASP.NET 3.5 SP1, but beware that they typically involve hacks that don’t necessarily work in all browsers.

Or, you can wait until Silverlight 3, because browser history is properly handled in the Navigation Framework.

Feature 4: Support of external tools (translation, accessibility, …)

Automated translation, special browsers for people with disabilities, automated RSS aggregating… these are just some examples of useful tools that consume web content. These tools typically process HTML, but don’t peek inside Silverlight applications.

Since HTML is the standard representation of online documents, consider whether it would make sense to expose a simplified version of your content as a simple HTML page, in addition to your Silverlight application.

Feature 5: Printing

Silverlight does not currently have much support for printing. In Internet Explorer 7, Silverlight applications show up on the printout, but in Firefox or Safary they do not.

So, a Firefox or Safari user will not be able to print out the information displayed by your Silverlight application (at least not without taking screenshots, etc).

If you need to support printing, you can try two different solution approaches. If you only need to print content that can be represented using HTML (e.g., no Silverlight-generated charts and such), see this solution. An alternate approach is to convert XAML to an image format on the server.

Feature 6: Open link in new tab

There doesn’t seem to be a very good way to implement the ‘Open link in new tab’ feature in Silverlight. You can use a HyperlinkButton with a Target set to _blank, which seems to open a new tab in Firefox and a new Window in IE 7. But that still won’t allow the user to choose whether to open the page in the same or different tab/window.

If you are committed enough, you can probably implement a HyperlinkButton with a context menu allowing the user to open the link in a new tab/window. Right-clicking is not directly supported in Silverlight, but workarounds do exist.

Or, use hyperlinks sparingly in Silverlight apps.

Feature 7: Find on this page

I use the ‘Find on this page’ feature (CTRL+F) extensively when browsing the web. But, content inside Silverlight apps is not searched by the browser.

A mitigation is to carefully design the app UI in a way that minimizes the user’s need to search. Data should be sortable and searchable in various ways, and important information should be shown prominently (e.g., the user’s own position on a scoreboard should be highlighted).

These are all good practices regardless of your development platform, but unavailability of the ‘Find on this page’ feature makes them even more important.

Conclusion

Hopefully you’ll find these points helpful when designing your next Silverlight application. If you have other tips on extending browser features into Silverlight apps, let me know in the comments!

The video made the reddit front page, so you can read the usual mixture of insightful, funny, and outright insane comments on the reddit page and the YouTube page.

My favorite funny comment is this one:

And finally, this is the video:

One solution to this performance problem is to use a “precomputed view”. Unlike an ordinary view, a precomputed view is stored in a table rather than computed on demand. When data in one of the aggregated tables changes, the update operation also updates the precomputed view table.

A great thing about precomputed views is that they can be implemented fully in SQL. Any code that accesses the database sees a precomputed view as a regular table. Also, if you have an existing regular view, you can change it into a precomputed view without having to modify any code that queries the view.

To explain the precomputed view pattern, let’s look at an example loosely inspired by the reddit social news site. Users submit articles to reddit and the articles receive up and down votes from other users. User’s “karma” is computed as a sum of votes on positively-voted articles submitted by the user.

To store the reddit data, you can store users in one table, articles in another table, and votes (+1 or -1) from users on articles in a third table:

Now, say that we want to find the top 10 users with highest karma. To compute a user’s karma, we need to sum up the scores of all articles submitted by the user. And to compute each article score, we need to aggregate the votes for that article. It should be clear that this query is going to be very expensive, no matter how much you tune and optimize it.

Views could be used to factor the complex query into simpler pieces, but not to decrease its overall cost:

It is easy to find the top 10 users, simply by querying User_View. Unfortunately, if the database contains millions and millions of votes, the query will take a long time to run. The query will have to group all votes by article, group all articles by user, and then pick the top users. Imagine the impact on performance if you wanted to show the top users on every page of your web app!

However, by changing the views into precomputed views, we can make the query for top users cheap:

Let’s walk through the conversion of Article_View to a precomputed view. First, we’ll create a table for the precomputed view:

    CREATE TABLE Article_PView(
        ArticleId int NOT NULL,
        Title varchar(40) NOT NULL,
        Url varchar(250) NOT NULL,
        VoteSum int NOT NULL,
    )

Second, we’ll need two triggers. This trigger inserts a row into Article_PView whenever a new row is inserted into the Article table:

    CREATE TRIGGER TRG_ArticleInsert
        ON  Article
        AFTER INSERT
    AS
    BEGIN
        SET NOCOUNT ON;

        INSERT INTO Article_PView (ArticleId, Title, Url, VoteSum)
        SELECT Id As ArticleId, Title, Url, 0
        FROM Inserted
    END

And this trigger recomputes a row in Article_PView whenever a vote is inserted, updated or deleted:

    CREATE TRIGGER TRG_Vote
        ON  Vote
        AFTER INSERT, UPDATE, DELETE
    AS
    BEGIN
        SET NOCOUNT ON;

        WITH articleIds(ArticleId) As
        (
            SELECT ArticleId From Inserted
            UNION
            SELECT ArticleId From Deleted
        )
        UPDATE Article_PView
            SET VoteSum = (
                SELECT SUM(Vote) FROM Vote
                WHERE Article_PView.ArticleId = articleIds.ArticleId)
        FROM articleIds
        WHERE Article_PView.ArticleId = articleIds.ArticleId
    END

And finally, we’ll populate the precomputed view with data that is already in the database:

    INSERT INTO Article_PView (ArticleId, Title, Url, VoteSum)
    SELECT Article.Id, Title, Url, ISNULL((SELECT SUM(vote) FROM Vote WHERE ArticleId = Article.Id), 0)
    FROM Article

Article_PView precomputed view is now ready, and User_PView can be created in a similar fashion.

Remarks

Note that my example assumes articles never get removed or updated. Adding support for that functionality is straightforward: you’ll need to extend the TRG_ArticleInsert trigger to also handle updates and deletes. This will be very similar to what TRG_Vote does, but I left it out from the sample for simplicity.

There are several interesting variations of how Article_PView could be implemented. In the implementation above, the trigger aggregates the votes for an article each time someone votes on it. If you want to avoid this cost, you can change the trigger so that it only adjusts the article score instead of recomputing it. For example, if a vote was updated from -1 to +1, the trigger would add 2 to the score of the article. Avoiding concurrency issues may be tricky with that approach, though.

Another interesting variation is adding the VoteSum column to the Article table instead of creating a separate table. Choose the approach that better fits your table design.

Hope you find this pattern useful!

For decades, computer science students have been taught that so-called NP-hard problems do not have known efficient solutions. These problems include the infamous Travelling salesman problem, subset sum, 3SAT, and many more.

But - as is often the case - where theoretical Computer Science failed, sound software engineering practices will succeed. By using loosely-coupled OOP, agile methodologies and the model-view-controller architectural pattern, I developed a solution that someone trapped in the world of formulas and big Ohs would never dream of.

Enough with the background, and let’s take a deep dive into the intriguing design.

Introducing the choose expression

As most other elegant designs, this one is very simple. My proposal calls for a choose expression with this syntax:

    choose { boolean_expression1, boolean_expression2 }

Choose expression is basically the || operator, only with a slight twist. The semantics of the choose expression are similarly simple:

1. If boolean_expression1 or boolean_expression2 will evaluate to true, the runtime will evaluate the true expression, but not the other expression. The return value of the choose expression will be true in this case.
2. If both expressions will evaluate to false, the runtime will evaluate neither expression. The return value of the choose expression is false in this case.

Let’s look at a few simple usage examples:

    bool a = choose {
        1 == 2,
        1 < 2
    };

Variable a will be set to true, because the condition 1 < 2 is true.

Here is another example:

    bool a = choose {
        ((Func<bool>)(() => { Console.WriteLine("Hello"); return false; }))(),
        1 < 2
    };

There is no point executing the first function, because it would return false anyways. So, this code sample does not print anything to screen. Instead, the choose expression will execute the second function. The second expression returns true, so variable a will be set to true.

And another simple one:

    bool a = choose {
        ((Func<bool>)(() => { Console.WriteLine("Hello1"); return false; })(),
        ((Func<bool>)(() => { Console.WriteLine("Hello2"); return false; })(),
    };

This code sample will not be print anything to screen either. It is obvious; why evaluate either of the two functions if they are going to return false anyways? This code simply assigns false to variable a.

Now, let’s cut to the chase, and use choose expressions to give an efficient implementation of an NP-hard problem. Let’s look at subset sum:

    bool SubsetSum(int[] arr)
    {
        return SubsetSumHelper(arr, 0, 0);
    }

    bool SubsetSumHelper(int[] arr, int index, int sumSoFar)
    {
        if (index == arr.Length)
        {
            return sumSoFar == 0;
        }

        return choose {
            () => SubsetSumHelper(arr, index + 1, sumSoFar + arr[index]),
            () => SubsetSumHelper(arr, index + 1, sumSoFar)
        };
    }

Yes, that’s right! An O(N) implementation of the subset sum problem. There you have it, computer scientists. You said it was impossible. If anyone at the University of British Columbia needs my mailing address to send me a refund check for my education, you can find my contact information in the margin.

Under the hood of the choose expression

After a couple hours of coding, I was able to develop a simple prototype. It works perfectly, but since it is only a prototype, I simplified my life a little bit by allowing choose to execute both functions. After all, I don’t have to slave through all the nitty-gritty details in the initial prototype, right? The performance of my implementation is not that great either, but I haven’t had the time to fire up the profiler so far. Perhaps I need to unroll a loop somewhere, or ensure that method calls are getting inlined optimally.

To further prove the feasibility of my design, I developed a non-deterministic Turing machine construction that evaluates choose expressions extremely efficiently.

Non-deterministic Turing machines are known to be a good realistic abstraction of computing hardware; there was a study that proved that. To be exact, the study was only a moderate success. The researchers built a mechanical non-deterministic Turing machine that solved a Travelling Salesperson problem with 5 cities without a hitch. On the 6-city version of the problem, the experiment had to be abruptly interrupted after sprawling machine replicas filled up the room, and the head of one of the researchers got caught in a loop of tape.

So, it is clear that this design is sound. There may be performance issues in the first release, but they will improve as the technology matures. And once CPU manufacturers include a non-deterministic branching instruction in the instruction set, the cost of evaluating the choose expression will drop down to a couple of instructions.

Summary

I don’t know the detailed plans surrounding the C# language, but if there is a C# 4.1., I would like to see the choose expression included.

And the larger lesson of this post is simple: computer science is largely obsolete in today’s world of technology. Computer science says that this is impossible, that is impossible… As you just saw, anything is possible, so long as you have enough paper to print out all the UML diagrams.

For fun, I’ll discuss different aspects of RoboZZle and assign each a letter grade.

Game Addictiveness: A

Let’s start with the positive. RoboZZle has shown to be an addictive game, at least for a certain audience. There is a core group of players that log in regularly, solve puzzles, participate in discussions, design puzzles, propose improvements, and so forth.

A great illustration of my point is a quote from player recursive after finally cracking a long unsolved puzzle designed by evko:

This level is amazing.

I spent about 6 hours solving this one. It took me a while to realize that every movement had to be saved on a stack. Then I developed diagrams, models, and a logical structure around it. And eventually stumbled my way to the solution logically. But it all seems so intuitively obvious now.

This is the best level I’ve solved so far. Bravo.

RoboZZle players have contributed in a variety of ways:

• aalku contributed articles to a number of sections of the wiki (still in an early stage).
• evko is a brilliant puzzle designer who created 42 puzzles, many of them amazingly clever and innovative.
• hr0nix implemented an automated solver for simpler RoboZZle puzzles.
• life96 made a number of helpful suggestions, and investigated the CPU usage of the game.
• stingray blogged about RoboZZle. The article Can Games Teach You To Program? got popular on reddit.
• recursive has an amazingly deep understanding of the game, and discovered shortest known solution for nearly all puzzles.

Finally, I really like this comment left by player spikeless the day that RoboZZle launched:

Brilliant game! It has seriously impacted productivity in our development team leaving nothing to be heard but frustrated curses and elated ‘Yesss’s.

For addictiveness, I give RoboZZle a shameless A.

Features: B

My approach has been to do the minimal set of features I can get away with (but no less), and then grow the game from there. Otherwise, I would still be only 50% done; or more likely, I’d have given up a long time ago.

Since the game launched, I’ve been furiously adding features, in part driven by user feedback, and in part based on what I think will make the game work better.

I added forums, RSS feed for puzzles, wiki, scoreboard for shortest solutions, a stepping debugger for solutions, a new game mode, and lots more.

I give RoboZZle a B here because there are so many more things that I want to do with the game. I can already tell that this will keep me busy for a good while.

Code Quality: B-

This section is about bugs! Similarly to features, I tried to make things “good enough”, and then deploy. Otherwise, I would never get anything done.

Most of the time, this worked fine. Only once a new feature introduced a major bug that impacted the game play for a lot of users. That time, the robot would sometimes seriously misbehave, e.g. continuing its path even though it should have died by falling off a tile.

Except for this one instance, most bugs have been minor issues that most players won’t run into. There are a few minor blemishes still present in the game, but I’m working my way through them.

So, it seems appropriate that RoboZZle gets a B- for quality.

Incoming Traffic: C+

Hmm… incoming traffic. While the loyalty of visitors seems to be great, the incoming traffic numbers aren’t quite as impressive. This table gives a quick summary:

23,000 visits is nothing to sneeze at, but I’ve seen similar numbers for  a blog post that took me a weekend to write. (In all fairness, most of those visitors probably spent less than a second “reading” my blog post.)

Here are the main sources of incoming traffic for robozzle.com:

So, it’s silverlight.net, some popular Russian site, google, dotnetkicks, and two blogs (both recommended reading). Other than that, there are many sources that contribute a small number of visitors each.

I should be able to do better. A part of the problem is that most people still don’t have Silverlight installed, and Silverlight gaming is in its infancy. There are signs that this is about to improve, such as http://mashooo.com, http://silverarcade.com and http://silverlightclub.com, so I’m keeping my fingers crossed.

The other part of the problem is that I need to learn how to better market RoboZZle and draw in visitors. This is a new territory for me, but I’m learning new things every day.

And that’s the main reason I’m working on RoboZZle, so it’s OK.

RoboZZle is an online puzzle game that challenges you to program a robot to pick up all stars on a game board. The game mechanics are simple, yet allow for a wide variety of challenges that call for very different solution approaches.

Here is an example of a solved RoboZZle puzzle, with the arrow edited-in to show the path of the robot:

Since designing RoboZZle puzzles is as much fun as solving them, the game includes a tool to make puzzles yourself. After you create a puzzle, you submit it, and other players will get an opportunity to try to solve it.

In this screenshot, I am just about done designing a challenging puzzle:

Players rate the difficulty of each puzzle, as well as vote whether they liked it or not. When looking for the next puzzle to solve, players can use the ratings to find cool puzzles with the difficulty that suits their current mood.

This screenshot shows the main RoboZZle page at http://robozzle.com:

Players can lookup their ranking, as well as statistics on all players and puzzles on the statistics pages.

In a Web 2.0 fashion, RoboZZle is designed to be a user-driven, social experience. Please check it out, install Silverlight if you need to (it is safe to install), and let me know how you like the game.

   using System.Collections.Generic;
   class Program
   {
       public static void Main()
       {
           int[] arr = new int[10];
           IEnumerator<int> e = arr.GetEnumerator();
       }
   }

If you don’t see it, don’t worry.  I was surprised by this C# behavior as well. Just come back in a couple days to see the solution. Or try to compile the program in Visual Studio.

PS.: The cause for the low cadency of posts on my blog is a side project (an online game written in Silverlight) that has been draining away my extra time over the last few months. Expect an announcement in two to three weeks, once it’s ready for launch.

1. Live Writer clears its undo history when you switch between views. So, if you mess up your article in the HTML view, you won’t be able to revert the change when you notice the disaster after switching back into the Normal view.
2. In the Preview view, Live Writer looks a lot like Internet Explorer. If you are not careful, it is not too hard to close Live Writer by accident. And, the confirmation dialog looks somewhat like IE’s closing dialog.

Thankfully, I found a way to recover Live Writer posts, and saved myself some wasted work.

Every time you switch Live Writer to the Preview or the Normal View, a copy of the post will be written as a HTML file into a temporary directory. On my machine, each snapshot is saved under C:\Users\Igor\AppData\Local\Temp\WindowsLiveWriter1286139640:

Sorting the snapshots by ‘Date modified’ column gives you the history of your edits, so long as you regularly switch between the different views in Live Writer.

With a bit of luck, you will find the right version of the lost article somewhere among the snapshots.

A self-printing program - also called a quine - is a program that prints out its own source code. I will describe one simple way to implement a quine that can be adapted to just about any programming language. The technique does not depend on any unusual language features, but also does not necessarily yield the shortest possible quine in a particular language.

The main idea behind this quine implementation is simple. The quine will consist of two parts: a definition of a string and the program core. The string will contain the source code of the program core. And, what will the program core do? It will print the string twice: once to print the string definition, and again to print the program core.

That’s pretty much all we need to do, except for some details. When printing the string the first time, we need to escape special characters and surround each line with quotes. Also, some code may need to come before the string definition (the “header”), and some may need to come after the program core (the “footer”). Fortunately, we can stuff all the code we need into the program core, so handling these details is not a big problem.

Let’s walk through a quine construction in C#. The quine will look like this:

    using System;
    class P {
        static void Main() {
            string[] S = {
                // the program core, as a string array
            };

            // the program core, as source code:            //     1. Print the program header
            //     2. Print S, formatted as the definition of S
            //     3. Print S, formatted as source code            //     4. Print the program footer
        }
    }

Let’s implement the program core. That’s easy:

    using System;
    class P {
        static void Main() {
            string[] S = {
                // the program core, represented as a string array 
            };
            // 1. Print the program header
            Console.WriteLine("using System;");
            Console.WriteLine("class P {");
            Console.WriteLine("    static void Main() {");

            // 2. Print S, formatted as the definition of S
            Console.WriteLine("        string[] S = {");
            foreach (string line in S)
            {
                string escapedLine = line.Replace(@"\", @"\\").Replace("\"", "\\\"");
                Console.WriteLine("\"{0}\",", escapedLine);
            }
            Console.WriteLine("        };");

            // 3. Print S, formatted as source code
            foreach (string line in S) Console.WriteLine(line);

            // 4. Print the program footer
            Console.WriteLine("    }");
            Console.WriteLine("}");
        }
    }

We also need to initialize string S. To do that, simply copy & paste the program core source code into the definition of S, add a backslash before each occurrence of ” or \, and surround each line with quotes.

Here is the final quine:

using System;
class P
{
    static void Main()
    {
        string[] S = {
"        Console.WriteLine(\"using System;\");",
"        Console.WriteLine(\"class P {\");",
"        Console.WriteLine(\"    static void Main() {\");",
"",
"        Console.WriteLine(\"        string[] S = {\");",
"        foreach (string line in S) {",
"            string escapedLine = line.Replace(@\"\\\", @\"\\\\\")",
"                .Replace(\"\\\"\", \"\\\\\\\"\");",
"            Console.WriteLine(\"\\\"{0}\\\",\", escapedLine);",
"        }",
"        Console.WriteLine(\"        };\");",
"",
"        foreach (string line in S) Console.WriteLine(line);",
"",
"        Console.WriteLine(\"    }\");",
"        Console.WriteLine(\"}\");",
        };
        Console.WriteLine("using System;");
        Console.WriteLine("class P {");
        Console.WriteLine("    static void Main() {");

        Console.WriteLine("        string[] S = {");
        foreach (string line in S)
        {
            string escapedLine = line.Replace(@"\", @"\\")
                .Replace("\"", "\\\"");
            Console.WriteLine("\"{0}\",", escapedLine);
        }
        Console.WriteLine("        };");

        foreach (string line in S) Console.WriteLine(line);

        Console.WriteLine("    }");
        Console.WriteLine("}");
    }
}

Pretty simple, isn’t it?

One interesting point is that if we add extra code into the program core, and add the same code into the definition of string S, we will still have a quine. For example, here is how you can extend to quine to print an arbitrary string to standard error, after printing its own source code to standard output:

using System;
class P
{
    static void Main()
    {
        string[] S = {
"        Console.WriteLine(\"using System;\");",
"        Console.WriteLine(\"class P {\");",
"        Console.WriteLine(\"    static void Main() {\");",
"",
"        Console.WriteLine(\"        string[] S = {\");",
"        foreach (string line in S) {",
"            string escapedLine = line.Replace(@\"\\\", @\"\\\\\")",
"                .Replace(\"\\\"\", \"\\\\\\\"\");",
"            Console.WriteLine(\"\\\"{0}\\\",\", escapedLine);",
"        }",
"        Console.WriteLine(\"        };\");",
"",
"        foreach (string line in S) Console.WriteLine(line);",
"",
"        Console.WriteLine(\"    }\");",
"        Console.WriteLine(\"}\");",
"",
"        Console.Error.WriteLine(\"This quine can do other things too!\");",
        };
        Console.WriteLine("using System;");
        Console.WriteLine("class P {");
        Console.WriteLine("    static void Main() {");

        Console.WriteLine("        string[] S = {");
        foreach (string line in S)
        {
            string escapedLine = line.Replace(@"\", @"\\")
                .Replace("\"", "\\\"");
            Console.WriteLine("\"{0}\",", escapedLine);
        }
        Console.WriteLine("        };");

        foreach (string line in S) Console.WriteLine(line);

        Console.WriteLine("    }");
        Console.WriteLine("}");

        Console.Error.WriteLine("This quine can do other things too!");
    }
}

So, we can write a program that knows how to print its source code, but also does other things. This is interesting for three reasons:

1. It is an important result in theoretical computer science, known as the recursion theorem. Recursion theorem can be used to prove a variety of interesting results. For example, using the recursion theorem is one way to prove that the halting problem is undecidable.
2. Virus writers write programs that know how to replicate themselves, but also do other things, such as messing up your computer.
3. You can write pointless but cool little programs, like my self-printing Game of Life.

By the way, the quine that I described in this article is by no means the shortest possible one in C#. Joey Wescott came up with a C# quine that is only 166 characters long. I suggested two improvements, and we got it down to 149 characters (all one line):

class P{static void Main(){var S="class P{{static void Main(){{var S={1}{0}{1};System.Console

.Write(S,S,'{1}');}}}}";System.Console.Write(S,S,'"');}}

And there you have it - that’s how you write quines. In my next article, I will talk about an interesting little problem, and seven very different algorithms that can be used to solve it.

Other articles you may like:

Numbers that cannot be computed

Skip list are fascinating!

Quicksort killer

Conway’s Game of Life has fascinated computer scientists for decades. Even though its rules are ridiculously simple, Conway’s universe gives rise to a variety of gliders, spaceships, oscillators, glider guns, and other forms of “life”. Self-printing programs are similarly curious, and - rather surprisingly - have an important place in the theory of computation.

What happens when you combine the two? You are about to find out, but one thing is for sure: the geekiness factor should be pretty high.

I wrote a little C# program that contains a Game-of-Life grid. The program advances the game grid to the next generation and prints out a copy of itself, with the grid updated. You can take the output, compile it with a C# compiler, run it, and you’ll get the next generation of the game. You can iterate the process, or change the initial grid state manually.

Here is the source code:

using System;class G  /* GAME OF LIFE by Igor Ostrovsky */  {static string[]S={
"############################################################################",
"#                                                               * *        #",
"#  ***                                                         *           #",
"#                                       *                      *           #",
"#                                     * *                      *  *        #",
"#                           **      **            **           ***         #",
"#                          *   *    **            **                       #",
"#               **        *     *   **                                     #",
"#               **        *   * **    * *                                  #",
"#                         *     *       *                                  #",
"#                          *   *                                           #",
"#                           **                                             #",
"#   **     **                                                              #",
"#    **   **                                        *  *                   #",
"# *  * * * *  *                                         *                  #",
"# *** ** ** ***                                     *   *                  #",
"#  * * * * * *                                       ****                  #",
"#   ***   ***                                                              #",
"#                                                                          #",
"#   ***   ***                                                              #",
"#  * * * * * *            *                                                #",
"# *** ** ** ***           *           *  *                             *** #",
"# *  * * * *  *                           *                           *  * #",
"#    **   **             ***          *   *                **            * #",
"#   **     **                          ****                              * #",
"#                                                                     * *  #",
"############################################################################",
};static void Main(){string T="\",r=\"using System;class G  /* GAME OF LIFE b"+
"y Igor Ostrovsky \"+\"*/  {static string[]S={\\n\";int p=31,i,j,b,d;for(i=0;"+
"i<27;i++){r+='\"'; for(j=0;j<76;j++){if(S[i][j]!='#'){b=0;for(d=0;d<9;d++)if"+
"(S[i-1+d/3][j-1+d%3]=='*')b++;r+=b==3 ||(S[i][j]=='*'&&b==4)?'*':' ';} else "+
"r+='#';}r+=\"\\\",\\n\";}r+=\"};static\"+\" void Main(){string T=\\\"\";fore"+
"ach(var c in T){if(c=='\\\\'||c=='\"'){r+='\\\\';p++;} r+=c; if(++p>=77){r+="+
"\"\\\"+\\n\\\"\";p=1;}} foreach(var c in T){r+=c;if(++p%79==0)r+='\\n';}Cons"+
"ole.Write(r);}}",r="using System;class G  /* GAME OF LIFE by Igor Ostrovsky "+
"*/  {static string[]S={\n";int p=31,i,j,b,d;for(i=0;i<27;i++){r+='"'; for(j=0;
j<76;j++){if(S[i][j]!='#'){b=0;for(d=0;d<9;d++)if(S[i-1+d/3][j-1+d%3]=='*')b++;
r+=b==3 ||(S[i][j]=='*'&&b==4)?'*':' ';} else r+='#';}r+="\",\n";}r+="};static"
+" void Main(){string T=\"";foreach(var c in T){if(c=='\\'||c=='"'){r+='\\';p++
;} r+=c; if(++p>=77){r+="\"+\n\"";p=1;}} foreach(var c in T){r+=c;if(++p%79==0)
r+='\n';}Console.Write(r);}}

And is here the output the program prints. The output is the same as the source code, except that the game has advanced to the next generation:

using System;class G  /* GAME OF LIFE by Igor Ostrovsky */  {static string[]S={
"############################################################################",
"#   *                                                                      #",
"#   *                                                          **          #",
"#   *                                  *                      ***          #",
"#                                    * *                      ** *         #",
"#                           *       * *           **           ***         #",
"#                          **      *  *           **            *          #",
"#               **        **    **  * *                                    #",
"#               **       ***    **   * *                                   #",
"#                         **    **     *                                   #",
"#                          **                                              #",
"#                           *                                              #",
"#   ***   ***                                                              #",
"#                                                                          #",
"# *    * *    *                                        **                  #",
"# *    * *    *                                      ** **                 #",
"# *    * *    *                                      ****                  #",
"#   ***   ***                                         **                   #",
"#                                                                          #",
"#   ***   ***                                                              #",
"# *    * *    *                                                         *  #",
"# *    * *    *                                                        *** #",
"# *    * *    *          * *             **                            * **#",
"#                         *            ** **                            ***#",
"#   ***   ***             *            ****                             ** #",
"#                                       **                                 #",
"############################################################################",
};static void Main(){string T="\",r=\"using System;class G  /* GAME OF LIFE b"+
"y Igor Ostrovsky \"+\"*/  {static string[]S={\\n\";int p=31,i,j,b,d;for(i=0;"+
"i<27;i++){r+='\"'; for(j=0;j<76;j++){if(S[i][j]!='#'){b=0;for(d=0;d<9;d++)if"+
"(S[i-1+d/3][j-1+d%3]=='*')b++;r+=b==3 ||(S[i][j]=='*'&&b==4)?'*':' ';} else "+
"r+='#';}r+=\"\\\",\\n\";}r+=\"};static\"+\" void Main(){string T=\\\"\";fore"+
"ach(var c in T){if(c=='\\\\'||c=='\"'){r+='\\\\';p++;} r+=c; if(++p>=77){r+="+
"\"\\\"+\\n\\\"\";p=1;}} foreach(var c in T){r+=c;if(++p%79==0)r+='\\n';}Cons"+
"ole.Write(r);}}",r="using System;class G  /* GAME OF LIFE by Igor Ostrovsky "+
"*/  {static string[]S={\n";int p=31,i,j,b,d;for(i=0;i<27;i++){r+='"'; for(j=0;
j<76;j++){if(S[i][j]!='#'){b=0;for(d=0;d<9;d++)if(S[i-1+d/3][j-1+d%3]=='*')b++;
r+=b==3 ||(S[i][j]=='*'&&b==4)?'*':' ';} else r+='#';}r+="\",\n";}r+="};static"
+" void Main(){string T=\"";foreach(var c in T){if(c=='\\'||c=='"'){r+='\\';p++
;} r+=c; if(++p>=77){r+="\"+\n\"";p=1;}} foreach(var c in T){r+=c;if(++p%79==0)
r+='\n';}Console.Write(r);}}

If you want to see the program iterate, save the source code into a file named life.cs, and run this command repeatedly from a Visual Studio console:

csc.exe life.cs && (life > life.cs) && life

Cool, isn’t it? I have a follow-up article nearly ready that explains how to write programs like this one… just in case you ever wanted to.

[Update] The follow-up How to write a self-printing program is up.

More articles:

Numbers that cannot be computed

Skip list are fascinating!

Quicksort killer