You could also simply download the plugin I wrote for this as well. Although I have submitted it to Wordpress.org they have not posted it yet so here is a link in the mean time. Please note the plugin is a little more customizable then the code below.

-Auto Keywords and Description Generator-

//Code

<?php
$keywords = "";
$description = "";

if(is_home() || is_front_page())
{
	//LOAD KEYWORDS FROM USER SPECIFIED STRING
	$keywords = "Insert your homepage keywords here";

	//LOAD DESCRIPTION FROM BLOGINFO
	$description = bloginfo('description');
}
elseif(is_single())
{
	//LOAD POST TITLE AS DESCRIPTION
	$description = $post->post_title;

	//BUILD LIST OF KEYWORDS FROM TAGS
	$tags = wp_get_post_tags($post->ID);
	foreach($tags as $tag)
		$keywords = $keywords . $tag->name . ", ";
}
elseif(is_category())
{
	//LOAD CATEGORY DESCRIPTION
	$keywords = single_cat_title('', false);
	$description = category_description();
}
?>
<meta name="keywords" content="<?php echo $keywords ?>" />
<meta name="description" content="<?php echo $description ?>" />

//Code

        /// <summary>
        /// TRUNCATES A STRING PREFERRING WHOLE WORD OVER NON WHOLE WORD
        /// </summary>
        /// <param name="s">INCOMING STRING TO TRUNCATE</param>
        /// <param name="len">LENGTH IN WHICH TO TRUNCATE TO</param>
        /// <param name="postTruncate">ANYTHING TO ADD TO A TRUNCATED STRING SUCH AS ...</param>
        /// <returns>TRUNCATED STRING WITH POST TRUNCATE ADDED TO IT</returns>
        public static string Truncate(this string s, int len, string postTruncate)
        {
            //IF THE STRING IS SMALLER THEN THE LENGTH JUST RETURN THE STRING
            if (s == null || s.Length < len)
                return s;
            else
            {
                //INCASE NULL HAS BEEN PASSED IN CHANGE IT TO EMPTY STRING SO IT HAS A COUNT
                if (postTruncate == null)
                    postTruncate = string.Empty;

                //RETURN THE TRUNCATED STRING BACK TO CALLING FUNCTION
                string tmpReturn = string.Concat(Regex.Match(String.Concat(s, " "), string.Format("^(?<tmpMatch>.{{0,{0}}})\\s", len)).Groups["tmpMatch"].Value, postTruncate);

                //IF THE WHOLE WORD TRUNCATE WORKED THEN USE IT OTHERWISE USE NON WHOLE WORD TRUNCATE
                if (tmpReturn != postTruncate)
                    return tmpReturn;
                else
                    return string.Concat(Regex.Match(String.Concat(s, " "), string.Format("^(?<tmpMatch>.{{0,{0}}})", len)).Groups["tmpMatch"].Value, postTruncate);
            }
        }

//Usage

    class Program
    {
        static void Main(string[] args)
        {
            //OUTPUT WILL BE "Hello, World..."
            Console.WriteLine("Hello, World this is some long text to truncate".Truncate(15, "..."));
            Console.ReadLine();
        }
    }

