Principi di Continuous Delivery ( automatizzare i rilasci )

8 Principi di Continuous Delivery
1) Il processo per il rilascio / distribuzione del software DEVE essere ripetibile e affidabile . Questo porta al 2 ° principio ...

2) Automatizzare tutto! Una distribuzione manuale può mai essere descritta come ripetibile e affidabile (non se lo sto facendo!). Bisogna investire seriamente automatizzando tutte le mansioni che fate ripetitivamente, e questo tende ad accrescere la affidabilità.

3) Se qualcosa è difficile o faticosa, falla più spesso. Superficialmente questo suona stupido, ma in fondo questo significa che facendo qualcosa di difficoltoso, più spesso, vi porterà a migliorare, probabilmente automatizzando, e questo finirà per renderlo indolore e facile. Prendiamo ad esempio fare una distribuzione di uno schema di database. Se questo è difficile, si tende a non farlo molto spesso, ad evitarlo, facendolo forse una volta al mese. In realtà ciò che si dovrebbe fare è migliorare il processo di distribuzione delle implementazioni dello schema, diventando bravi a farlo, e farlo più spesso, ripetendolo anche una volta al giorno se necessario. Se fai qualcosa ogni giorno, troverai il modo di renderla migliore rispetto piuttosto che la si fa una volta al mese.

4) Tenere tutto codice sorgente versionato e sotto controllo - questo suona come un po strano oggi, ma parlo seriamente, chi tiene tutto il codice sorgente versionato? A quanto pare poche persone. Lo sapevate?

5) "Fatto" significa "Rilasciato". Ciò obbliga a lavorare su di un progetto fino a quando non è nelle mani degli utenti, e funziona correttamente. Non c'è, quindi, niente del tipo: "ho controllato nel mio codice quindi è fatto per quanto mi riguarda". Ho avuto la fortuna di lavorare con alcune squadre di software che con entusiasmo si assicuravano che le loro modifiche al codice stavano funzionando correttamente fino al momento in cui i loro cambiamenti erano in produzione, controllando, anche, il sistema live per assicurarsi che i loro cambiamenti erano avvenuti con successo. D'altra parte ho lavorato con squadre in cui la loro responsabilità finiva dopo aver controllato il loro codice per il VCS.

6) Costruire qualità! Prendete il tempo ed investite nelle metriche di qualità. Un progetto con buone metriche di qualità mirate (potremmo parlare di copertura di unit test, di code styling, di violazione delle regole, misure di complessità - o, preferibilmente, di tutto ) sarà sempre meglio di uno senza, e più facile da mantenere nel lungo termine.

7) Ognuno ha la responsabilità del il processo di rilascio. Un programma in esecuzione su un computer portatile di uno sviluppatore non sta andando a fare i soldi per la società. Allo stesso modo, un progetto senza un piano per la distribuzione non sarà mai pubblicato, e quindi non fa fare soldi. Le aziende fanno i soldi, da sempre, solo con prodotti rilasciati ai clienti, quindi, questo processo dovrebbe essere nell'interesse di tutti. Gli sviluppatori dovrebbero sviluppare progetti tenendo a mente come distribuirli. I project manager devono pianificare progetti con attenzione alla distribuzione. Tester dovrebbero verificare i difetti di distribuzione con la stessa cura e attenzione che impiegano per i bug del codice (e questo dovrebbe essere automatizzato e integrato nella attività di distribuzione stesso).

8) Migliorare continuamente. Non sedersi e aspettare che il sistema diventi obsoleto o impossibile da mantenere. Miglioramento continuo significa che il sistema sarà sempre in evoluzione e quindi più facile da cambiare quando ce ne sarà bisogno.

 Per usare al meglio questi principi
