Hello,

    Welcome to the Mono/Winforms hacker interview process.  The point
    of this interview is to identify if you can join the Windows.Forms
    team at Novell to enhance Mono.

    To interview you, you must reply to me privately by September 18th
    (I could give more time if you absolutely need it, but you must
    negotiate this in advance) to respond and implement the following
    answers.

    Completing this interview will probably take about sixteen hours,
    as it requires you to implement a sample widget that I have
    specified here for Windows.Forms and it must run on Linux with
    Mono's current Windows.Forms.

    You also have to answer a trick question.

    Be careful, email me your reply *privately*

* Important

    Just so you know, am working with a budget here, I can hire two,
    maybe three candidates, but I need to from you on your reply:

	* What kind of compensation you are expecting.

	* What kind of experience you have.

    The compensation is actually reviewed by HR at Novell, which 
    has parameters for most parts of the world, so the compensation
    that we might be able to offer you will be related to the market
    opportunities in your particular location/country.

    ie, we are not able to pay 10 times more than other people in your
    country, this job will pay about the same that you would be paid
    for doing engineering work in your country.

* The Widget

	You must implement a small rendering engine for a small
	XML-inspired markup language, the language accepts:

	<p>...</p>    To start paragraphs.

	Paragraphs in turn can contain the following:

	<b>...</b>    Where the text ... is bolded.

	<i>...</i>    Where the text ... is italicized

	<link>...</link> Where the ... is rendered as a link

	<blink>...</blink> The text should blink.

        The control must expose one property:

	    string Markup { get; set; }

	Which allows the developer to programatically set the markup
	language, for example:

		  m = new MarkupControl ();
		  m.Markup = "<p>Hello <b>World</b>!</p>";

	The control must also expose an event, so I can hook up
	whenever someone clicks on a link:

	delegate void LinkClicked (object sender, string link_text);

	So I can use it like this:

	          m.LinkClicked += my_clicked;
		  ...
		
		  void my_clicked (object sender, string link_text)
		  {
			Console.WriteLine ("The link {0} was clicked", link_text);
		  }
		 	   
	You must also provide a complete program that will run when I
	run it in Linux, and you must also exercise the property and
	the event, this would be nice to have:

		  void my_clicked (object sender, string link_text)
		  {
			Console.WriteLine ("The link {0} was clicked", link_text);
			((MarkupControl) sender).Markup = "<p>This is the new text after clicking</p>";
		  }

	Extra points: when I use blink, you will have to refresh,
	bonus points if you avoid flicker by using double buffering, or
	by only repaining the area that has changed. 

	I want a small and succinct implementation, but this is your
	opportunity to show that you can write *robust* code, so impress
	me.

* Trick Question

	In our corlib implementation, in System/DateTime.cs we have a
	suboptimal implementation of the method "TryParse", we basically
	call Parse inside try/catch.

	Explain:

		* Why do I say that our solution is "suboptimal"?

		* What would it take it to make more efficient?

		* Why did the maintainer that wrote that code not do
		  the more efficient thing?

	The trick question is: Why was the faster process not done in
	the first place.

	Explain.