//Function

        /// <summary>
        /// FUNCTION FOR TESTING PASSWORD COMPLEXITY
        /// </summary>
        /// <param name="s">INCOMING PASSWORD TO TEST</param>
        /// <param name="minLength">MIN LENGTH OF PASSWORD</param>
        /// <param name="maxLength">MAX LENGTH OF PASSWORD</param>
        /// <param name="rule">COMPARISON FLAGS CAN BE ANY COMBINATION OF THE FOLLOWING - UPPER, LOWER, NUMERIC, SPECIAL</param>
        /// <returns>TRUE OR FALSE IF THE PASSWORD PASSES OR NOT</returns>
        static bool ValidatePasswordComplexity(string s, int minLength, int maxLength, PasswordRules rule)
        {
            //CONSTANTS FOR COMPARISON GROUPS
            const string UPPER = "(?=.*[A-Z])";
            const string LOWER = "(?=.*[a-z])";
            const string NUMERIC = "(?=.*[0-9])";
            const string SPECIAL = "(?=.*[!@#$%^&*()<>])";

            //CREATE A NEW VAR TO HOLD THE COMPARE STRING WHILE ITS ASSEMBLED
            StringBuilder tmpCompare = new StringBuilder("^");

            //CHECK IF UPPER IS A REQUIREMENT
            if ((rule & PasswordRules.Upper) == PasswordRules.Upper)
                tmpCompare.Append(UPPER);

            //CHECK IF LOWER IS A REQUIREMENT
            if ((rule & PasswordRules.Lower) == PasswordRules.Lower)
                tmpCompare.Append(LOWER);

            //CHECK IF NUMERIC IS A REQUIREMENT
            if ((rule & PasswordRules.Numeric) == PasswordRules.Numeric)
                tmpCompare.Append(NUMERIC);

            //CHECK IF SPECIAL IS A REQUIREMENT
            if ((rule & PasswordRules.Special) == PasswordRules.Special)
                tmpCompare.Append(SPECIAL);

            //APPEND THE LENGTH REQUIREMENTS
            tmpCompare.Append(string.Format(".{{{0},{1}}}", minLength, maxLength));

            //RETURN THE RESULT OF THE COMPARISON
            return Regex.Match(s, tmpCompare.ToString()).Success;
        }

        /// <summary>
        /// ERNUMERATIONS FOR PASSWORD COMPLEXITY TESTING
        /// </summary>
        [Flags]
        public enum PasswordRules
        {
            Upper = 1,
            Lower = 2,
            Numeric = 4,
            Special = 8,
        }

//Usage

        /// <summary>
        /// MAIN APPLICATION ENTRY POINT
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //SOMETHING TO COMPARE
            string pwd = "Password1";

            //TWO DIFFERENT SAMPLES TO SHOW THE PASSWORD MEETS THE REQUIREMENTS IF YOU ARE NOT LOOKING FOR A SPECIAL CHARACTER
            //BUT FAILS ONCE THE SPECIAL REQUIREMENT IS ADDED TO THE PARAMETER
            Console.WriteLine("{0}: {1}", pwd, ValidatePasswordComplexity(pwd, 6, 15, PasswordRules.Upper | PasswordRules.Lower | PasswordRules.Numeric));
            Console.WriteLine("{0}: {1}", pwd, ValidatePasswordComplexity(pwd, 6, 15, PasswordRules.Upper | PasswordRules.Lower | PasswordRules.Numeric | PasswordRules.Special));

            //WAIT FOR USER INPUT
            Console.ReadLine();
        }

//Code

        /// <summary>
        /// MAIN TO HUMAN READABLE FUNCTION TO CONVERT DOUBLES INTO XB, XKB, XMB, XGB
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this double x)
        {
            //CONSTANTS FOR SIZING
            double KB = 1024;
            double MB = 1024 * KB;
            double GB = 1024 * MB;

            if (x < KB)
                return string.Format("{0}B", x);
            else if (x < MB)
            {
                return string.Format("{0:0.##}KB", x / KB);
            }
            else if (x < GB)
            {
                return string.Format("{0:0.##}MB", x / MB);
            }
            else if (x >= GB)
            {
                return string.Format("{0:0.##}GB", x / GB);
            }
            else
            {
                //HACK: GET RID OF COMPILER ERROR BECAUSE IT BELEIVES NOT ALL PATHS RETURN A VALUE
                return null;
            }
        }

        /// <summary>
        /// EXTENSION FOR LONG TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this long x)
        {
            return ToHumanReadable((double)x);
        }

        /// <summary>
        /// EXTENSION FOR INT TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this int x)
        {
            return ToHumanReadable((double)x);
        }

        /// <summary>
        /// EXTENSION FOR SINGLE TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this Single x)
        {
            return ToHumanReadable((double)x);
        }

