Friday, December 7, 2007

Sorting Generic List in C#

You can sort a generic List in C# using different methods. Here I cover only two options which I found them most handy. The third option is to put the method into a class that implements the IComparer interface.




using System;
using System.Collections.Generic;

public class SortingList
{
/// <summary>
/// SortingList: This snippet code demonstrates the delegate method of sorting lists
/// I define an Item type having some fields and sort based on a preferred field
/// To do so I need to implement a method would be called during the sort action for each pair.
///
/// NOTE: You could also create a class implementing IComparer and use the class to pass to the Sort method.
///
/// Asghar Panahy
/// 07-12-2007
/// </summary>
public static void Main()
{
List
<Item> list = new List<Item>();

// Adding some dummy items
list.Add(new Item("6", " Asghar 1"));
list.Add(
new Item("5", " Asghar 2"));
list.Add(
new Item("3", " Asghar 3"));
list.Add(
new Item("4", " Asghar 4"));
list.Add(
new Item("2", " Asghar 5"));
list.Add(
new Item("1", " Asghar 6"));

Console.WriteLine(
"Dumping the list:");
DumpList(list);

// Sorting it by ID
list.Sort(SortByID);

Console.WriteLine(
"Dumping the list:");
DumpList(list);

// Second Option, using anonimous methods
// Sorting it by Birthday
list.Sort(
delegate (Item i1, Item i2)
{
return i1.Birthday.CompareTo(i2.Birthday);
}
);

Console.WriteLine(
"Dumping the list:");
DumpList(list);

// Wait for response before closing it
Console.ReadLine();

}
public static int SortByID(Item s1, Item s2)
{
return s1.ID.CompareTo(s2.ID);
}

public static void DumpList(List<Item> list)
{
foreach(Item l in list)
{
Console.WriteLine(l);
}
}

}

// Sample Class
public class Item
{
public Item(string id, string name)
{
this.ID = id;
this.Name = name;
this.Birthday = DateTime.Now;
}
public string Name;
public string ID;
public DateTime Birthday;
public override string ToString()
{
return String.Format("{0} is born on {1}", this.Name, this.Birthday.ToLocalTime());
}
}
}



Thursday, November 29, 2007

Characteristics of a Leader

The following is coted from the book Analyzing Requirements and Defining Solution Architectures.

Finding Effective Leaders

For the person in charge of putting together a project team, the first task is to decide who will work on the project. This seemingly simple (but more often complex) decision can dramatically affect the project's outcome.

Finding leaders within an organization is not a difficult process. By definition, leaders are recognized by those they work with. It's important to remember that we are talking about leaders here, not bosses. Every organization has its share of managers, directors, and so on, but the hierarchical structure of an organization does not determine who the true leaders are. Actions and characteristics, rather than job titles, identify leaders.

Why do we need leaders? Because we have so many followers. It's important to realize that labeling people as leaders and followers does not imply a value judgment. We must have leaders to be successful, but we must also have followers. Leaders provide direction for the team. Followers get the work done. The team needs to strike a balance between its leaders and followers. It must decide what to do and then must do it, so both leaders and followers are equally important and valuable. An absence of either leaders or followers will hinder the project's success.

Certain characteristics are present in many leaders. Common qualities of leaders include:

  • Understanding and meeting the needs of others.
  • Communicating well with groups and individuals.
  • Earning the respect of internal and external customers.
  • Displaying commitment to well-defined purposes.
  • Making a positive difference.
  • Having confidence in his or her abilities.
  • Practicing good problem-solving skills.
  • Helping others to develop their skills.

Many people will read this list and say, "I do those things." More people will read this list and say, "I intend to do those things." But being a leader also means knowing the difference between intent and impact. When measuring their own success, people measure their intent; when measuring other people's success, they measure their impact. The impact that leaders have on others may or may not be their intent, and leaders' intent may not have the impact they were striving for. The proper way to measure people's leadership skills is by the impact they actually have, not by their intent. We can summarize this concept by saying, "Other people's perceptions are reality."

Total Participation in Design

Jim McCarthy summarizes the concept of total participation in design in Dynamics of Software Development:

The goal in any product design is to have the best ideas become the basis of the product. Everybody on the team should be working to accomplish that goal.

Each role participates in the generation of the Functional Specification because each role has a unique perspective of the design and tries to ensure that the design meets their role's objectives, as well as the project team's objectives.

 

