Μπορεί ένα βιβλίο να σου αλλάξει τον τρόπο σκέψης,
                           να σου φανερώσει "απλές" λύσεις σε "δύσκολα" προβλήματα,
                           να σε γεμίσει με χαρά και δέος για τη δύναμη της αφηρημένης σκέψης,
                           να σου αποκαλύψει την βαθιά σχέση της μαγείας με το λογισμικό,
                           να σε ταξιδέψει σε αιθέριους πλατωνικούς παραδείσους
                          ....                             
 
Πριν από χρονια, συνάντησα ένα τέτοιο βιβλίο...

Structure and Interpretation of Computer Programs

Ο Eric Meijer έχει βαλθεί να αλλάξει τον κόσμο του development... Πρώτα με το LINQ και τώρα με το Volta...

http://labs.live.com/volta/

Πολλές φορες, μέσα από την διαφορετικότητα μπορούμε να έχουμε μια ομορφότερη εικόνα για τον κόσμο...

Μέσα από την εκκεντρικότητα της pure & lazy Haskell, μπορούμε να δώσουμε εντυπωσιακές λύσεις σε δύσκολα προβλήματα.

Ένα κλασικό παράδειγμα είναι οι αριθμοί Hamming σε Haskell...
hamming = 1 : merge (map (2*) hamming) (merge (map (3*) hamming) (map (5*) hamming))

Clean, simple and elegant... Η ιδέα των infinite lists είναι γοητευτική, και σε συνδυασμό με την Haskell το αποτέλεσμα είναι αισθητικά άψογο.

Επειδή όμως δύσκολα θα γίνει mainstream η Haskell, ας δοκιμάσω να μεταφέρω κάποιες από αυτές τις ιδέες στην C#...
Μετά από πειραματισμό με κάποιες τεχνικές, κατέληξα σε αυτόν τον κώδικα...

public static IEnumerable<int> Hamming()
{
   yield return 1;
   var merge = Merge(Hamming().Select(n => n * 2),
                        Merge(Hamming().Select(n => n * 3), Hamming().Select(n => n * 5)));
   foreach(var number in merge)
      yield return number;
}

Το αποτέλεσμα με ικανοποιεί, και είναι "σχετικά" κοντά στην φιλοσοφία της Haskell

Happy coding

Edsger W. Dijkstra
"Elegance has the disadvantage that hard work is needed to achieve it and a good education to appreciate it."

Στο τελευταίο blog post του, o Jon Skeet παρουσίασε μια "πιθανή" υλοποίηση του Mandelbrot set σε Parallel LINQ.

Επηρεασμένος από το post, αποφάσισα να δοκιμάσω μια υλοποίηση της ιδέας, σαν proof of concept...

H μονη αλλαγή που χρειάζεται είναι πολύ απλή

var query = from row in Enumerable.Range(0,ImageHeight).ΤοParallel()
            from col in Enumerable.Range(0, ImageWidth) 
            select ComputeMandelbrotIndex(row, col);

byte[] data = query.ToArray();

Το αποτέλεσμα είναι ότι τώρα το Parallel MandelbrotGenerator εκτελείται στο μισό χρόνο... (τουλάχιστον στο dual core laptop μου)

Happy coding my friends

Πριν από κάποια χρονια, (όταν δούλευα στην exodus) είχα κάποιες πολύ ενδιαφέρουσες συζητήσεις με έναν fellow hacker, τον Τάσο Κουτσοβασίλη.

Κάναμε πολλές συζητήσεις περί γλωσσών προγραμματισμού και κλασικά ο Τάσος μου μιλούσε για την python και εγώ για την C++.

Μια μέρα ήρθε στο R&D (όπου δούλευα) και μου είπε για ένα νέο web app framework που δούλευε στον ελεύθερο χρόνο του... το έλεγε τότε entropy (τελικά ονομάστηκε Porcupine)!!!

Οι ιδέες του μου κίνησαν την προσοχή και με γέμισαν ενθουσιασμό... Θυμάμαι ότι ήταν full Ajax, Berkeley DB persistence και φυσικά ήταν όλο γραμμένο σε python.