ci sono anche: 4 Best Practise di Continuos Delivery

 1) Compilare i binari solo una volta. Rimarreste attontiti per il numero di volte che ho visto gente ricompilare il codice tra un ambiente e l'altro. I binari devono essere compilati una sola volta e una sola volta. Il binario deve quindi essere conservato in un posto che è accessibile solo per il meccanismo di distribuzione e il meccanismo di distribuzione dovrebbe schierare lo stesso binario per ogni ambiente successivo ...

 2) Utilizzare esattamente lo stesso meccanismo per distribuire in ogni ambiente. Sembra ovvio, ma ho visto sinceramente casi in cui sono state automatizzate le distribuzioni di Test e solo per le distribuzioni di produzione applicare procedure manuali. Ho visto anche casi in cui sono stati entrambi automatizzati, distribuzioni di Test e di produzione, ma in due lingue completamente diverse. Questo è ovviamente un lavoro da pazzi.

 3) Smoke test di rilascio. E' necessario non lasciare al caso che il rilascio sia un successo strepitoso, scrivere un test di funzioni base (smoke test) e includerli nel processo di distribuzione. Mi piace anche includere un semplice test diagnostico, tutto quello che è possibile fare per controllare va fatto e tracciato - si confronta un elenco di file e quello che ci si aspetta è di vedere la vostra distribuzione in quello che realmente finisce sul server. Io lo chiamo un test di diagnostica perché è un buon primo porto di scalo quando c'è un problema.

 4) Se qualcosa va storto, ferma la linea! Butta via e ricomincia da capo il processo, non modificare, non fare hack. Se si verifica un problema, non importa dove, scarta la distribuzione (cioè fai rollback), risolvi il problema correttamente, controllare nella versione del codice sorgente e ripeti il processo di distribuzione. Un sacco di gente dice che questo è impossibile, soprattutto se hai una finestra di interruzione per distribuire le cose nel vostro sistema live limitata, o se le modifiche di produzione finiscono nel bel mezzo della notte, mentre nessun altro è in giro per fixare adeguatamente la issue. Direi, invece, che questi argomenti colgono il punto. In primo luogo, se si dispone solo di una piccola finestra di interruzione, hacking del sistema live dovrebbe essere l'ultima cosa che vorrei fare, perché questo farà decadere tutti gli altri ambienti a meno di hackerare similmente tutti gli ambienti. In secondo luogo, la prossima volta che fate un rilascio, si può riprodurre il problema originale. In terzo luogo, se si sta facendo il rilascio nel bel mezzo della notte con nessuno intorno per risolvere i problemi, allora non stai prestando sufficiente attenzione al 7 ° principio di Continuos Delivery - Ognuno ha la responsabilità per il processo di rilascio. Almeno che non sia indispensabile, non mi consiglia di fare rilasci quando c'è la minima quantità di supporto disponibile e di personale, va semplicemente contro il buonsenso.

Easy Parallelism in .NET ? PLINQ !

come parallelizzare facilmente delle ricerche all'interno di una lista ? usando PLinQ cos'è ?
immaginate una ricerca su una lista semplice cosi come di seguito :

var customers = new[] {
 new Customer { ID = 1,  FirstName = "Sandeep"  , LastName = "Ramani" },
 new Customer { ID = 2,  FirstName = "Dharmik"  , LastName = "Chotaliya" },
 new Customer { ID = 3,  FirstName = "Nisar"    ,  LastName = "Kalia" } ,
 new Customer { ID = 4,  FirstName = "Ravi"     , LastName = "Mapara" } ,
 new Customer { ID = 5,  FirstName = "Hardik"   , LastName = "Mistry" }
 new Customer { ID = 6,  FirstName = "Sandy"    , LastName = "Ramani" },
 new Customer { ID = 7,  FirstName = "Jigar"    , LastName = "Shah" },
 new Customer { ID = 8,  FirstName = "Kaushal"  , LastName = "Parik" } ,
 new Customer { ID = 9,  FirstName = "Abhishek" , LastName = "Swarnker" } ,
 new Customer { ID = 10, FirstName = "Sanket"   , LastName = "Patel" }
 new Customer { ID = 11, FirstName = "Dinesh"   , LastName = "Prajapati" },
 new Customer { ID = 12, FirstName = "Jayesh"   , LastName = "Patel" },
 new Customer { ID = 13, FirstName = "Nimesh"   , LastName = "Mishra" } ,
 new Customer { ID = 14, FirstName = "Shiva"    , LastName = "Reddy" } ,
 new Customer { ID = 15, FirstName = "Jasmin"   , LastName = "Malviya" }
 new Customer { ID = 16, FirstName = "Haresh"   , LastName = "Bhanderi" },
 new Customer { ID = 17, FirstName = "Ankit"    , LastName = "Ramani" },
 new Customer { ID = 18, FirstName = "Sanket"   , LastName = "Shah" } ,
 new Customer { ID = 19, FirstName = "Amit"     , LastName = "Shah" } ,
 new Customer { ID = 20, FirstName = "Nilesh"   , LastName = "Soni" }       };

  List<Customer> result = new List<Customer>();
 foreach( Customer c in customers )
  if ( c.FirstName.StartWith("San") )
   result.add(c) ;

Come parallalelizzare semplicemente ed in maniera efficente questa ricerca ? 
semplicemente usando PLinQ e sostituendo il ciclo in questo modo : 

var results = from c in customers.AsParallel()
  where c.FirstName.StartsWith("San")
  select c;

Con la semplice aggiunta del metodo di estensione AsParallel(), il runtime .NET automaticamente parallelizza l'operazione in più nuclei. 