Project Goals and Responsibilities


The folowing is coming from a paragraph in Chapter 3 of Analyzing Requirements and Defining Solution Architectures.


Specific responsibilities must be carried out and specific goals must be met in order for any project to be successful. These responsibilities and goals serve to provide continual direction for all the team members. Key project responsibilities and goals include the following:



  • Customer satisfaction Projects must meet the needs of their customers and users in order to be successful. It is possible to meet budget and time goals but still be unsuccessful because customer needs have not been met.

  • Delivery within project constraints Most projects measure success using "on time, on budget" metrics.

  • Delivery to specifications based on user requirements The Functional Specification describes in detail the deliverable to be provided by the team to the customer. This specification represents an agreement between the team and the customer as to what will be built, and constitutes the basis for "Doing what we say we will do."

  • Release after identifying and addressing all issues All software is delivered with defects. The team's goal is to ensure that those defects are identified and addressed before the product is released. Addressing defects can involve everything from fixing the defect in question to documenting work-around solutions. Delivering a known defect that has been addressed along with a work-around solution is preferable to delivering a product containing unidentified defects that may "surprise" the team and the customer later.

  • Enhanced user performance For a product to be successful, it must enhance the way that users work. Delivering a product that is rich in features and content but can't be used is considered a failure.

  • Smooth deployment and ongoing management The effectiveness of deployment directly affects the perceived quality of a product. For example, a faulty installation program may imply to users that the installed application is similarly faulty. The team must do more than simply deploy the product; it must deploy smoothly and then support and manage the product.

NOTE



Many factors can affect a project, some of which will constrain it. When the project team focuses on meeting the agreed-upon goals of the project and delivering the product on time, it ensures that the organization receives the right Return on Investment (ROI), which is the right product for the right price.


Goals and corresponding team roles:

Customer satisfaction by Product Management
Delivery within project constraints by Program Management
Delivery to product specifications by Development
Release after identifying and addressing all issues by Testing
Enhanced user performance by User Education
Smooth deployment and ongoing management by Logistics Management


Tuesday, November 27, 2007

Anonimous Functions in C# 3.0

These parts are coming from the Language Specification document:

x => x + 1 // Implicitly typed, expression body
x => { return x + 1; } // Implicitly typed, statement body
(int x) => x + 1 // Explicitly typed, expression body
(int x) => { return x + 1; } // Explicitly typed, statement body
(x, y) => x * y // Multiple parameters
() => Console.WriteLine() // No parameters
delegate (int x) { return x + 1; } // Anonymous method expression
delegate { return 1 + 1; } // Parameter list omitted

// Example:
delegate bool Filter(int i);
void F() {
Filter f = (int n) => n < 0;
list.FindAll(f);
}

delegate void D();
void F() {
int n;
D d = () => { n = 1; };
d();

// Error, n is not definitely assigned
Console.WriteLine(n);
}

Monday, November 12, 2007

Distinguish Design time in ASP.NET

From MSDN site:

The easiest method to check if the control is at design mode is simply to check the current HttpContext. If this variable returns Nothing, then the control is in design mode.


Private Function IsDesignMode() As Boolean
Try

If HttpContext.Current Is Nothing Then

mboolDesignMode
= True

Else

mboolDesignMode
= False

End If

Return
mboolDesignMode

Catch

Throw


End Try


End Function

Tuesday, October 30, 2007

Cannot modify members of 'item' because it is a 'foreach iteration variable'

 I had a compile time issue with using my custom list. The code simply looks like the following:

 

foreach (ItemType item in listOfItems)

    item.CustomAccessor = "value";

 

And compiler complains with error:

            Cannot modify members of 'item' because it is a 'foreach iteration variable'

 

This is because the ItemType is defined as a  struct and not as a class. Doing so the iteration of foreach will result to some copies of the heap that are not reflecting the real objects. The question that has often been asked is why did you define your ItemType as struct and not as a class.... which I will answer it in other discussion.

  

Thursday, October 25, 2007

Zip a folder using SharpZipLib assembly in C#

There are several ways of zipping files. One way I started was to copy the files in the folder into an already existing zip file using a vb script. This was going fine until we had the request to delete the files when the process is done. Unfortunately the zip process thought it was completed and so the delete could start which caused the files be removed before taking the chance to be zipped.