//Application

using System;
using System.IO;
using System.IO.Pipes;

class Program
{
    /// <summary>
    /// MAIN APPLICATION THREAD
    /// </summary>
    /// <param name="args">NOTHING IS ACCEPTED HERE</param>
    static void Main(string[] args)
    {
        //HOLDS THE SECLECTION A USER MAKES AS TO WHAT THEY WANT TO RUN
        string tmpSelection = string.Empty;

        //ASK THE USER WHAT THEY WANT TO DO
        Console.Write("Please Enter A Selection 1(Server) or 2(Client): ");
        tmpSelection = Console.ReadLine();

        //CLEAR THE SCREEN AND BEGIN RUNNING THE USERS SELECTION
        Console.Clear();
        if (tmpSelection == "1")
        {
            //START A PIPE SERVER
            pipeServer();
        }
        else if (tmpSelection == "2")
        {
            //START A PIPE CLIENT
            pipeClient();
        }
        else
        {
            //LET THE USER KNOW THEY HAVE MADE AN INVALID SELECTION
            Console.WriteLine("Invalid selection made.  This app will now close.");
            Console.ReadLine();
        }
    }

    /// <summary>
    /// RUNS A PIPE CLIENT FOR SENDING MESSAGES
    /// </summary>
    private static void pipeClient()
    {
        //LET THE USER KNOW WHAT IS GOING ON
        Console.WriteLine("Starting Client!");

        //LOOP FOREVER FOR TESTING PURPOSES
        while (true)
        {
            //CREATE A CONNECTION TO A NAMED PIPE ON THE LOCAL MACHINE NAMED testPipe
            using (NamedPipeClientStream tmpPipe = new NamedPipeClientStream(".", "testPipe", PipeDirection.Out))
            {
                string tmpSendMessage;

                //GET SOME TEXT TO SEND THROUGH THE PIPE
                Console.Write("Enter Some Text To Send: ");
                tmpSendMessage = Console.ReadLine();

                //SEND THE MESSAGE THROUGH THE PIPE
                tmpPipe.Connect();
                using (TextWriter tmpWriter = new StreamWriter(tmpPipe))
                {
                    tmpWriter.WriteLine(tmpSendMessage);
                }
            }
        }
    }

    /// <summary>
    /// RUNS A PIPE SERVER FOR ACCEPTING MESSAGES
    /// </summary>
    private static void pipeServer()
    {
        //LET THE USER KNOW WHAT IS GOING ON
        Console.WriteLine("Starting Server!");

        //LOOP FOREVER FOR TESTING PURPOSES
        while (true)
        {
            //CREATE A NAMED PIPE ON THE LOCAL MACHINE NAMED testPipe
            using (NamedPipeServerStream tmpPipe = new NamedPipeServerStream("testPipe", PipeDirection.In))
            {
                //READ THE DATA ON THE PIPE
                tmpPipe.WaitForConnection();
                using (TextReader tmpReader = new StreamReader(tmpPipe))
                {
                    Console.WriteLine(tmpReader.ReadLine());
                }
            }
        }
    }
}

via 3D Projection on Buildings.