(Δεν ήταν μονο ο DHH αγανακτισμένος με τις "χύμα" php σελίδες... Εμείς είχαμε "χύμα" asp σελίδες...)

Σύμφωνα με τον Τάσο
Η φιλοσοφία του είναι:
No postbacks
No viewstate
No ORM

Ήθελα από καιρό να γράψω για το Porcupine, και επιτέλους τα κατάφερα, με μια μικρή καθυστέρηση ενός έτους...

Happy coding φιλε Τάσο

Σήμερα είχα αρκετό χρόνο να ασχοληθώ με τo αγαπημένo μου pet project => Parallel LINQ

Μετά από ένα intense coding session, ολοκλήρωσα την ιδιότητα των LINQ queries για deferred execution. Θεώρησα απαραίτητο να υπάρχει deferred execution, έτσι ώστε να έχω τα ίδια execution semantics με το LINQ tο Objects.

Example:

var items = from value in numbers.ToParallel()
            where value.IsPrime()
            select value.ToBinary();

int count = items.Count(); // this point the query gets executed

Happy hacking

Σήμερα ολοκλήρωσα το απαραίτητο refactoring και την υλοποίηση της Parallel Reduce extension method.

Συνεχίζοντας το coding, υλοποίησα με την Reduce τις Parallel versions των Min και Max, με σκοπό να δείξω την εκφραστική δύναμη του Reduce pattern.

public static T Max<T>(this IParallelEnumerable<T> data) where T : IComparable<T>
{
  return data.Aggregate(data.First(), (accumulate, value) => (accumulate.CompareTo(value) > 0)? accumulate : value);
}

public static T Min<T>(this IParallelEnumerable<T> data) where T : IComparable<T>
{
  return data.Aggregate(data.First(), (accumulate, value) => (accumulate.CompareTo(value) < 0)? accumulate : value);
}

(Σημείωση: Στο LINQ η Reduce method ονομάζεται Aggregate)

Code hacking is fun... ειδικά όταν συνδυάζεις (functional + parallel) programming !!!

Η MS έχει ανακοινώσει ότι θα μας έχει Parallel LINQ... κάποια στιγμή... αλλα μέχρι τότε θα ήθελα τα LINQ queries μου να κρατούν busy το multi-core machine μου.

Οποτε αποφάσισα να δοκιμάσω μια "toy" υλοποίηση του Parallel LINQ...
(Είχα δοκιμάσει στο παρελθόν κάποιες απλές υλοποιησεις σε Scheme και Haskell,
αλλα τα  Query Comprehensions του LINQ είναι αρκετά πιο clear σε όσους έχουν κάνει SQL coding)

Αποφάσισα να δοκιμάσω την υλοποίηση σε ένα ένα μηχανάκι που έχουμε στη δουλειά (τον φωνάζουμε zeus) με 4 cores (8 threads) 

Πρώτα εκτελώ το sequential LINQ query (CPU Usage: 14%)

var items = from value in 1.To(n)
            where value.IsPrime()
            select new { Value = value, Binary = value.ToBinary() };

Και μετά την Parallel εκδοχή του (CPU Usage: 97%)

var items = from value in 1.To(n).ToParallel()
            where value.IsPrime()
            select new { Value = value, Binary = value.ToBinary() };

Όπως φαίνεται τα δυο queries είναι "σχεδόν" ίδια... εκτος από αυτό το περίεργο ToParallel() !!!
Για να έχουμε Parallel execution, το μονο που χρειάζεται είναι να καλέσουμε την ToParallel() extension method σε ένα IEnumerable<T> source.

Σε αυτο το release έχω υλοποιησει Parallel εκδόσεις των Select (also known as Map), Where (also known as Filter), και σκοπεύω να υλοποιήσω κάποια στιγμή μια Parallel Reduce method (για να ολοκληρώσω την κλασική τριάδα)

Μελλοντικά, θα εξετάσω πιθανά improvements, όπως την δυνατότητα για deferred execution, parameterized thread count... (ιδέες πολλές, αλλα πολύ λίγος ο ελεύθερος χρόνος)

