private static void Sort(List<int> integers)
        {
            foreach (int i in integers)
            {
                Thread t = new Thread(new ParameterizedThreadStart(display));
                t.Start(i);
            }
        }

        private static void display(object x)
        {
            int i = (int)x;
            Thread.Sleep(i * 100);
            Console.WriteLine(i);
        }

If all the stars align and your list is short enough this will sort properly!

*SHEERS*

I won’t go int too much detail at the moment, in future posts I will make sure to revisit everything shown here. This is more or less a test

“No major systems language has emerged in over a decade, but over that time the computing landscape has changed tremendously”

GOlang takes a fresh spin at something we are all familiar with, it does it with class and performance. I have recently had the chance to delve into the intricacies of GO for class and decided to dedicated part of my blog to it as a resource for future programmers.

I have acquired the ONLY GO Programming book available and will be posting a review shortly. I will also start to develop a library of simple examples to help everyone out!

GO’s official site is located at http://golang.org

The book which has been facilitated to me can be found at http://www.goprogrammingbook.com/

One of the things I have always done is provide extensive config files in XML format in order to alleviate having to modify the code when simple things change such as passwords, database names, host addresses etc. This has in my opinion always been a great venue to ensure maintainability and stability. But the big issue always was XML..

XML (Extensible Markup Language) is a general-purpose specification for creating custom markup languages.[1] It is classified as an extensible language, because it allows the user to define the mark-up elements. XML’s purpose is to aid information systems in sharing structured data, especially via the Internet, [2] to encode documents, and to serialize data; in the last context, it compares with text-based serialization languages such as JSON, YAML and S-Expressions. [3]
more…

The problem I’ve always had with XML is parsing the file; although the support for it and the built in tools have improved greatly over the past few years it still requires considerable amount of code in order to gather the data in some languages (C#), and another considerable amount of code in order to update or change the data in the file. When I was learning Object Oriented programming a while back we were introduced to the concept of Serialization

In computer science, in the context of data storage and transmission, serialization is the process of converting an object into a sequence of bits so that it can be stored on a storage medium (such as a file, or a memory buffer) or transmitted across a network connection link. When the resulting series of bits is reread according to the serialization format, it can be used to create a semantically identical clone of the original object. For many complex objects, such as those that make extensive use of references, this process is not straightforward.
more…

But like the Wikipedia definition above says “this process is not straightforward”, you used to have to define Interfaces and formats and if your object had any kind of list or array in it, you couldn’t use it unless you wanted to spend a considerable amount of time making it work.

While I was working on the practice projects I grew to hate Serialization and had not used it since. Yesterday in a fit of rage, because my XML config file was being stubborn I stumbled across an implementation that used a Serialized object for storing configuration. I was baffled by the ease in which this was accomplished and I immediately implemented it. Now it its extremely easy to add and remove config parameters from my program and at the same time I don’t have to worry about someone deleting or changing the config file since it is stored in binary and gets re-created if deleted.

In order to serialize an object your class must be declared as [Serializable] . After you have done this, the below example will take care of the serialization for you.

//Serialize an Object
FileStreamfs = new FileStream(@”prog.conf”, FileMode.Create); //Create new File where the object will live
BinaryFormatter bf = new BinaryFormatter(); //Create new BinaryFormatter to Serilize Object
bf.Serialize(fs, YOUROBJECT); //Serialize Object
fs.Close(); //Close File

//Deserialize
FileStreamfs = newFileStream(@”prog.conf”,FileMode.Open);  //Open File Containing Serialized Object
YOUROBJECT obj = (YOUROBJECT) (new BinaryFormatter().Deserialize(fs));
fs.Close(); //Close File

Remember to include the System.IO and System.Runtime.Serialization.Formatters.Binary libraries.