//Class

    public static class AssemblyBuilder
    {
        /// <summary>
        /// COMPILE CODE INTO A MEMORY DLL
        /// </summary>
        /// <param name="Code">PLAIN TEXT OF THE CODE TO BE EXECUTED</param>
        /// <returns>MEMORY DLL OF COMPILED CODE</returns>
        static Assembly BuildAssembly(string Code)
        {
            CSharpCodeProvider tmpProvider = new CSharpCodeProvider();
            CompilerParameters tmpParams = new CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true };

            //ADD ANY ADDITIONAL REFERENCES YOU MAY NEED HERE
            tmpParams.ReferencedAssemblies.Add("System.dll");
            tmpParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");

            //ATTEMPT TO COMPILE THE CODE INTO A MEMORY DLL
            CompilerResults tmpResults = tmpProvider.CompileAssemblyFromSource(tmpParams, Code);

            //IF IT WORKED THEN RETURN THE COMPILED ASSEMBLY ELSE RETURN NOTHING
            if (!tmpResults.Errors.HasErrors)
                return tmpResults.CompiledAssembly;
            else
                return null;
        }

        /// <summary>
        /// COMPILE AND EXECUTE PLAIN TEXT AS THOUGH IT WERE A LOADED LIBRARY
        /// </summary>
        /// <param name="code">CODE TO COMPILE</param>
        /// <param name="namespacename">NAMESPACE INSIDE THE CODE FROM WHICH TO EXECUTE</param>
        /// <param name="classname">CLASS NAME INSIDE THE NAMESPACE FROM WHICH TO EXECUTE</param>
        /// <param name="functionname">FUNCTION TO EXECUTE INSIDE OF THE CLASS</param>
        /// <param name="isstatic">IS THE METHOD A STATIC METHOD OR AN INSTANCED METHOD</param>
        /// <param name="args">ARRAY OF ARGUMENTS TO BE PASSED INTO THE FUNCTION WE ARE CALLING</param>
        /// <returns>RETURNS ANY VALUE RETURNED BY THE FUNCTION THAT WAS CALLED</returns>
        public static object ExecuteCode(string code, string namespacename, string classname, string functionname, bool isstatic, params object[] args)
        {
            Type tmpType = null;
            object tmpInstance = null;
            Assembly tmpAsm = BuildAssembly(code);

            //CHECK TO VERIFY THE BUILDASSEMBLY WORKED
            if (tmpAsm != null)
            {
                //IF THIS IS A STATIC METHOD WE CAN CALL IT DIRECTLY OTHERWISE WE NEED TO CREATE AN INSTANCE OF THE LIBRARY FIRST
                if (isstatic)
                {
                    tmpType = tmpAsm.GetType(namespacename + "." + classname);
                }
                else
                {
                    tmpInstance = tmpAsm.CreateInstance(namespacename + "." + classname);
                    tmpType = tmpInstance.GetType();
                }

                //FIND THE METHOD WE WISH TO EXECUTE
                MethodInfo method = tmpType.GetMethod(functionname);

                //RETURN WHATEVER VALUE COMES BACK FROM THE FUNCTION CALL
                return method.Invoke(tmpInstance, args);
            }
            else
            {
                return null;
            }
        }
    }

//Usage

            string plainTextCode = "using System.Windows.Forms;namespace Test{public class Test	{public void Main(){MessageBox.Show(\"Testing!\", \"Test Title\");	}}}";
            AssemblyBuilder.ExecuteCode(plainTextCode, "Test", "Test", "Main", false, new object[]{});

//Class

    class ExecutionTimer
    {
        //PRIVATE VARIABLES FOR HOLDING THE TIME INFORMATION
        private long startTime;
        private long stopTime;

        //DEFAULT CONSTRUCTOR JUST CALLS THE START TIMER
        public ExecutionTimer()
        {
            StartTimer();
        }

        /// <summary>
        /// MARK THE START TIME FOR CALCULATIONS
        /// </summary>
        public void StartTimer()
        {
            startTime = DateTime.Now.Ticks;
        }

        /// <summary>
        /// MARK THE STOP TIME FOR CALCULATIONS
        /// </summary>
        public void StopTimer()
        {
            stopTime = DateTime.Now.Ticks;
        }

        /// <summary>
        /// DEFAULT OVERRIDE OF TOSTRING TO FORMAT THE OUTPUT AS A VALID TIME STRING
        /// </summary>
        /// <returns>FORMATTED TIME STRING IN FORMAT OF HH:MM:SS.MILISECONDS</returns>
        public override string ToString()
        {
            return ToString(1);
        }

        /// <summary>
        /// OUTPUT THE STRING USING AN AVERAGE COUNTER INCASE THE USER RAN THE TRACKING MORE THEN ONCE WE NEED TO AVG THE TIME
        /// </summary>
        /// <param name="avg">DIVISOR</param>
        /// <returns>FORMATTED TIME STRING IN FORMAT OF HH:MM:SS.MILISECONDS AVERAGED OVER X ATTEMPTS</returns>
        public string ToString(long avg)
        {
            //VERIFY THAT AVG IS A VALID VALUE
            if (avg == 0)
                throw new ArgumentException("Avg can not be 0", "avg");

            //RETURN THE FORMATTED STRING FROM THE NEW DATE
            return string.Format("{0:HH:mm:ss.ff}", new DateTime((stopTime - startTime) / avg));
        }
    }