Limitazioni :
PLINQ funziona solo contro collezioni locali. Questo significa che se si sta utilizzando il provider LINQ sopra dati remoti, ad esempio LINQ to SQL o ADO.NET Entity Framework, allora non sei fortunato per questa versione. Poiché PLINQ divide la collection in più partizioni e li esegue in parallelo, i risultati che si otterrebbero da una query PLINQ non sarà nello stesso ordine dei risultati che si otterrebbero da una query LINQ eseguita o da un approccio tradizionale.

 Tuttavia, si può aggirare questo introducendo il metodo AsOrdered() nella tua query, che costringerà a un ordinamento specifico nei vostri risultati.

var results = from c in customers.AsParallel().AsOrdered()
  where c.FirstName.StartsWith("San")
  select c;

Tieni presente, tuttavia, che inserendo AsOrdered(), per insiemi di grandi dimensioni, puoi perdere in termini di performance i guadagni di parallelizzazione ottenuti.

c# cross-platform Mobile tool 4 Android & iOS

 VSNomad Cool C# cross-platform Mobile tool 4 Android & iOS
http://www.youtube.com/watch?feature=player_embedded&v=W8Gto7JkCBk#!

Server VPS or Dedicated ? find the difference !!

Avete un pò le idee confuse riguardo la differenza tra un VPS – Server Virtuale ed un Server Dedicato? Bene, non preoccupatevi, oggi cercherò di chiarire le differenze e mettere fine ai vostri dubbi.

VPS – Server Virtuale (Virtual Private Server)

Un VPS e’ un server virtuale in funzione su un server fisico, le cui risorse sono divise tra piu’ utenti. Questo avviene grazie alla suddivisione di  un server in più macchine virtuali, separate ed isolate tra loro tramite apposite applicazioni, dando quindi ai propri clienti la possibilità di configurare e gestire in piena autonomia il proprio VPS.

E’ possibile scegliere il sistema operativo, le applicazioni da installare, ed è altamente personalizzabile.

E’ un’ottima forma di hosting dedicato, consigliata a chi possiede un sito di grandi dimensioni e/o di grande traffico, o chi vuole o deve gestire più siti contemporaneamente. E’ un hosting dedicato che grazie alla virtualizzazione permette di usufruire di ottime potenzialità a prezzi veramente convenienti.

Mi raccomando, prestate sempre attenzione ai prezzi che trovate in giro per la rete, ci sono una miriade di servizi ed offerte nel settore, più o meno convenienti. Se avete esperienze limitate con la gestione di un server, affidatevi ad un servizio “managed“.

Server Dedicato

E’ sicuramente la forma di hosting più personalizzabile e costosa che c’è, consigliata per siti estremamente trafficati e con un alto consumo di risorse. Si avrà la possibilità di gestire e configurare a proprio piacimento un intero server, e di utilizzare l’hardware noleggiato per il servizio che preferiamo. Numerosissime le offerte per server dedicati presenti in rete, con la possibilità di scegliere tra processori AMD e Intel di ultima generazione, scegliere quanta memoria ram acquistare, hard disk, etc.

Come per i VPS, stesso discorso riguardo la gestione. Per chi non ha valide conoscenze per l’amministrazione di un server, è consigliato affidarsi a servizi “managed“, ovvero gestiti interamente dallo staff dell’azienda hosting. (installazione, configurazione, gestione, aggiornamenti, patch sistema operativo, etc).

Git Automate Pull

Ciao

l'altro giorno mi sono ritrovato a dovere aggiornare tutti i 29 repository Git del un progetto su cui sto lavorando ... ODDIO che noia ... farli uno per uno .. allora mi sono detto ora automatizzo ... seee magari sembrava facile ma devo dire che ci ho messo un po a capire come poter passare al comando git pull le credenziali non dalla tastiera ed il tutto in un ciclo senza scrivere tutto a brodo che era brutto ... insomma alla fine il risultato è stato questo :

PullAll.bat

set ITEM_LIST=(repositoryFolder1 repositoryFolder2 repositoryFolder3  ... )

for %%i in %ITEM_LIST% do (

cd %%i

git pull | echo "<password>" > CON

cd ..

)

Object Cloning usando IL in C#

una delle cose più fastidiose che succede spesso nella programmazione in c# è quando ci si imbatte in un oggetto da modificare mantenendo in copia l'originale.

Questa difficoltà si manifesta poiché quasi sempre gli oggetti riassegnati vengono legati all'oggetto sorgente per riferimento*. 

