• the code does not belong to any programmer, in other words anyone can change any piece of code in order to solve an issue
• the members of the team are interchangeable, so not a bunch of experts in different fields, but people that can do all things (and be easily replaced by people just as agile as them :) )
• the members of the team must have similar competencies, one cannot do pair programming between a rookie and a senior, for example. That is called teaching :)
• the client is supposed to change their mind often and unpredictably, one plans for the unplannable
• the client must be represented in the agile team, so as to not have delays or misunderstandings in requirements

Scrum

• All development is done in fixed time increments called Sprints. Scrum specifies 15 or 30 days, although I bet most dev companies actually plan this on a calendaristic month.
• At the start of each Sprint a meeting of 8 hours takes place (so the first day) in which half of it is to present the requests by the Product Owner (in our case that would be either the client or the person that did the analysis) and the other half to plan which of the tasks in the Project BackLog (requirements list) can be done in the current Sprint. This last part if the responsability of the Team (that would be the developers and their team leaders and managers).
• In the last day of the Sprint two meetings will be held: a 4 hour meeting that will allow the Team to present what was done in the current Sprint to the Product Owner (this would be an informal meeting that "is intended to bring people together and help them collaboratively determined what the Team should do next") and a 3 hour meeting in which the ScrumMaster (the person in charge with the implementation of Scrum in the project) "encourages the Team to revise, within the Scrum process framework and practices, its development process to make it more effective and enjoyable for the next Sprint"
• The development is one in the rest of 28 days
• Each day there is a 15 minute Scrum Meeting held within the Team in which "each Team member answers three questions: What have you done on this project since the last Daily Scrum meeting? What do you plan on doing on this project between now and the next Daily Scrum meeting? What impediments stand in the way of you meeting your commitments to this Sprint and this project? The purpose of the meeting is to synchronize the work of all Team members daily and to schedule any meetings that the Team needs to forward its progress".

XP (Extreme Programming)

• User stories as requirements gathering; Most important! a detailed story of what the user will do and why, like a narrative, the Word version of an UML flow diagram, which is the responsability of the client! The actual developing is the implementation in code of those stories
• iterations, which in the case of XP don't have a specific time length, each one is planned depending on what there is to do and what can be done
• the separation of user and client, the user is the one that actually uses the program, while the client... well, you know
• user-on-site, you can always ask the user what they think and receive quick feedback
• Test driven development, which, together with pair programming, seem the only actual extreme parts of XP, where they insist on tests first, programming later.
• Spikes: small bursts of programming for no other reason than to research an idea. Developers don't have to be rigurous in spike programming, since they only do the bit of code, test its functionality, then throw it away, the idea being that they learn how to do the actual code they wanted to do and what problems they might be facing. In this particular case, the spike is part of the planning or designing of a piece of code.

Conclusion

1. Don't gain extra weight
2. Eat the right stuff to maintain your weight
3. Keep your metabolism running to lose weight

• it is an ugly country
• it is overrun by car thieves, corrupt cops and enterprising murderers
• it has no, little or bad roads
• it is poor like a third world country

• Decide upon a database naming convention, standardize it across your organization, and be consistent in following it. It helps make your code more readable and understandable.
• Write comments in your stored procedures, triggers and SQL batches generously, whenever something is not very obvious.
• Try to avoid server side cursors as much as possible.
  As Vyas Kondreddi himself says: "I have personally tested and concluded that a WHILE loop is always faster than a cursor"
• Avoid the creation of temporary tables while processing data as much as possible, as creating a temporary table means more disk I/O. Consider using advanced SQL, views, SQL Server 2000 table variable, or derived tables, instead of temporary tables.
  This is interesting, because I usually use a lot of temporary tables in my stored procedures to make the code more orderly. I guess that in the case of SQL Server 2005 and later one can always use Common Table Expressions to make the code more readable. For SQL 2000 and such I found two interesting articles about not using temporary tables and replacing them with either derived tables (selects in selects) or with table variables, although they do have some limitations, thoroughly explained in the latter post. Here are the links: Eliminate the Use of Temporary Tables For HUGE Performance Gains and Should I use a #temp table or a @table variable?
