Science-fiction author Arthur C. Clarke is one of the people that has defined me as a person and who's books provided both comfort and excitement during my childhood and adolescence. He is mostly known for the movie adaptation of 2001: A Space Odyssey although I liked the Rama series more. He also invented the concept of a geo synchronous satellite. 
He has lived a full life and I don't believe in artificially prolonging living above a certain threshold (he was suffering for 13 years now), so I am just happy to have known about him rather than sad for his death.

More details at this BBC News article and this Wikipedia entry.

• Stargate Atlantis - the spinoff series of Stargate SG1 has ended its 4Th season, but a 5Th is under way. I am watching it mechanically now, as the quality and originality of the show has decreased in time to the point of negative values
  


• Battlestar Galactica - another sci-fi show, it reinvented completely the story of the old 70's BattleStar Galactica. It started great, but the third season ended in some weird pseudo spiritual mambo jumbo. Hopefully, the fourth season due in April will not suffer from the 'Lost' disease
  


• Doctor Who - British sci fi, a bit goofy, but fun nonetheless. It is about an alien that travels space and time with his human female companions (nothing kinky though ;) )
  


• Eureka - silly sci-fi show about an American town that is populated only with brilliant scientists. Very far fetched, but nice as a light comedy. I haven't been able to finish season 2 that finished airing. I think there will be a season 3 as well.
  


• Regenesis - a bit hard to catalogue, this Canadian sci-fi depicts a multinational scientific group with no political associations trying to fight the medical national emergencies in the world. All kinds of diseases and wacky characters, but a bit failing in the field of science. Season 4 is ongoing.
  


• Jericho - now this is a series that was almost cancelled, then brought back at popular demand. Twelve American cities have been blown to smithereens by carefully planted nukes. The US quickly destroyed Iran and North Korea, but it seems the actual perpetrators are American. A small town in the US has to fight off both corporate conspiracies, the newly formed American government and the bands of bandits and neighbouring towns that want what Jericho has: a fan base :).
  


• Numb3rs - oh, what a waste. It started so beautifully as a mathematician applying math to help his FBI agent brother. By season 3 it got completely unscientific, season 4 lost math completely and turned into yet another cop show.
  


• Lost - I am not watching this anymore, only my wife does. I stopped watching this crap after the first season. Meanwhile they use the same psychological system to carry on a story that makes no sense and that everybody watches for the sole purpose of seeing it end. Like a modern day 1001 Arabian nights played on the audience. The only worth watching part of Lost is the pilot episode, then you should continue the story in your own way.
  


• Grey's Anatomy - medical/soap opera. My wife watches it. It started a bit interesting, but ended up crappy. Almost no medicine anymore, instead you see the personal issues of various medical staff people.
  


• Private Practice - as if Grey's Anatomy was not enough, they made a spinoff out of it. I don't know if it will ever air again, though, with the writer strike and all.
  


• Ugly Betty - it proved a commercial success in Latin America, so the TV corporations cloned it for the US market. A gayified version of the South American show, it is basically a women magazine made TV series.
  


• Prison Break - interesting beginning. I recommend the first season, then it all got 'Lost', with psychological effect to keep the audience interested, an escalation of tension, a complete disaster of a plot.
  


• House MD - this one lasted a bit longer before turning to shit. It is a medical show that depicts a wacky, but brilliant diagnostician trying to figure out what the disease and cure is before the sick expires. It has become repetitive and self-satirical, moving away from medicine and back on the ugly and not interesting ploy of human relationships, but then it got back on track. Still worth watching, although the quality is dropping and the story grows old.
  


• Criminal Minds - TV cop show with a team of FBI agents trying to find criminals by using behavioural analysis. Interesting enough, although, as you can imagine, not very technical.
  


• Sarah Connor Chronicles - [chuckle] Terminator is not a teenage girl. She protects John Connor and his mother from other Terminators that roam freely in the past, yet keep a low profile for some reason or another. It's not terrible.
  


• South Park - delicious animated gross comedy, making fun of everything and everybody. They lost the way around season 10, when the authors seemed buried in scandals and full of rage, unable to make fun of things, starting to instead vent frustration in the show. I am happy to see they have recovered in season 11 and season 12 has just started.
  


• Dexter - a serial killer hunts serial killers. This makes him good, somehow, but he is still a killer. Funny enough his cop father taught him how to hide from the police, his sister doesn't know and she is a cop, too, and a colleague of Dexter, who is a criminal forensic in the police department.
  