//Usage

    class Program
    {
        static void Main(string[] args)
        {
            ExecutionTimer tmpTimer = new ExecutionTimer();
            System.Threading.Thread.Sleep(5500);
            tmpTimer.StopTimer();
        }
    }

//Code

        /// <summary>
        /// ENCRYPTS A STRING USING AES ENCRYPTION AND A PASSWORD
        /// </summary>
        /// <param name="s">INCOMING STRING TO ENCRYPT</param>
        /// <param name="password">PASSWORD TO USE FOR ENCRYPTION</param>
        /// <returns>BASE64 ENCODED ENCRYPTED STRING</returns>
        public static string EncryptString(this string s, string password)
        {
            //CREATE AN AES CRYPTOGRAPHY CLASS
            using (Aes tmpAes = AesCryptoServiceProvider.Create())
            {
                //CREATE A PASSWORD DERIVED BYTES CLASS TO CONVERT A SIMPLE PASSWORD INTO SOMETHING MORE COMPLEX
                PasswordDeriveBytes tmpPasswordBytes = new PasswordDeriveBytes(password.ToByteArray(), password.Reverse().ToByteArray());

                //CREATE A ICRYPTO TRANSFORM PROVIDER USING 256 BITS FOR THE KEY WHICH IS DERIVED FROM THE PASSWORD PASSED IN
                using (ICryptoTransform tmpCrypto = tmpAes.CreateEncryptor(tmpPasswordBytes.GetBytes(256 / 8), tmpPasswordBytes.GetBytes(16)))
                {
                    //CREATE A TEMPORARY MEMORY STREAM TO HOLD THE DATA WHICH IS BEING ENCRYPTED
                    using (MemoryStream tmpMemoryStream = new MemoryStream())
                    {
                        //CREATE THE CRYPTO STREAM WHICH WILL WRITE TO THE UNDERLYING MEMORY STREAM
                        using (CryptoStream tmpStream = new CryptoStream(tmpMemoryStream, tmpCrypto, CryptoStreamMode.Write))
                        {
                            tmpStream.Write(s.ToByteArray(), 0, s.Length);
                            tmpStream.Flush();
                        }

                        //CONVERT THE DATA TO A BASE64 STRING SO WE HAVE ALL VALID CHARACTERS IN THE STRING
                        return Convert.ToBase64String(tmpMemoryStream.ToArray());
                    }
                }
            }
        }

        /// <summary>
        /// DECRYPTS A BASE64 ENCODED STRING USING AES AND PASSWORD
        /// </summary>
        /// <param name="s">INCOMING BASE64 ENCODED STRING TO DECRYPT</param>
        /// <param name="password">PASSWORD USED DURING THE ENCRYPTION PROCESS TO REVERSE THE SEQUENCE</param>
        /// <returns>ORIGINAL STRING PRIOR TO ENCRYPTION</returns>
        public static string DecryptString(this string s, string password)
        {
            //CREATE AN AES CRYPTOGRAPHY CLASS
            using (Aes tmpAes = AesCryptoServiceProvider.Create())
            {
                //CREATE A PASSWORD DERIVED BYTES CLASS TO CONVERT A SIMPLE PASSWORD INTO SOMETHING MORE COMPLEX
                PasswordDeriveBytes tmpPasswordBytes = new PasswordDeriveBytes(password.ToByteArray(), password.Reverse().ToByteArray());

                //CREATE A ICRYPTO TRANSFORM PROVIDER USING 256 BITS FOR THE KEY WHICH IS DERIVED FROM THE PASSWORD PASSED IN
                using (ICryptoTransform tmpCrypto = tmpAes.CreateDecryptor(tmpPasswordBytes.GetBytes(256 / 8), tmpPasswordBytes.GetBytes(16)))
                {
                    //CREATE A MEMORY STREAM FROM THE BASE64 STRING WHICH IS BEING PASSED IN
                    using (MemoryStream tmpMemoryStream = new MemoryStream(Convert.FromBase64String(s)))
                    {
                        //CREATE A NEW STREAM WHICH WILL DECRYPT THE DATA AS WE READ IT
                        using (CryptoStream tmpStream = new CryptoStream(tmpMemoryStream, tmpCrypto, CryptoStreamMode.Read))
                        {
                            int readCount;
                            byte[] tmpBuffer = new byte[1024];
                            StringBuilder tmpReturn = new StringBuilder();

                            //CATCH THE ERROR INCASE THE PASSWORD IS INVALID
                            try
                            {
                                //AS LONG AS THEIR IS DATA ON THE STREAM KEEP READING
                                while ((readCount = tmpStream.Read(tmpBuffer, 0, tmpBuffer.Length)) != 0)
                                {
                                    tmpReturn.Append(tmpBuffer.Take(readCount).ToArray().ConvertToString());
                                }

                                //RETURN THE DECRYPTED STRING VALUE
                                return tmpReturn.ToString();
                            }
                            catch (CryptographicException ex)
                            {
                                return "";
                            }
                        }
                    }
                }
            }
        }

        #region "Supporting Extensions"
        /// <summary>
        /// CONVERT AN ARRAY OF BYTES INTO THE UTF8 STRING
        /// </summary>
        /// <param name="b">ARRAY OF BYTES COMING IN</param>
        /// <returns>STRING REPRESENTATION OF THE BYTES PASSED IN</returns>
        public static string ConvertToString(this byte[] b)
        {
            return System.Text.ASCIIEncoding.UTF8.GetString(b);
        }

        /// <summary>
        /// REVERSES A STRING
        /// </summary>
        /// <param name="s">INCOMING STRING TO REVERSE</param>
        /// <returns>REVERSED STRING</returns>
        public static string Reverse(this string s)
        {
            StringBuilder tmpReturn = new StringBuilder();

            //LOOP THROUGH EACH CHARACTER FROM BACK TO FRONT AND INSERT IT INTO THE BUILDER
            for (int i = s.Length - 1; i >= 0; i--)
                tmpReturn.Append(s[i]);

            //RETURN THE REVERSED STRING TO THE CALLING FUNCTION
            return tmpReturn.ToString();
        }

        /// <summary>
        /// CONVERTS A STRING INTO UTF8 ENCODED BYTE ARRAY
        /// </summary>
        /// <param name="s">INCOMING STRING TO CONVERT</param>
        /// <returns>BYTE ARRAY OF THE INCOMING STRING</returns>
        public static byte[] ToByteArray(this string s)
        {
            //CONVERT THE STRING TO A BYTE ARRAY
            return System.Text.ASCIIEncoding.UTF8.GetBytes(s);
        }
        #endregion

//Usage

    class Program
    {
        static void Main(string[] args)
        {
            string tmpEnc = "Hello, World!".EncryptString("password");
            string tmpDec = tmpEnc.DecryptString("password");

            Console.WriteLine("{0}\n{1}", tmpEnc, tmpDec);
            Console.ReadLine();
        }
    }