• Try to avoid wildcard characters at the beginning of a word while searching using the LIKE keyword, as that results in an index scan, which defeats the purpose of an index.
  For a short analysis of index scans go to SQL SERVER - Index Seek Vs. Index Scan (Table Scan).
• Use the graphical execution plan in Query Analyzer or SHOWPLAN_TEXT or SHOWPLAN_ALL commands to analyze your queries.
• Use SET NOCOUNT ON at the beginning of your SQL batches, stored procedures and triggers in production environments, as this suppresses messages like '(1 row(s) affected)' after executing INSERT, UPDATE, DELETE and SELECT statements. This improves the performance of stored procedures by reducing network traffic.
• Use the more readable ANSI-Standard Join clauses instead of the old style joins.
• Incorporate your frequently required, complicated joins and calculations into a view so that you don't have to repeat those joins/calculations in all your queries.
• Use User Defined Datatypes if a particular column repeats in a lot of your tables, so that the datatype of that column is consistent across all your tables.
  Here is a great article about Sql UDTs (not the new .NET CLR types): What's the Point of [SQL Server] User-Defined Types?. Never used them, myself, but then again I am not an SQL guy. For me it seems easier to control data from .Net code
• Do not let your front-end applications query/manipulate the data directly using SELECT or INSERT/UPDATE/DELETE statements. Instead, create stored procedures, and let your applications access these stored procedures.
  I am afraid I also fail at this point. I don't use stored procedures for simple actions like selecting a specific item or deleting a row. Many time I have to build search pages with lots of parameters and I find it really difficult to add a variable number of parameters to a stored procedure. For example a string that I have to split by spaces and search for all found words. Would it be worth to use a stored procedure in such a situation?
• Avoid dynamic SQL statements as much as possible. Dynamic SQL tends to be slower than static SQL, as SQL Server must generate an execution plan every time at runtime.
  Personally, I never use dynamic SQL. If I need to create an SQL string I do it from .Net code, not from SQL.
• Consider the following drawbacks before using the IDENTITY property for generating primary keys. IDENTITY is very much SQL Server specific, and you will have problems porting your database application to some other RDBMS. IDENTITY columns have other inherent problems. For example, IDENTITY columns can run out of numbers at some point, depending on the data type selected; numbers can't be reused automatically, after deleting rows; and replication and IDENTITY columns don't always get along well.
  So, come up with an algorithm to generate a primary key in the front-end or from within the inserting stored procedure. There still could be issues with generating your own primary keys too, like concurrency while generating the key, or running out of values. So, consider both options and go with the one that suits you best.
  This is interesting because I always use identity columns for primary keys. I don't think a data export or a database engine change justify creating a custom identity system. However I do have to agree that in the case that data is somehow corrupted a GUID or some other identifier would be more useful. I am sticking with my IDENTITY columns for now.
• Use Unicode datatypes, like NCHAR, NVARCHAR, or NTEXT.
• Perform all your referential integrity checks and data validations using constraints (foreign key and check constraints) instead of triggers, as they are faster.
• Always access tables in the same order in all your stored procedures and triggers consistently. This helps in avoiding deadlocks. Other things to keep in mind to avoid deadlocks are: Keep your transactions as short as possible. Touch as few data as possible during a transaction. Never, ever wait for user input in the middle of a transaction. Do not use higher level locking hints or restrictive isolation levels unless they are absolutely needed. Make your front-end applications deadlock-intelligent, that is, these applications should be able to resubmit the transaction incase the previous transaction fails with error 1205. In your applications, process all the results returned by SQL Server immediately so that the locks on the processed rows are released, hence no blocking.
  I don't have much experience with transactions. Even if I would need transactions in some complex scenarios, I would probably use the .Net transaction system.
• Offload tasks, like string manipulations, concatenations, row numbering, case conversions, type conversions etc., to the front-end applications.
  Totally agree, except the row numbering, where SQL 2005 added all those nice Getting the index or rank of rows in SQL Server 2005 aggregate ranking options
• Always add a @Debug parameter to your stored procedures. This can be of BIT data type. When a 1 is passed for this parameter, print all the intermediate results, variable contents using SELECT or PRINT statements and when 0 is passed do not print anything. This helps in quick debugging stored procedures, as you don't have to add and remove these PRINT/SELECT statements before and after troubleshooting problems.
  Interesting, I may investigate this further, although the SQL debugging methods have improved significantly since the article was written.