• Big Love - this is like a family in distress kind of show, but this time the family is made of one husband, 3 wives and numerous children I've lost count of. Yes, they are Mormons and they must navigate the perils of hiding their religion and marital arrangements from the rest of the world, while managing to obey or wriggle around the organisational structure of the Mormons in their community. As much a fascinating subject as this is, the show is pretty ordinary. Tom Hanks is an executive producer.

• PageMethods requirements:
  1. ScriptManager must have EnablePageMethods="true"
  2. The page method must have the form public static string[] MethodName(string prefixText, int count) AND THE SAME PARAMETER NAMES. If you change prefixText with text it will not work!
  3. The page method has to be public and STATIC
  4. No, it is not possible to declare the method in a web user control, it must be in the page
• Web service requirements:
  1. The method must have the form public string[] MethodName(string prefixText, int count) AND THE SAME PARAMETER NAMES. If you change prefixText with text it will not work!
  2. The method has to be public and NOT STATIC
  3. The method must be marked as ScriptMethod

AutoCompleteExtender.CreateAutoCompleteItem(text, value);

string script = @"var tb=document.getElementById('" + tbAutoComplete.ClientID + @"');if (tb) tb.control={set_text:setText,element:tb};";
ScriptManager.RegisterStartupScript(Page,Page.GetType(),UniqueID+"_init",script,true);

function setText(input) {
   if (input=='No Match') return;
   this.element.value=input;
}

<style>
.ajax__tab_header {
    float:left;
}
.ajax__tab_body {
    /*float:left;*/
    margin-left:220px;
}
.ajax__tab_outer {
    display:block !important;
}
.ajax__tab_tab{
    /*min-width:200px;*/
    width:200px;
    height:auto !important;
}
</style>

• First of all this does not overwrite the CSS that the TabContainer loads because it is organized under a general ajax__tab_xp class like: .ajax__tab_xp .ajax__tab_header .
• Then the width of 200px is arbitrary. I used it to keep the vertical tabs at the same width. I tried using min-width first, but it won't display right in Firefox.
• Another point is about the ajax__tab_body class that I tried to set up first as float left, which would place the body div next to the tabs div, however this breaks if the body tab is wider and the content would appear underneath the tabs div. Thanks to my colleague Romeo I used the margin-left trick. 220px is enough to work in both IE and Firefox. It can be made smaller (closer to 200px)if the default IE body margin would be 0.
• The !important keyword is placed to overwrite some settings that are already set up in the original TabContainer CSS.
• Last issue: now the right panel will be truncated if it gets too large. You should control the overflow of that div, although, as far as I am concerned, my job is done

updatePanel.ContentTemplateContainer.Controls.Add(new TextBox());

using System;
using System.Web.UI;

public partial class DynamicUpdatePanels : Page
{
    private int? _nrPanels;

    public int NrPanels
    {
        get
        {
            if (_nrPanels == null)
            {
                if (ViewState["NrPanels"] == null)
                    NrPanels = 0;
                else
                    NrPanels = (int) ViewState["NrPanels"];
            }
            return _nrPanels.Value;
        }
        set
        {
            _nrPanels = value;
            ViewState["NrPanels"] = value;
        }
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        CreatePanels();
    }

    private void CreatePanels()
    {
        for (int i = 0; i < NrPanels; i++)
        {
            AddPanel();
        }
    }

    private void AddPanel()
    {
        UpdatePanel up = new UpdatePanel();
        up.UpdateMode = UpdatePanelUpdateMode.Conditional;
        up.ContentTemplate = Page.LoadTemplate("~/ucUpdatePanelTemplate.ascx");
        pnlTest.Controls.Add(up);
    }

    protected void btnAdd_Click(object sender, EventArgs e)
    {
        NrPanels++;
        AddPanel();
    }
}

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="DynamicUpdatePanels.aspx.cs"
    Inherits="DynamicUpdatePanels" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>
        Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:ScriptManager ID="ScriptManager1" runat="server" />
        <asp:Panel ID="pnlTest" runat="server">
        </asp:Panel>
        <asp:Button ID="btnAdd" runat="server" Text="Add Panel" OnClick="btnAdd_Click" />
        <asp:Button ID="btnPostBack" runat="server" Text="Postback" />
    </form>
</body>
</html>

using System;
using System.Web.UI;