Happy code hacking my friends

Σήμερα παρέλαβα ένα πολύ "όμορφο" βιβλίο, με τον πολύ "όμορφο" τίτλο "Beautiful Code: Leading Programmers Explain How They Think ".
 
Το βιβλίο αποτελείται από 33 κεφαλαια, και το καθένα από αυτά παρουσιάζει "κάτι" που οι συγγραφείς τους θεωρούν ότι είναι "όμορφο".
Ένας από τους διάσημους συγγραφείς-programmers είναι και ο συμπολίτης μας Διομήδης Σπινέλλης, με το κεφαλαιο 17 "Another Level of Indirection"...

Νομίζω ότι το βιβλίο προορίζεται για να γίνει classic στον χώρο μας.

Πολλά συγχαρητήρια στους ASD για την πρώτη θέση στην Assembly 2007... Το Lifeforce είναι ένα εκπληκτικό demo και κατά τη γνώμη μου η καλύτερη δουλειά τους... Τι να πω... το demo με έχει μαγέψει... είναι τέλειο...

Πολλά συγχαρητήρια στα παιδιά

Στο 5ο  dotnetzone community event παρουσίασα ένα προγραμματάκι που παράγει Truth tables από boolean expressions.  Ο σκοπός μου ήταν να δείξω πως μπορούμε προγραμματιστικά να δημιουργήσουμε expression trees και την δυνατότητα που έχουν να γίνονται compile σε IL (και μετά μέσω του Jitter σε x86).

Πρόσφατα βρήκα λίγο χρόνο για code hacking και αποφάσισα να κάνω refactor τον Tokenizer και τον Parser.
Το αποτέλεσμα τώρα μου αρέσει περισσότερο...

Happy coding...

Πρόσφατα διάβασα ένα πολύ ενδιαφέρον άρθρο από τον Peter Norvig για το πως μπορούμε να γράψουμε έναν Spelling Corrector!!!

(Ο Peter Norvig είναι Director of Research στην Google και γνωστός LISP hacker, έχοντας γράψει εκπληκτικά βιβλία για AI με την LISP).

Ο Norvig παρουσιάζει τον αλγόριθμο με ένα πολύ μικρό προγραμματάκι (21 lines) σε python. Εντυπωσιασμένος από την ιδέα και τον πολύ όμορφο python κώδικα, αποφάσισα να δοκιμάσω μια υλοποίηση σε C# 3.0... Ο τελικός κώδικας είναι αρκετά μεγαλύτερος από τον αντίστοιχο python... αλλα anyway ... C# είναι ... και πάλι καλά να λέμε...

Happy code hacking

public class ToySpellingCorrector
{

   private readonly Dictionary<string, int> dictionaryOfWords;

   public ToySpellingCorrector(string filename)
   {
      dictionaryOfWords = Train(Words(File.ReadAllText(filename)));
   }

   private Dictionary<string, int> Train(IEnumerable<string> words)
   {
      var query = from word in words
                  group word by word into g
                  select new { Key = g.Key, Value = g.Count() };

      return query.ToDictionary(item => item.Key, item => item.Value);
   }

   private IEnumerable<string> Words(string text)
   {
      return text.ToLower().FindAll("[a-z]+");
   }


   public string Correct(string word)
   {

      var candidateStrings = SelectTheFirstNonEmptyCandidateSet( Known(word.Enumerate()), 
                                                                  Known(EditsDistanceOne(word)),
                                                                  Known(EditsDistanceTwo(word)),
                                                                  word.Enumerate());

      return candidateStrings.Max((first, second) => dictionaryOfWords[first].CompareTo(dictionaryOfWords[second]));

   }

   private IEnumerable<string> Known(IEnumerable<string> words)
   {
      var query = from word in words
                  where dictionaryOfWords.ContainsKey(word)
                  select word;
      return query.Distinct();
   }

   private IEnumerable<string> SelectTheFirstNonEmptyCandidateSet(params IEnumerable<string>[] candidates)
   {
      return ( from candidate in candidates
               where candidate.Any()
               select candidate ).First();
   }