• Make sure your stored procedures always return a value indicating their status. Standardize on the return values of stored procedures for success and failures. The RETURN statement is meant for returning the execution status only, but not data. If you need to return data, use OUTPUT parameters
• If your stored procedure always returns a single row resultset, consider returning the resultset using OUTPUT parameters instead of a SELECT statement, as ADO handles output parameters faster than resultsets returned by SELECT statements.
• Though T-SQL has no concept of constants (like the ones in the C language), variables can serve the same purpose. Using variables instead of constant values within your queries improves readability and maintainability of your code.

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.

• a general format for parsing the data
• a way to mark the different matched groups with meaningful identifiers
• performance and resource economy

namespace Siderite.Text.RegularExpressions
{
/// <summary>
/// Regex Match equivalent for Streams
/// </summary>
public class StreamMatch
{
private readonly Match _match;
private readonly StreamRegex _streamRegex;
private long _streamIndex;

/// <summary>
/// Constructor
/// </summary>
/// <param name="regex">StreamRegex that generated it</param>
/// <param name="m">internal Regex match</param>
/// <param name="streamIndex">real stream index</param>
internal StreamMatch(StreamRegex regex, Match m, long streamIndex)
{
_streamRegex = regex;
_match = m;
StreamIndex = streamIndex;
}

/// <summary>
/// Empty StreamMatch
/// </summary>
public static StreamMatch Empty
{
get { return new StreamMatch(null, null,0); }
}

/// <summary>
/// Success of matching
/// </summary>
public bool Success
{
get
{
if (_match == null) return false;
// matches with length 0 would only cause infinite loops
if ((_streamRegex.EmptyRegexMode==EmptyRegexMode.NoSuccess)&&(_match.Length == 0)) 
return false;
return _match.Success;
}
}

/// <summary>
/// Length of match
/// </summary>
public int Length
{
get
{
if (_match == null) return 0;
return _match.Length;
}
}

/// <summary>
/// Groups in the match. This is a regular Regex GroupCollection
/// </summary>
public GroupCollection Groups
{
get
{
if (_match == null) return null;
return _match.Groups;
}
}

/// <summary>
/// Value of the match
/// </summary>
public string Value
{
get
{
if (_match == null) return null;
return _match.Value;
}
}

/// <summary>
/// Group names in the match including "0","1", etc
/// </summary>
public string[] GroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.GroupNames;
}
}

/// <summary>
/// Group names in the match that are non numeric (words only)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.NonNumericGroupNames;
}
}

public long StreamIndex
{
get { return _streamIndex; }
set { _streamIndex = value; }
}

/// <summary>
/// indexer using a name
/// </summary>
/// <param name="groupName"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[string groupName]
{
get
{
if (_match == null) return null;
return _match.Groups[groupName];
}
}

/// <summary>
/// indexer using a numeric index
/// </summary>
/// <param name="groupNr"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[int groupNr]
{
get
{
if (_match == null) return null;
return _match.Groups[groupNr];
}
}

/// <summary>
/// Find next match
/// </summary>
/// <returns></returns>
public StreamMatch NextMatch()
{
if (_streamRegex == null) return null;
return _streamRegex.NextMatch();
}
}

public enum EmptyRegexMode
{
NoSuccess,
ThrowException,
Success
}

/// <summary>
/// Regex equivalent for Streams
/// </summary>
public class StreamRegex
{
private readonly Regex _regex;
private readonly StringBuilder _sb;
private readonly Stream _stream;
private byte[] _buffer;
private int _bufferSize = 65536;
private long _currentPosition;
private Encoding _encoding;
private string[] _groupNames;
private long _internalStreamLength;
private bool _matchInitialised;
private long _maxMatchLength;
private EmptyRegexMode _emptyRegexMode;

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
public StreamRegex(Stream stream, string pattern)
: this(stream, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Compiled)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions)
: this(stream, pattern, regexOptions, Encoding.GetEncoding(1252))
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding)
: this(stream, pattern, regexOptions, encoding, long.MaxValue/2)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
/// <param name="maxMatchLength">Maximum possible match. Specify this to minimize memory use</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding,
long maxMatchLength)
{
_regex = new Regex(pattern, regexOptions);
_stream = stream;
_matchInitialised = false;
Encoding = encoding;
MaxMatchLength = maxMatchLength;
_sb = new StringBuilder();
EmptyRegexMode = EmptyRegexMode.NoSuccess;
}