public partial class ucUpdatePanelTemplate : UserControl
{
    protected void btnAjax_Click(object sender, EventArgs e)
    {
        tbSomething.Text = DateTime.Now.ToString();
    }
}

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="ucUpdatePanelTemplate.ascx.cs"
    Inherits="ucUpdatePanelTemplate" %>
<asp:TextBox ID="tbSomething" runat="server"></asp:TextBox>
<asp:Button ID="btnAjax" runat="server" OnClick="btnAjax_Click" />

Agile development is something of a growing software culture. Every dev team is trying to become agile. Programmers I know working like that are all happy and evangelizing the concept as the best thing since the fire simulation algorithm. The word is that Agile gives control back to the developer.

So, what does a code monkey have to do to become agile? (and no tree algorithm jokes here, please!). As experience dictates, Google for "become Agile in 11 seconds" and see what tools one can download and integrate in the personal toolbox! Surprise! There are tools, but they only help you when you are already agile. WTF? It was supposed to be a developer empowering thing!

Actually, this has an only marginal connection to the developer. Agile development is actually a management strategy. No programmer can become agile without the support of their manager. Management in itself is the application of scientific methods to achieve business goals, which are, almost every time, to maximize profits. You see, managers have noticed that they could hardly quantify programmer work. Software development was becoming more artsy and less scientific as technology grew ever faster and more complex.

The typical development cycle of a piece of software is to plan it (sort of) do stuff to it depending on the planning (which always results in changing the original plan or ignoring it altogether), then show it to the customer. They will, almost every time, just applaud and ask you "ok, this is nice (albeit full of bugs), but where is what I wanted?". The manager then gets scolded for not doing their job. But how could one possibly know what the client dreamed of when they said something completely different at the start?

So, what does a manager do when they have a big problem they can't get their hands on? They split it in smaller problems! Divide et Impera! said the Latin managers of old. So the Agile solution was to copy the development process in its entirety, make it as small as possible, then repeat it until it reaches the original size. It's like when you kill the monster at the boss level and he splits in many small bosses (let's call them middle managers) that you have to kill individually to continue the game. Hopefully I have explained this in a way most code monkeys would understand :).

What about empowering the developer? It was a really nice side effect, one that was taken into consideration at the beginning, of course, but I am sure exceeded the expectations of the designers of the process. You see, at the end of each iteration the application should work, somehow, and also be tested, documented, code reviewed and client approved. The client will undoubtedly notice a discrepancy between what he wanted and what was produced, but he can give feedback a lot sooner than at the end of the project. The developer doesn't have to work their ass off to finish the product, sometimes ignoring the most basic testing or documenting techniques in favour of speed, and then be forced to start work almost from scratch because the client either changed his mind or was not understood properly. Therefore there is an increase in motivation and thus productivity and a decrease in unnecessary work. This is also incorporated in one the agile principles YAGNI, which is actually a really buzzy and ugly acronym for "you aren't gonna need it" - in other words, do the least work to achieve the exact desired result.

But most importantly, this is a managerial process, one that is now easy to analyse and even quantify (since the idea to do as much automated testing as possible). If the bugs are too numerous, then testing must be improved. If code is too obscure, code review and refactoring must be done. If nobody knows how to use the product, documentation is needed. But only for the last small bit that was done. Even more cool, the documentation, code review and even refactoring can be done on the code from the previous iteration, while coders are working on the current one!

So, to summarize: to be agile means that your management has decided on a new strategy and you understand the principles enough to get the tools that would make it easier to work under them as well as design your applications to neatly mold to the concept. It does NOT mean you get some library or development tool and it does things for you. There is not an agilizer application (yet? :) take a look at Pex) and the different software patterns like MVC or MVP are used to facilitate the technical solution found to solve the managerial problem of quantifying results (in this case quality) which is Unit Testing.

It's not that Agile Development is not a good idea. Managers don't really see eye to eye with programmers because they have completely different goals - managers see things from the business perspective while developers see it from the beauty and functionality of code. It's like physicists and mathematicians all over again - but both are (or should be) scientific types that try to solve problems in the best possible way. Agile is a happy intersection of their goals, but as it happens, must be implemented in both worlds simultaneously.

string key=Guid.NewGuid().ToString();
Response.AppendToLog(" key=["+key+"]");
MyLogger.Write(myInformation,key);

Response.Filter=new BandwidthThrottleFilter(Response.Fitler,10000);