   private IEnumerable<string> EditsRawDistanseOne(string word)
   {
      return word.Deletion()
                  .Concat(word.Transposition())
                  .Concat(word.Alternation())
                  .Concat(word.Insertion());
   }

   private IEnumerable<string> EditsRawDistanceTwo(string word)
   {
      foreach (string edit in EditsRawDistanseOne(word))
         foreach (string innerEdit in EditsRawDistanseOne(edit))
            yield return innerEdit;
   }

   private IEnumerable<string> EditsDistanceOne(string word)
   {
      return EditsRawDistanseOne(word).Distinct();
   }

   private IEnumerable<string> EditsDistanceTwo(string word)
   {
      return EditsRawDistanceTwo(word).Distinct();
   }
}

public static class MyExtensions
{

   public static IEnumerable<string> Deletion(this string word)
   {
      for (int i = 0; i < word.Length; i++)
         yield return word.Substring(0, i) + word.Substring(i + 1);
   }

   public static IEnumerable<string> Transposition(this string word)
   {
      for (int i = 0; i < word.Length - 1; i++)
         yield return word.Substring(0, i) + word.Substring(i + 1, 1) + word.Substring(i, 1) + word.Substring(i + 2);
   }

   public static IEnumerable<string> Alternation(this string word)
   {
      for (int i = 0; i < word.Length; i++)
         for (char c = 'a'; c <= 'z'; c++)
            yield return word.Substring(0, i) + c.ToString() + word.Substring(i + 1);
   }

   public static IEnumerable<string> Insertion(this string word)
   {
      for (int i = 0; i <= word.Length; i++)
         for (char c = 'a'; c <= 'z'; c++)
            yield return word.Substring(0, i) + c.ToString() + word.Substring(i);
   }

   public static IEnumerable<string> FindAll(this string text, string pattern)
   {
      MatchCollection matchCollection = Regex.Matches(text, pattern);
      foreach (Match match in matchCollection)
      {
         yield return match.Value;
      }
   }

   public static IEnumerable<T> Enumerate<T>(this T source)
   {
      yield return source;
   }

   public static T Max<T>(this IEnumerable<T> source, Comparison<T> comparison)
   {
      if (source == null) throw new ArgumentNullException("source");
      T value = default(T);
      bool hasValue = false;
      foreach (T x in source)
      {
         if (hasValue) 
         {
            if (comparison(x, value) > 0) 
               value = x;
         }
         else 
         {
            value = x;
            hasValue = true;
         }
      }
      if (hasValue) return value;
      throw new InvalidOperationException("Sequence contains no elements");
   }

}


class Program
{
   static void Main(string[] args)
   {
      ToySpellingCorrector toySpellingCorrector = new ToySpellingCorrector("big.txt");

      while(true)
      {
         Console.Write(">>>");
         string word = Console.ReadLine();
         if(word == string.Empty) break;
         Console.WriteLine("Correct: {0}", toySpellingCorrector.Correct(word));
      }
   }
}

Τα screencasts του Nitro με εντυπωσίασαν και με έπεισαν ότι αξίζει την προσοχή μας...

Αυτά είναι ωραία νέα... Έλληνες Ruby hackers ενωθείτε...

Μια πολύ ενδιαφέρουσα άποψη από τον Martin Fowler για την Ruby και το "μέλλον" της Microsoft.

http://www.martinfowler.com/bliki/RubyMicrosoft.html

Μια από τις πιο cool ιδιότητες των iterators στην C# είναι ότι μπορούμε να δημιουργήσουμε infinite streams of values. Σε μια συζήτηση που είχα με τον Wes Dyer περί infinite streams, μου έστειλε ένα πολύ ενδιαφέρον κομμάτι κώδικα που υλοποιεί ένα lazy stream από πρώτους αριθμούς.

Ο Wes χρησιμοποιεί μια "lazy" παραλλαγή του κλασσικού αλγοριθμου "το κόσκινο του Ερατοσθένη".

Ο κώδικάς του είναι απλά mind blowing... Simple & Elegant...