/// <summary>
/// Read buffer size. default 65536 bytes
/// Warning: this works on an internal string that will be 
/// a multiple of this number. Don't make it too large.
/// </summary>
public int BufferSize
{
get { return _bufferSize; }
set
{
_bufferSize = value;
// you cannot run NextMatch now
_matchInitialised = false;
}
}

/// <summary>
/// Encoding for the stream. default Windows-1252
/// </summary>
public Encoding Encoding
{
get { return _encoding; }
set { _encoding = value; }
}

/// <summary>
/// Maximum possible match length. default long.MaxValue/2
/// </summary>
public long MaxMatchLength
{
get { return _maxMatchLength; }
set { _maxMatchLength = value; }
}

/// <summary>
/// Names of the groups in the regex expression
/// </summary>
public string[] GroupNames
{
get
{
if (_regex == null) return null;
if (_groupNames == null)
{
_groupNames = _regex.GetGroupNames();
}
return _groupNames;
}
}

/// <summary>
/// Names of the groups in the regex expression
/// that are non numeric (so only the word names)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_regex == null) return null;
List<string> list = new List<string>();
foreach (string groupName in _regex.GetGroupNames())
{
if (!Regex.IsMatch(groupName, @"^\d+$")) list.Add(groupName);
}
return list;
}
}