Per risolvere questo noioso problema solitamente nei nostri progetti implementiamo dei metodi di "Clone" ossia dei metodi che ci copiano gli oggetti ( veriabili, classi, e quant'altro ) su un altro contenitore non collegato al primo.

A volte però ci sono oggetti per cui abbiamo grosse difficoltà perché magari non sono serializzabili o altro ... ma ecco che vi posto un po di metodologie che vi aiuteranno nella quasi totalità dei casi di Clonazione. 

IL (Intermediate Language) può essere utilizzato per clonare oggetti e non è affatto male, e può essere abbastanza performante. 

definiamo una Classe Person : 

  public class Person 
  { 
  private int _id; 
  private string _name; 
  private string _firstName; 
  private string _field1, _field2, _field3; 

  public Person() 
  { 

  } 

  public int ID 
  { 
  get { return _id; } 
  set { _id = value ; } 
  } 

  public string Name 
  { 
  get { return _name; } 
  set { _name = value ; } 
  } 

  public string FirstName 
  { 
  get { return _firstName; } 
  set { _firstName = value ; } 
  } 
  } 

Test Code: Il codice riportato di seguito è un bel pezzo di codice, leggete i commenti e capirete cosa vi è dichiarato.

  class Program 
  { 
  /// <summary> 
  /// Delegate handler that's used to compile the IL to. 
  /// (This delegate is standard in .net 3.5) 
  /// </summary> 
  /// <typeparam name="T1">Parameter Type</typeparam> 
  /// <typeparam name="TResult">Return Type</typeparam> 
  /// <param name="arg1">Argument</param> 
  /// <returns>Result</returns> 
  public delegate TResult Func<T1, TResult>(T1 arg1); 
  /// <summary> 
  /// This dictionary caches the delegates for each 'to-clone' type. 
  /// </summary> 
  static Dictionary<Type, Delegate> _cachedIL = new Dictionary<Type, Delegate>(); 

  /// <summary> 
  /// The Main method that's executed for the test. 
  /// </summary> 
  /// <param name="args"></param> 
  static void Main( string [] args) 
  { 
  DoCloningTest(1000); 
  DoCloningTest(10000); 
  DoCloningTest(100000); 
  //Commented because the test takes long ;) 
  //DoCloningTest(1000000); 

  Console.ReadKey(); 
  } 

  /// <summary> 
  /// Do the cloning test and printout the results. 
  /// </summary> 
  /// <param name="count">Number of items to clone</param> 
  private static void DoCloningTest( int count) 
  { 
  // Create timer class. 
  HiPerfTimer timer = new HiPerfTimer(); 
  double timeElapsedN = 0, timeElapsedR = 0, timeElapsedIL = 0; 

  Console.WriteLine( "--> Creating {0} objects..." , count); 
  timer.StartNew(); 
  List<Person> personsToClone = CreatePersonsList(count); 
  timer.Stop(); 
  Person temp = CloneObjectWithIL(personsToClone[0]); 
  temp = null ; 
  Console.WriteLine( "\tCreated objects in {0} seconds" , timer.Duration); 

  Console.WriteLine( "- Cloning Normal..." ); 
  List<Person> clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneNormal(p)); 
  } 
  timer.Stop(); 
  timeElapsedN = timer.Duration; 

  Console.WriteLine( "- Cloning IL..." ); 
  clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneObjectWithIL<Person>(p)); 
  } 
  timer.Stop(); 
  timeElapsedIL = timer.Duration; 

  Console.WriteLine( "- Cloning Reflection..." ); 
  clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneObjectWithReflection(p)); 
  } 
  timer.Stop(); 
  timeElapsedR = timer.Duration; 

  Console.WriteLine(); 
  Console.ForegroundColor = ConsoleColor.Green; 
  Console.WriteLine( "----------------------------------------" ); 
  Console.WriteLine( "Object count:\t\t{0}" , count); 
  Console.WriteLine( "Cloning Normal:\t\t{0:00.0000} s" , timeElapsedN); 
  Console.WriteLine( "Cloning IL:\t\t{0:00.0000} s" , timeElapsedIL); 
  Console.WriteLine( "Cloning Reflection:\t{0:00.0000} s" , timeElapsedR); 
  Console.WriteLine( "----------------------------------------" ); 
  Console.ResetColor(); 
  } 

  /// <summary> 
  /// Create a list of persons with random data and a given number of items. 
  /// </summary> 
  /// <param name="count">Number of persons to generate</param> 
  /// <returns>List of generated persons</returns> 
  private static List<Person> CreatePersonsList( int count) 
  { 
  Random r = new Random(Environment.TickCount); 
  List<Person> persons = new List<Person>(count); 
  for ( int i = 0; i < count; i++) 
  { 
  Person p = new Person(); 
  p.ID = r.Next(); 
  p.Name = string .Concat( "Slaets_" , r.Next()); 
  p.FirstName = string .Concat( "Filip_" , r.Next()); 
  persons.Add(p); 
  } 
  return persons; 
  } 

  /// <summary> 
  /// Clone one person object with reflection 
  /// </summary> 
  /// <param name="p">Person to clone</param> 
  /// <returns>Cloned person</returns> 
  private static Person CloneObjectWithReflection(Person p) 
  { 
  // Get all the fields of the type, also the privates. 
  FieldInfo[] fis = p.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic); 
  // Create a new person object 
  Person newPerson = new Person(); 
  // Loop through all the fields and copy the information from the parameter class 
  // to the newPerson class. 
  foreach (FieldInfo fi in fis) 
  { 
  fi.SetValue(newPerson, fi.GetValue(p)); 
  } 
  // Return the cloned object. 
  return newPerson; 
  } 

  /// <summary> 
  /// Generic cloning method that clones an object using IL. 
  /// Only the first call of a certain type will hold back performance. 
  /// After the first call, the compiled IL is executed. 
  /// </summary> 
  /// <typeparam name="T">Type of object to clone</typeparam> 
  /// <param name="myObject">Object to clone</param> 
  /// <returns>Cloned object</returns> 
  private static T CloneObjectWithIL<T>(T myObject) 
  { 
  Delegate myExec = null ; 
  if (!_cachedIL.TryGetValue( typeof (T), out myExec)) 
  { 
  // Create ILGenerator 
  DynamicMethod dymMethod = new DynamicMethod( "DoClone" , typeof (T), new Type[] { typeof (T) }, true ); 
  ConstructorInfo cInfo = myObject.GetType().GetConstructor( new Type[] { }); 

  ILGenerator generator = dymMethod.GetILGenerator(); 

  LocalBuilder lbf = generator.DeclareLocal( typeof (T)); 
  //lbf.SetLocalSymInfo("_temp"); 

  generator.Emit(OpCodes.Newobj, cInfo); 
  generator.Emit(OpCodes.Stloc_0); 
  foreach (FieldInfo field in myObject.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic)) 
  { 
  // Load the new object on the eval stack...  (currently 1 item on eval stack) 
  generator.Emit(OpCodes.Ldloc_0); 
  // Load initial object (parameter) (currently 2 items on eval stack) 
  generator.Emit(OpCodes.Ldarg_0); 
  // Replace value by field value (still currently 2 items on eval stack) 
  generator.Emit(OpCodes.Ldfld, field); 
  // Store the value of the top on the eval stack into the object underneath that value on the value stack. 
  // (0 items on eval stack) 
  generator.Emit(OpCodes.Stfld, field); 
  } 

  // Load new constructed obj on eval stack -> 1 item on stack 
  generator.Emit(OpCodes.Ldloc_0); 
  // Return constructed object.  --> 0 items on stack 
  generator.Emit(OpCodes.Ret); 

  myExec = dymMethod.CreateDelegate( typeof (Func<T, T>)); 
  _cachedIL.Add( typeof (T), myExec); 
  } 
  return ((Func<T, T>)myExec)(myObject); 
  } 

  /// <summary> 
  /// Clone a person object by manually typing the copy statements. 
  /// </summary> 
  /// <param name="p">Object to clone</param> 
  /// <returns>Cloned object</returns> 
  private static Person CloneNormal(Person p) 
  { 
  Person newPerson = new Person(); 
  newPerson.ID = p.ID; 
  newPerson.Name = p.Name; 
  newPerson.FirstName = p.FirstName; 
  return newPerson; 
  } 
  } 

La cosa fondamentale che fa è, creare un metodo dinamico, ottenere il ILGenerator, creare codice nel metodo, compilarlo per un delegato, ed eseguire il delegato. 
Il delegato è in cache cosi che l'IL non viene generato ogni volta che una clonazione dovrebbe avvenire, quindi perdiamo un solo poco tempo, quando il primo oggetto viene clonato (IL deve essere creato e compilato in fase di esecuzione). 

Speriamo che questo articolo sia utile per alcune persone se è così, fatemelo sapere. 

Saluti

c# Best Practice for Code Style

Spesso ci chiediamo quale sia il miglior stile di programmazione o quali sono gli errori in cui si incorre durante lo sviluppo .
ecco una buona guida a non commettere errori durante lo sviluppo ( best practises c# developing ) :

http://download.microsoft.com/download/e/2/1/e216b4ce-1417-41af-863d-ec15f2d31b59/dev320.ppt