Χαρείτε τον...

    static IEnumerable<int> ToInfinity(this int i)
    {

      while (true)

        yield return i++;

    }



    static IEnumerable<int> Sieve(this IEnumerable<int> e)
    {

      var first = e.First();

      yield return first;

      foreach (var item in Sieve(e.Skip(1).Where(x => x % first != 0)))

        yield return item;

    }


    static void Main(string[] args)
    {

      foreach(var prime in 2.ToInfinity().Sieve())
        Console.WriteLine(prime);
    }

Πολύ cool παιχνιδάκι και πολύ ενδιαφέρουσα η διαφημιστική προσπάθεια της Sun.

Άντε και καλά high score...

Επιτέλους, στο .Net Framework 3.5 υπάρχει BigInteger type και κατοικεί στο namespace System.Numeric.
Τώρα πια μπορούμε να αποθηκεύουμε και να διαχειριζόμαστε arbitary size ακέραιους, χωρίς unexpected overflows.
(Remark: ο BigInteger είναι ένα abstraction και είναι φυσικό να είναι αρκετά πιο αργός σε σχέση με τους άλλους primitive ακέραιους int, long)
Η ομάδα σχεδιασμού του BigInteger έχει κάνει overload αρκετούς operators, με αποτέλεσμα ο κώδικας να είναι καθαρός και να εκφράζει την επιθυμητή ενέργεια.
(Remark: Η δύναμη του operator overloading in use)

Τον τελευταίο καιρό αναπτύσσω σε F# μια βιβλιοθήκη με διαφορα infinite streams αριθμών.
Η F# περιέχει τον δικό της BigInt type στο namespace Microsoft.FSharp.Μath και μπορούμε να τo χρησιμοποιήσουμε και σε αλλα .Net projects.
Ένα απλό code sample σε C# 3.0

    public static IEnumerable<BigInt> NaturalNumbers()
    {
      BigInt number = BigIntModule.zero;
      while(true)
      {
        number += BigIntModule.one;
        yield return number;
      }
    }

    public static IEnumerable<BigInt> OddNumbers()
    {
      BigInt two = BigIntModule.of_int(2);
      return NaturalNumbers().Select(number => two * number + BigIntModule.one);
    }

    public static IEnumerable<BigInt> EvenNumbers()
    {
      BigInt two = BigIntModule.of_int(2);
      return NaturalNumbers().Select(number => two * number);
    }

(Remark: BigInteger type μπορούμε να βρούμε και στην J#, αλλα δεν υποστηρίζει operator overloading)

Happy Coding...

O Y fixed point combinator είναι ένα από τα πιο περίεργα και γοητευτικά
"αντικείμενα" που έχω συναντήσει σε αυτό που ονομάζουμε "Computer Science".
Γενικά ο Y combinator χρησιμοποιείται για να ορίσουμε recursive anonymous functions.

Πρόσφατα, εντόπισα ένα πολύ καλο άρθρο από τον Wes Dyer
για το πως μπορούμε να οδηγηθούμε και να καταλάβουμε το γιατι υπάρχει και το πώς δουλεύει.
Ο Wes Dyer είναι developer στον compiler της C# και μέσα από το blog του παρουσιάζει
τις νέες functional δυνατότητες της C# 3.0.

Πρίν από κάποια χρονια είχα εντοπίσει μια διαφορετική υλοποίηση που με είχε προβληματίσει αρκετά...
Ο κώδικας που είχα βρει:

static Func<A, R> Fix<A, R>(Func<Func<A, R>, Func<A, R>> f)
{
   Func<A, R> g = null;
   Func<A, R> g = a => f(g)(a);
   return g;
}

Πρόσφατα, επικοινώνησα μαζί του για να ακούσω την άποψή του και για να μου σχολιάσει τις διαφορες αναμεσα στις δύο υλοποιήσεις. Η απάντησή του έχει αρκετό ενδιαφέρον και με κάλυψε απόλυτα.
Παραθέτω ένα κομμάτι από το κείμενο της απάντησης:

"In some sense the fixed point combinator that I
presented originally is more beautiful.

static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f)
{
   Recursive<A, R> rec = r => a => f(r(r))(a);
   return rec(rec);
}