/// <summary>
/// defines who empty matches are treated: 
/// no success match, exception or succesful match
/// defaults to no success match
/// </summary>
public EmptyRegexMode EmptyRegexMode
{
get { return _emptyRegexMode; }
set { _emptyRegexMode = value; }
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <returns></returns>
public StreamMatch Match()
{
return Match(0L);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public StreamMatch Match(long index)
{
return Match(index, long.MaxValue/2);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public StreamMatch Match(long index, long length)
{
if (!_stream.CanRead) throw new Exception("Stream is not readable");
if (length <= 0) return StreamMatch.Empty;
if (index != 0) SeekStream(index);
_buffer = new byte[BufferSize];
_sb.Length = 0;
// initialize real position in stream
_currentPosition = _stream.Position;
// this is the maximum length of bytes this match will read
_internalStreamLength = length;
// you can now call NextMatch
_matchInitialised = true;
return NextMatch();
}

internal StreamMatch NextMatch()
{
if (!_matchInitialised) 
throw new Exception("First run Match, then NextMatch");
// search the buffer string first
Match m = _regex.Match(_sb.ToString());
if (m.Success&&((EmptyRegexMode!=EmptyRegexMode.NoSuccess)||(m.Length>0)))
{
if (EmptyRegexMode == EmptyRegexMode.ThrowException)
{
if (m.Length == 0)
throw new Exception(
"Successful Match has empty value. If you use NextMatch in a loop it will become infinite");
}
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;

return sm;
}
int l;
while ((l = _stream.Read(_buffer, 0, (int) Math.Min(_internalStreamLength, _buffer.Length))) > 0)
{
_internalStreamLength -= l;

// remove part of StringBuilder where there is no chance it contains a match
// this works only if MaxMatch is specified
long extraLength = _sb.Length - MaxMatchLength;
if (extraLength > 0)
{
_sb.Remove(0, (int) extraLength);
_currentPosition += extraLength;
}


_sb.Append(Encoding.GetString(_buffer, 0, l));

// TODO: remove this
Debug.WriteLine("SB length: " + _sb.Length);

m = _regex.Match(_sb.ToString());
if (m.Success)
{
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;
return sm;
}
}
return new StreamMatch(this, m, 0);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches()
{
return Matches(0L);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index)
{
return Matches(index, long.MaxValue/2);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index, long length)
{
List<StreamMatch> list = new List<StreamMatch>();
StreamMatch m = Match(index, length);
while (m.Success)
{
list.Add(m);
m = NextMatch();
}
return list;
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index from current position</param>
public void SeekStream(long index)
{
SeekStream(index, SeekOrigin.Current);
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index position</param>
/// <param name="origin">from current position, start or end</param>
public void SeekStream(long index, SeekOrigin origin)
{
int _tmpSeekSize = 65536;
if (_stream.CanSeek)
{
_stream.Seek(index, origin);
}
else
{
if (origin != SeekOrigin.Current) throw new Exception("Stream is not seakable");
long l = 0;
try
{
l = _stream.Length;
}
#pragma warning disable EmptyGeneralCatchClause
catch (Exception)
{
}
#pragma warning restore EmptyGeneralCatchClause
if ((l > 0) && (l < 65536)) _tmpSeekSize = 4096;
if (l > 1000000) _tmpSeekSize = 409600;
if (index >= 0)
{
byte[] buff = new byte[_tmpSeekSize];
l = index;
while (l > 0)
{
l -= _stream.Read(buff, 0, (int) Math.Min(l, buff.Length));
}
}
else
{
throw new Exception("begin cannot be negative on a non seeking stream");
}
}

// update real position in stream
_currentPosition = _stream.Position;
// you cannot run NextMatch now
_matchInitialised = false;
}
}
}

• the .NET regular expression flavour supports marking a group with a name like this

  (?<nameOfGroup>someRegexPattern)

• it also supports non capturing grouping:

  (?:pattern)

  This will not appear as a Group in any match although you can apply quantifiers to it
• also supported are atomic or greedy grouping.

  (?>".+")

  The pattern above will match "abc" but not "abc"d because ".+ matches the whole pattern and the ending quote is not matched. Normally, it would backtrack, but atomic groups do not backtrack once they failed, saving time, but possibly skipping matches
• one can also use lazy quantifiers:ab+? will match ab in the string abbbbbb
• posessive quantifiers are not supported, but they can be substituted with atomic groups:

  ab*+ in some regex flavours is (?>ab*) in .NET

• let's not forget the

  (?#this is a comment)

  notation to add comments to a regular expression
• Look-behinds! - great new discovery of mine that can match an already matched expression. I am not sure how it would hinder speed, though. Quick example: I want to match "This is a string", but not "This is a longer string, that I don't want to match, since it is ridiculously long and it would make my regex run really slow when I really need only a short string" :), both as separate lines in a text file.

  ([^\r\n]+)(?:$|[\r\n])(?<=(?:^|[\r\n]).{1,21})

  This expression matches all strings that do not contain line breaks, then looks behind to check if there is a string begin or a line break character at at most 21 characters behind, effectively reducing the maximum length of the matched string to 20. Unfortunately, this would slow even more the search, since it would only back check a match AFTER the match completed.

• the Regex class is no sealed
• Regex calls on a RegexRunner class, which is also public and abstract
• RegexRunner asks you to implement the FindFirstChar, Go and InitTrackCount methods, while all the other methods it has are protected but not virtual. In the MSDN documentation on it, this text seals the fate of the class This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.
• The RegexRunner class that the Regex class calls on is the RegexInterpreter class, which is a lot of extra code and, of course, is internal sealed

• Step 1: inherit from Regex and set some base protected values. One that is essential is base.factory = new YourOwnFactory();
• Step 2: create said YourOwnFactory by inheriting from RegexRunnerFactory, override the CreateInstance() method and return a YourOwnRunner object. Like this:

  class YourOwnFactory : RegexRunnerFactory
      {
          protected override RegexRunner CreateInstance()
          {
              return new YourOwnRunner();
          }
      }

  
  
• Step 3: create said YourOwnRunner by inheriting from abstract class RegexRunner. You must now implement FindFirstChar, Go and InitTrackCount.

• An option to match in parallel two or more regular expressions on the same string. This would allow me to check for a really complicated expression and in the same time validate it (for length, format, or whatever)
• Stream support. This hack in the above code works, but does not real tap in the power of regular expressions. The support should be included in the engine itself
• Extensibility support. Maybe this would have been a lot more easy if there was some support for adding custom expressions, maybe hidden in .NET (?#comment) syntax.

• use gap analysis for all the levels of your software work. When you define what you have and what you need, filling the blanks becomes easier.
• use functional documentation, design documentation and structural documentation to detail what you wanted the software to do, how you designed to solve the problems and what are the basic building blocks of the project (classes, patterns, etc).
• use code standards and peer reviews and even external code auditing to improve the quality of code. Refactoring is a must. Popular code development methodologies include Extreme Programming and Rational Unified Process.
• use a design standard like the open-source architecture framework (TOGAF)
• the enterprise vs. domain dichotomy. Should a software be started from scratch and done for the current set of requests only, or should it be designed as a general component ready for reuse? I would really go towards the enterprise, even when the profit from the extra work is not immediately obvious. Sometimes things that you have prepared in advance and nobody acknowledged become a real time (and life) saver when unreasonable requests tumble down upon you.
• also linked to the enterprise/domain issue: an application framework solution. Create a basic Visual Studio solution that contains common components used in many projects and use it as a startup solution.
• use the Visual Studio formatting options to keep your code well formatted. Use a standard of naming variables, methods, properties. My own choice is using lowerCamelCase for inner variables, prefixing the name with an underscore for fields. UpperCamelCase (or Pascal) for methods, properties and class names. Hungarian notation for controls (lbName for a label with a name). I don't really care if one names the control txtName, tbName or tboxName, as long as the prefix is revealing.
• use the Obsolete attribute for methods and properties that are intended to be removed in the near future. In my own library I have used methods that became obsolete with the coming of .NET 2.0 and used this attribute to point not only to the obsolescence, but also to the blog entry detailing the reasoning behind it.
• this is basically derived from other sources, but I do think it is relevant: best practices recommends using composition over inheritance, wherever possible. I admit that the coding of composition is much more complex, but with the refactoring tools found in Visual Studio and its add-ons (like my beloved Resharper), it becomes similar in complexity.
• references:
  
  1. book: Programming C# by Jesse Liberty, published by O'Reilly
  2. dude: Martin Fowler is a leading authority on refactoring
  3. books to understand object-oriented development: Object-Oriented Analysis and Design with Applications by Grady Booch, published by Addison-Wesley in 1994
  4. Expert C# Business Objects by Rockford Lhotka, published by Apress in 2003
  5. book: Code Complete, by Steve McConnell, published by Microsoft Press 2004
  6. authorities on design patterns: Martin Fowler, Gregor Hohpe, Bobby Woolf
  7. dude: professor Trygve Reenskaug and his discussion on the role of object collaboration: Role Modeling and UML-VM discussions

I was bent on writing an article about tea. You see, tea :) is a word often used instead of "infusion", but the definition of the word says it is specifically an infusion of Camellia sinensis, or the tea plant. I drink tea a lot, although I prefer to alternate the different tastes as much as possible.

But the tea and coffee plants are far from being the only ones used for energizing drinks. In the Theaceae family alone there are a few species that are traditionally used for infusions.

Then there is the mate, from Yerba Mate, a species of the Holly (Ilex) family. 
Other members of the Ilex family are used for traditional drinks.

The Roiboos infusion is an African tea made from a plant that is part of the legume family! I've tried it and I didn't enjoy it much.

How about a little Coca to boost the spirit? The "Coca tea" or "mate de coca" is a traditional drink in the Andes.

You can try Bubble tea made from Tapioca, the processed root of the Cassava plant.

All these links are giving me headaches, but there is more! The stuff above is just the tip of the iceberg, or the most famous plant infusions that are known as tea, because there are all the other plant infusions that are covered by the more generic term "Herbal tea". On that particular page you can find over 60 herbal infusions not made from the tea plant, including mate.

Please follow the plethora of links as I can assure you you will find a lot of interesting things there. This also got me thinking of the way the markets are functioning right now. I drank about every possible tea I could commercially find without looking too deep and I've only experienced tea and mate infusions. How about all the others? When will I be able to drink tapioca tea or coca tea? The plant itself is not illegal! Perhaps deeper digging in the commercial part of the Internet will help me find sources for some of the drinks above. Also, if I only had the time, I would try to learn about herbalism.

Eh, enough of this. Now I must add the images to the post and hopefully someone will read it.