1. Create a BandwidthThrottleFilter class that inherits from the abstract class Stream
2. Add a constructor that receives as parameters a Stream and an integer
3. Add fields that will get instantiated from these two parameters
4. Implement all abstract methods of the Stream object and use the same methods from the Stream field
5. Change the Write method to also call a Delay method that receives as parameter the count parameter of the Write method

    /// <summary>
    /// Use this filter to simulate slow connections
    /// </summary>
    public class BandwidthThrottleFilter : Stream
    {
        private readonly int _bytesPerSecond;
        private readonly Stream _sink;

        /// <summary>
        /// Gets a slow reading stream
        /// </summary>
        /// <param name="sink">a stream to use as a base (like Response.Filter)</param>
        /// <param name="bytesPerSecond">number of maximum bytes per second</param>
        public BandwidthThrottleFilter(Stream sink, int bytesPerSecond)
        {
            _sink = sink;
            _bytesPerSecond = bytesPerSecond;
        }


        private void Delay(int length)
        {
            int milliseconds = length*1000/_bytesPerSecond;
            if (milliseconds>0) Thread.Sleep(milliseconds);
        }


        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports reading.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports reading; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanRead
        {
            get { return _sink.CanRead; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports seeking.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports seeking; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanSeek
        {
            get { return _sink.CanSeek; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports writing.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports writing; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanWrite
        {
            get { return _sink.CanWrite; }
        }

        ///<summary>
        ///When overridden in a derived class, gets the length in bytes of the stream.
        ///</summary>
        ///
        ///<returns>
        ///A long value representing the length of the stream in bytes.
        ///</returns>
        ///
        ///<exception cref="T:System.NotSupportedException">A class derived from Stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Length
        {
            get { return _sink.Length; }
        }

        ///<summary>
        ///When overridden in a derived class, gets or sets the position within the current stream.
        ///</summary>
        ///
        ///<returns>
        ///The current position within the stream.
        ///</returns>
        ///
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Position
        {
            get { return _sink.Position; }
            set { _sink.Position = value; }
        }


        ///<summary>
        ///When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.
        ///</summary>
        ///
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception><filterpriority>2</filterpriority>
        public override void Flush()
        {
            _sink.Flush();
        }

        ///<summary>
        ///When overridden in a derived class, sets the position within the current stream.
        ///</summary>
        ///
        ///<returns>
        ///The new position within the current stream.
        ///</returns>
        ///
        ///<param name="offset">A byte offset relative to the origin parameter. </param>
        ///<param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"></see> indicating the reference point used to obtain the new position. </param>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support seeking, such as if the stream is constructed from a pipe or console output. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Seek(long offset, SeekOrigin origin)
        {
            return _sink.Seek(offset, origin);
        }

        ///<summary>
        ///When overridden in a derived class, sets the length of the current stream.
        ///</summary>
        ///
        ///<param name="value">The desired length of the current stream in bytes. </param>
        ///<exception cref="T:System.NotSupportedException">The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. </exception>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>2</filterpriority>
        public override void SetLength(long value)
        {
            _sink.SetLength(value);
        }

        ///<summary>
        ///When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        ///</summary>
        ///
        ///<returns>
        ///The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
        ///</returns>
        ///
        ///<param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream. </param>
        ///<param name="count">The maximum number of bytes to be read from the current stream. </param>
        ///<param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source. </param>
        ///<exception cref="T:System.ArgumentException">The sum of offset and count is larger than the buffer length. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support reading. </exception>
        ///<exception cref="T:System.ArgumentNullException">buffer is null. </exception>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception><filterpriority>1</filterpriority>
        public override int Read(byte[] buffer, int offset, int count)
        {
            return _sink.Read(buffer, offset, count);
        }

        ///<summary>
        ///When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
        ///</summary>
        ///
        ///<param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream. </param>
        ///<param name="count">The number of bytes to be written to the current stream. </param>
        ///<param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream. </param>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support writing. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
        ///<exception cref="T:System.ArgumentNullException">buffer is null. </exception>
        ///<exception cref="T:System.ArgumentException">The sum of offset and count is greater than the buffer length. </exception>
        ///<exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception><filterpriority>1</filterpriority>
        public override void Write(byte[] buffer, int offset, int count)
        {
            Delay(count);
            _sink.Write(buffer, offset, count);
        }
    }