Because it doesn't use the g = null combined with lazy evaluation to
reference itself.  Note that g is defined in terms of g whereas in Y rec is
*not* defined in terms of rec.  There is no recursion in the definition of
rec, yet when used it allows for recursion.  Wild eh?  To do this the
recursion has been moved to the type system.  Recursive is a delegate type
is that defined in terms of itself.

delegate Func<A,R> Recursive<A,R>(Recursive<A,R> r);

So in some senses the definition of Y is more interesting that the
definition of Fix although they accomplish the same thing."

Κλείνοντας, θέλω να αναφέρω τα πολύ σημαντικά lectures από δύο μεγάλους μάγους.

http://www.swiss.ai.mit.edu/classes/6.001/abelson-sussman-lectures/

Πραγματικά διαχρονικές ιδέες.

Happy coding...

Μου αρέσει αρκετά το coding με την Ruby...Μέχρι τώρα ο ruby code editor που χρησιμοποιούσα ήταν το notepad++ ή το Ultraedit.

Καλό το notepad++, αλλά όταν δουλεύεις για αρκετά χρόνια και καθημερινά με το Visual Studio, αρχίζεις και αποκτάς εξαρτήσεις...

Σήμερα ανακάλυψα το Ruby in steel και ένα χαμόγελο έλαμψε στο πρόσωπό μου!!!

Η 37signals είναι μια εταιρία που εδρεύει στο Chicago και είναι γενικότερα γνωστη ως οι δημιουργοί του Ruby On Rails web-app framework.

Σήμερα εντόπισα ένα βιβλίο που έχουν γράψει με τον τίτλο Getting Real: The smarter, faster, easier way to build a successful web application.

Προσωπικά με διασκέδασε και με προβλημάτισε... Το προτείνω στον Ζαχαρία για μελέτη και για νέες ιδέες...

Εύχομαι σε όλο το community, Καλά Χριστούγεννα και να έχουμε ένα ευτυχισμένο και δημιουργικό 2007!!!

Κλείνοντας, είπα να στολίσω το blog μου με τα ανάλογα δεντράκια μιας και οι μέρες το ζητούν.

 class Program
 {
  static int GetIndexFromRule(char first, char second, char third)
  {
      if (first == ' ' && second == ' ' && third == ' ')
          return 0;
      else if (first == ' ' && second == ' ' && third == '*')
          return 1;
      else if (first == ' ' && second == '*' && third == ' ')
          return 2;
      else if (first == ' ' && second == '*' && third == '*')
          return 3;
      else if (first == '*' && second == ' ' && third == ' ')
          return 4;
      else if (first == '*' && second == ' ' && third == '*')
          return 5;
      else if (first == '*' && second == '*' && third == ' ')
          return 6;
      else //if (first == '*' && second == '*' && third == '*')
          return 7;
   
  }

  static IEnumerable<string> ExecuteRule(string rule, int times)
  {
      string space = "  *  ";
      string newSpace = string.Empty;

      yield return space;

      for(int counter = 2; counter <= times; counter++)
      {

          for(int i = 1; i < space.Length - 1; i++)
          {
              newSpace += rule[GetIndexFromRule(space[i - 1], space[i], space[i + 1])];
          }
          yield return newSpace;
          space = String.Format("  {0}  ", newSpace);
          newSpace = string.Empty;
      }
   
  }

  static void Center(int row, string text)
  {
      int left = ((Console.WindowWidth - 1) - text.Length) / 2;
      Console.SetCursorPosition(left, row);
      Console.Write(text);
  }

  static void PrintRule(string rule)
  {
      Console.Clear();
      Console.ForegroundColor = ConsoleColor.Green;

      int counter = 1;
      foreach(string line in ExecuteRule(rule, 40))
      {
          Center(counter++, line);
      }
      Console.ReadKey();
  }

  static void Main(string[] args)
  {
      PrintRule(" ****   "); // rule 30
      PrintRule(" *******"); // rule 254
      PrintRule(" * *****"); // rule 250
      PrintRule(" * ** * "); // rule 90
  }
 }

Υλικά κατασκευης: A New Kind Of Science