My second attempt is this small c# script that is runnable in both frameworks 1.1 and 2.0. It uses a free open software called ZipLib that I have downloaded it from their website.

In this library they have several ways of doing the same thing. Adding files one by one was my preferred option for this particular problem but I had an issue with Windows XP not willing to show the content of the zip file whislt the file is unzippable. So I had to come up with this fast solution.

This small program is using a fast class for doing regular things like I wanted.

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Zip;
using ICSharpCode.SharpZipLib.Checksums;

namespace ZipFolder
{
/// <summary>
/// This small program is a command line application that takes two parameters.
/// If you don't provide any parameter it will then show the syntax.
/// The aim of this class is to zip a folder with all its contents into a small zip file.
/// Notice that you can call it to zip the current folder but the destination may not be
/// within the source folder.
///
/// By Asghar Panahy
/// 25-oct-2007
///
/// </summary>
class Program
{
/// <summary>
/// Expects exactly zero or two parameters
/// </summary>
[STAThread]
static void Main(string[] args)
{
if (args.Length <2)
{
DumpSyntaxt();
return;
}

// Get the parameters
string fileName = args[0];
string path = args[1];

Console.Write(String.Format("Searching for files in {0}", path));

FastZip fZip = new FastZip();
fZip.CreateZip(fileName, path, true, "");// Still need to figure out how
he filter works!?!?!
}

private static void DumpSyntaxt()
{
Console.WriteLine("Syntaxt: Zipper.exe <zipFile>
lt;FolderPath>
");
Console.WriteLine("Exemple: Zipper.exe ..\test.zip . ");
}
}
}

Thursday, October 18, 2007

Abstract versus Interface

An article on the MSDN describes a summary of both the definitions. Although the article is a bit old (2003) and it compares C# with C++ it still provides a good start.

On the Code Project I found a nice article written by Rahman Mahmoodi where her has a nice comparisson for these two definitions. Another article on the Code Project which seems even more in dept about abstract class is written by Jayababu.


Some important points about Abstract classes


· In contrary to other object oriented languages like JAVA, you can not inherit from more than one abstract class

· you can not instanciate them or you get a Compiler Error

· An abstract class may have a non-abstract constructor implementation.

· they might have (also) non-abstract methods having implementation. these non-abstract methods are callable from the

abstract class AbstractClass
{
public void NonAbstractMethod()
{
Console.WriteLine("
You can call a non-abstract method which is implemented within the abstract method.");
}
}

· You can reimplement the non-abstract method but it would be called by the class internally or any object of that type. If you define an object of abstract type and you instanciate the derived class you still call the implementation within the abstract class. To get the reimplementation you need to instanciate the class using a reference of type of the derived class. For example defining the following in the derived class:

public new void NonAbstractMethod()
{
Console.WriteLine("
This is new implementation of the non-abstract method.");
}


and calling it like this

// Will call the original implementation
AbstractClass obj = new InheritedClass();
obj.NonAbstractMethod();

// Will call the re-implementation
InheritedClass obj2 = new InheritedClass();
obj2.NonAbstractMethod();


· In your derrived class you need to ovreride all the abstract methods.

public override void OverrideThis()
{
Console.WriteLine("
You have to implement an abstract method using the override key");
}



· An abstract method can not be marked as static, compile error.

· You can have static and non-static fields in an abstract class:

public static int count = 1;
public int InstCount = 1;

public
AbstractClass()
{
count++;
InstCount++;
}

but when instanciating two objects of the derived class and verify the value of the fields:

Console.WriteLine("Static field is " + AbstractClass.count);
Console.WriteLine("
Instance counter is " + obj1.InstCount);
Console.WriteLine("
Instance counter is " + obj2.InstCount);

output:

Static field is 3
Instance counter is 2
Instance counter is 2



The Differences



· An inheritted class cannot have multiple base classes: compiler error.

· An abstract class can define a default implementation (using a non-abstract method) and that will not force the derived classes to reimplement it whereas an interface can not have any implementation at all.

· Interfaces can not contain fields; compile error.

· An interface is like a contract. Once the contract changes all the classes implementing it need to change whereas an abstract class is like a common code for all the classeds and you might introduce the new method as a non-abstract method and give a default implementation. This could be seen as a pro or con. In some situations it is required to force all the contract holders to apply on the new method and in other cases you want to have this new feature for some of the types while the rest migh follow later. (a good question would be why is the new method part of the abstract class and not introduced as a new contract)

·

Tuesday, October 16, 2007

How to Transform A DataSet using Xml and Xslt in .Net 2.0

// Creating DOM Document
XmlDocument doc = new XmlDocument();

// Get hold of the XML string from the dataset
doc.LoadXml(ds.GetXml());

//Load XSL and Tranform
XslCompiledTransform myXslTrans = new XslCompiledTransform();
string path = Directory.GetCurrentDirectory();
myXslTrans.Load(path + @"\PrintView.xslt");

// Using a StringWriter for Streaming part
StringWriter stringWriter = new StringWriter();

// The actual transformation
myXslTrans.Transform(doc.DocumentElement, null, stringWriter);
stringWriter.Flush();

// Consuming the transformed results
webBrowser1.Document.Write(stringWriter.ToString());

//doc.Save("Example.xml");

Attributes to consider applying when writing a custom control

The original author published this : Eilon Lipton's Blog

 

Almost every custom control has at least one additional public property, and that public property as well as the control itself should probably have at least a few attributes applied to them. Attributes tell the designer host (Visual Studio) or the parser (ASP.NET) interesting things about your control that might not be evident from just its name and its type. Launch any decent class browser tool and you'll see that every control that shipped in ASP.NET and ASP.NET AJAX has several attributes on it as well as their properties and events.

By applying the proper set of attributes you can significantly increase the usefulness of your control in several ways. For example, the DescriptionAttribute provides helpful text to the person designing the page. The ValidationPropertyAttribute is required when the person designing the page wants to validate the value of your control. Following is a list of the most useful and important attributes you can apply to your control and its properties and events.

Control attributes:

  • ControlValueProperty
     - Used by data source parameters to get the "intrinsic" value of the control. For example, DropDownList's "intrinsic" value is its SelectedValue property.
  • DefaultEvent
     - Set the event for which to create an event handler when double clicking the control in the designer.
  • DefaultProperty
     - Set the default selected property in the designer's property grid.
  • NonVisualControl
     - Hide the control at design time when "Non Visual Controls" is unchecked from the View menu.
  • ParseChildren
     - The full name is really "parse children as properties".
     - Set to true if the inner contents of the control represent properties as opposed to child controls.
     - True by default on controls deriving from WebControl; false by default otherwise.
  • PersistChildren
     - The full name is really "persist child controls".
     - Set to true if the designer should persist child controls as the inner contents.
     - False by default on controls deriving from WebControl; true by default otherwise.
     - 99.9% of the time PersistChildren has the opposite value of ParseChildren.
  • SupportsEventValidation
     - Indicates that the control's client-side calls to __doPostBack() should be validated on the server for security purposes.
  • Themable
     - Indicates that by default all the control's properties can be customized via themes. Individual properties can also be marked with this attribute to override the behavior.
     - True by default for controls that derive from WebControl.
  • ValidationProperty
     - Required when a control can be validated.
     - Somewhat similar to the ControlValueProperty in that they often point at the same property.
  • ViewStateModeById
     - Indicates that viewstate should be loaded based on control IDs as opposed to being loaded based on the index of the control in the child controls collection.

Property attributes:

  • Bindable
     - Indicates at design time only whether the property should appear by default in the Edit Databindings dialog.
  • Browsable
     - Indicates whether the property is visible in the property grid at design time.
  • Category
     - Determines in which category the property will appear when the property grid is in category mode.
  • DefaultValue
     - Get-only property: Since get-only properties are never persisted anyway, no default value is needed.
     - Get/Set value type property: Must be set.
     - Get/Set reference type property: Must be null so that it shows up as non-bold in the property grid.
  • Description
     - Determines the help text that will show in the property grid's lower help panel.
  • DesignerSerializationVisibility
     - Controls whether the property is persisted in the markup (see also PersistenceMode).
     - Use this to prevent get/set properties from being persisted at all.
  • EditorBrowsable
     - Affects whether the property appears in Intellisense.
  • IDReferenceProperty
     - Specifies that the property represents a control ID, and optionally the type of the target control. Not used by Visual Studio 2005.
  • MergableProperty
     - Affects whether the property shows up in the property grid when multiple controls are selected.
     - If the property is Browsable and is a reference type then set Mergable=false (except immutable reference types, such as string).
  • PersistenceMode
     - Controls how the property is persisted in the markup.
     - Simple-valued properties should use the default, which is Attribute.
     - Collection, template, and complex (e.g. styles) should use InnerProperty.
     - InnerDefaultProperty should never be used since it causes compatibility problems. For example, if in the next version of your control you want another inner property, it won't work properly.
     - EncodedInnerDefaultProperty should also rarely be used for similar reasons as InnerDefaultProperty.
     - In ASP.NET 2.0 support was added for strings to be InnerProperties, which is good for large multi-line string values, such as XmlDataSource's Data property.
  • Themable
     - Overrides the value of the attribute on the control to determine whether the property can be customized via themes.

Event attributes:

  • Browsable
     - Same as properties.
  • Category
     - Same as properties.
  • Description
     - Same as properties.
  • EditorBrowsable
     - Same as properties.

 

Friday, August 31, 2007

Customize attachment settings in outlook

I got a mail in my outlook and the application didn't let me open the attachment because it might be unsecure. The mail was from a know person and I want to access the attachment file. It appears that you can override the security level as described by Microsoft ( Customize attachment settings in Outlook 2007) and let some file types allowed to be opened.
 
To do this you have to tell the outlook which types of files are allowed. You do it in the registry:
HKCU\Software\Microsoft\Office\12.0\Outlook\Security\Level1Remove
 
You simply mention the extentions seporated by a semicolon like this one :
pts;bat;reg;vbs
 
 

Tuesday, August 21, 2007

Read/Write files from/to an Image field in SQL-Server

In this example I have a table called Attachment having a field of time Image which holds binary value. In this field I am going to put any type of file in a byte array and read it back. I have defined a class called Attachment to read and write the records. This class has a variable called Data which is defined as byte[]


Read Image Field


This example passes a reference to an object called record of type Attachment. The record object has an attribute called Data where the attachment file will be streamed into it.


/// <summary>
/// Read a TestLog record identified by the given parameter
/// </summary>
/// <param name="id">the record key</param>
/// <returns>a Attachment object that maps to the record</returns>
public static void Read(Attachment record)
{


if (record.Id < 1)
throw new ApplicationException("Invalid Record ID");

using (SqlConnection sqlConnection1 = Connection)
{
SqlCommand cmd
= sqlConnection1.CreateCommand();
cmd.CommandType
= CommandType.Text;
cmd.CommandText
= "SELECT TestLogId, Name, Description, CreatedBy, CreateDate, Data FROM Attachment WHERE ID=@Id";

SqlParameter par
= new SqlParameter("@Id", SqlDbType.Int);
par.Value
= record.Id;
cmd.Parameters.Add(par);


sqlConnection1.Open();
SqlDataReader dr
= cmd.ExecuteReader();
if (!dr.HasRows)
throw new ApplicationException(String.Format("Could not find TestLog '{0}'.", record.Id));

dr.Read();

if (!dr.IsDBNull(0))
record.TestLogID
= dr.GetInt32(0);
if (!dr.IsDBNull(1))
record.Name
= dr.GetString(1).TrimEnd();
if (!dr.IsDBNull(2))
record.Description
= dr.GetString(2).TrimEnd();
if (!dr.IsDBNull(3))
record.CreatedBy
= dr.GetString(3).TrimEnd();
if (!dr.IsDBNull(4))
record.CreateDate
= dr.GetDateTime(4);

// Read the bytes into the Data attribute of the record
int PictureCol = 5; // the column # of the BLOB field
record.Data = new Byte[(dr.GetBytes(PictureCol, 0, null, 0, int.MaxValue))];
dr.GetBytes(PictureCol,
0, record.Data, 0, record.Data.Length);

dr.Close();
sqlConnection1.Close();
}
}

Write File into the record



/// <summary>
/// Save the Attachment record. If Id doesn't exist, it will create a new one, otherwise it will update.
/// </summary>
/// <param name="record">the attachment record to save</param>
public static void Save(Attachment record)
{

using (SqlConnection sqlConnection1 = Connection)
{
SqlCommand cmd
= sqlConnection1.CreateCommand();
cmd.CommandType
= CommandType.StoredProcedure;
cmd.CommandText
= "SaveAttachment";

#region Add the input parameter and set its value

SqlParameter par
= new SqlParameter("@TestLogId", SqlDbType.Int);
par.Value
= record.TestLogID;
cmd.Parameters.Add(par);

par
= new SqlParameter("@Name", SqlDbType.NVarChar, 128);
par.Value
= record.Name;
cmd.Parameters.Add(par);

par
= new SqlParameter("@Description", SqlDbType.NVarChar, 320);
par.Value
= record.Description;
cmd.Parameters.Add(par);

par
= new SqlParameter("@Data", SqlDbType.VarBinary, record.Data.Length);
par.Value
= record.Data;
cmd.Parameters.Add(par);

#endregion

// Add the output parameter
par = new SqlParameter("@Id", SqlDbType.Int, 4);
par.Direction
= ParameterDirection.InputOutput;
par.Value
= record.Id;
cmd.Parameters.Add(par);

sqlConnection1.Open();
cmd.ExecuteNonQuery();
int id = Int32.Parse(cmd.Parameters["@ID"].Value.ToString());
record.Id
= id;
sqlConnection1.Close();
}
}

Read the file into the variable




/// <summary>
/// Read the file into the Data field
/// </summary>
/// <param name="path">A valid path to the file</param>
public void ReadFromFile(string path)
{
System.IO.FileStream fs
=
new System.IO.FileStream(path, System.IO.FileMode.Open, System.IO.FileAccess.Read);

this.data = new Byte[fs.Length];
fs.Read(
this.data, 0, this.data.Length);
fs.Close();
}


Write the byte array to a File


This simple method is using the name of the file as is stored in the attachment record to save in the location specified by parameter.


/// <summary>
/// Save the content into a file
/// </summary>
/// <param name="path">the full path to write to</param>
public void SaveToFile(string path)
{
if (path.EndsWith("\\"))
path
+= "\\";

string DestFilePath = path + this.name;
System.IO.FileStream fs
=
new System.IO.FileStream(DestFilePath, System.IO.FileMode.Create, System.IO.FileAccess.Write);

fs.Write(
this.data, 0, this.data.Length);
fs.Close();

}

Monday, August 20, 2007

Merging Menu and Toolbar to MDI Form

I have a form that it is used both stand alone and within an MDI from. When used in an MDI form I wanted to move the menu's and toolbars to the shared placed on the MDI form whereas using it on a standalone case I had no option than having it on the owner form.

To establish this behavior I had to implement the activate and deactivate methods to make the toolstrip and menu strip, which hold the toolbar items and menu items, invisible and move the items to the new container. This is a stait forward solution as illustrated below:



private void OnFormActivate(object sender, EventArgs e)
{
try
{
// Get the parent
Form parent = this.MdiParent;
if (parent == null)
return;

// Get the toolbar on the parent by name
string targetToolbar = "toolStrip"; // using the name of the control
if (!parent.Controls.ContainsKey(targetToolbar))
return;
ToolStrip target
= parent.Controls[targetToolbar] as ToolStrip;
if (target == null)
return;

ToolStripManager.Merge(
this.toolStrip1, target);

// Hide the original container
this.toolStrip1.Visible = false;
this.menuStrip1.Visible = false;
SetToolbarCaption();
}
catch { } // Any exception will cause the toolbar to remain on its oroginal parent
}
private void OnFormDeactivate(object sender, EventArgs e)
{
try
{
// Get the parent
Form parent = this.MdiParent;
if (parent == null)
return;

// Get the toolbar on the parent by name
string targetToolbar = "toolStrip";
if (!parent.Controls.ContainsKey(targetToolbar))
return;

// Double check
ToolStrip target = parent.Controls[targetToolbar] as ToolStrip;
if (target == null)
return;

// Actual Merge Revert of the contents of the toolStrip
ToolStripManager.RevertMerge(target, this.toolStrip1);

// Keep hiding the original container
this.toolStrip1.Visible = false;
}
catch { }
}


All I need to do next is to wire these events to the propper events: FormActivate and Deactivate.

Thursday, August 9, 2007

Welcome

I have lost my blogs that I used to store on http://blogs.wdevs.com/a.Panahy/ The site is just gone down and made me desporate. I decided to start my own. Thanks to NiMS I got this subdomain up and running in short time and the idea is to build up my personal blogs in this blog site.
The site will start with my technical blogs to support my (leaking) memory. I might have a copy of them on other online site (maybe on codeproject.com or msn.Live) and later on probably some private blogs.
for now all I want to say is yoopy