Info:

twitter

Ultimi commenti: Comment feed

Tags:

Sponsor:

Archivio 2018:

Gen

Archivio 2017:

Dic Nov Ott Mag Apr Mar Feb Gen

Archivio 2016:

Dic Nov Ott Ago Mag Mar Feb Gen

Archivio 2015:

Nov Ott Set Mar Gen

Archivio 2014:

Dic Nov Ott Set Lug Giu Mag Apr Gen

Archivio 2013:

Dic Nov Set Ago Lug Giu Mag Apr Feb Gen

Archivio 2012:

Dic Nov Ott Set Ago Giu Mag Apr Mar Feb Gen

Archivio 2011:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen

Archivio 2010:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen

Archivio 2009:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen

Archivio 2008:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen

Archivio 2007:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen

Archivio 2006:

Dic Nov Ott Set Ago Lug Giu Mag Apr Mar Feb Gen
Overengineering

Comincio a credere che quello di passare troppo tempo sul come migliorare una soluzione - laddove non sia strettamente necessario - stia diventando una piaga molto comune. In inglese hanno una sola parola, overengineering: un esempio [quasi] reale di quanto ho visto accadere può essere di aiuto.

Richiesta di implementare HelloWorld in C#. La prima versione:

/// <summary>
/// My hello world class
/// </summary>
public class HelloWorld
{
    static void Main(string[] args)
    {
        System.Console.WriteLine("hello world");
    }
}

Primo feedback: System.Console non è proprio standard. Meglio uno using statement. E ovviamente mancano i copyright.

/*
 * HelloWorld.cs
 * 
 * copyright PippoSoft corp. 2007
 * 
 * owner: Paolino Paperino
 * 
 * */
using System;

/// <summary>
/// My hello world class
/// </summary>
public class HelloWorld
{
    static void Main(string[] args)
    {
        Console.WriteLine("hello world");
    }
}

Secondo feedback: che succede se non vogliamo più scrivere alla console ma ad un'altra classe di tracing? Giusto:

/*
 * HelloWorld.cs
 * 
 * copyright PippoSoft corp. 2007
 * 
 * owner: Paolino Paperino
 * 
 * */
using System;

/// <summary>
/// Abstract trace writer
/// </summary>
public abstract class AbstractWriter
{
    public abstract void WriteLine(string line);
}

/// <summary>
/// Trace writer to Console
/// </summary>
public class ConsoleWriter : AbstractWriter
{
    public override void WriteLine(string line)
    {
        Console.WriteLine(line);
    }
}

/// <summary>
/// My hello world class
/// </summary>
public class HelloWorld
{
    static void Main(string[] args)
    {
        ConsoleWriter cw = new ConsoleWriter();
        cw.WriteLine("hello world");
    }
}

Terzo feedback: ma così facendo la stringa non è localizzabile. Ah vero!

/*
 * HelloWorld.cs
 * 
 * copyright PippoSoft corp. 2007
 * 
 * owner: Paolino Paperino
 * 
 * */
using System;

/// <summary>
/// Abstract trace writer
/// </summary>
public abstract class AbstractWriter
{
    public abstract void WriteLine(string line);
}

/// <summary>
/// Trace writer to Console
/// </summary>
public class ConsoleWriter : AbstractWriter
{
    public override void WriteLine(string line)
    {
        Console.WriteLine(line);
    }
}

public enum LocalizedStrings
{
    Error,
    HelloWorld
}

public class ResourceHelper
{
    public static string RetrieveResource(string xmlFileName, 
LocalizedStrings aLocalizedString) { // TODO: open the file // find the string return "Hello world"; } } /// <summary> /// My hello world class /// </summary> public class HelloWorld { static void Main(string[] args) { ConsoleWriter cw = new ConsoleWriter(); cw.WriteLine(ResourceHelper.RetrieveResource("myfilename.resx",
LocalizedStrings.HelloWorld)); } }

Quarto feedback. Ma se volessimo scrivere ad un server che ha una certa latenza? Meglio invertire il controllo tra Writer e codice che lo invoca. Un paio d'ore dopo:

/*
 * HelloWorld.cs
 * 
 * copyright PippoSoft corp. 2007
 * 
 * owner: Paolino Paperino
 * 
 * */
using System;

/// <summary>
/// Generic interface for all traceable stuff
/// </summary>
public interface ITraceable
{
    string ReturnTrace();
}

public enum LocalizedStrings
{
    Error,
    HelloWorld
}

public class ResourceHelper
{
    public static string RetrieveResource(string xmlFileName, 
LocalizedStrings aLocalizedString) { // open the file // find the string return "Hello world"; } } /// <summary> /// My ITraceable implementation /// </summary> public class MyTraceable : ITraceable { public string ReturnTrace() { return ResourceHelper.RetrieveResource("myfilename.resx",
LocalizedStrings.HelloWorld); } } /// <summary> /// Abstract trace writer /// </summary> public abstract class AbstractWriter { public abstract void WriteLine(); public abstract void SetTraceable(ITraceable myTraceable); } /// <summary> /// Trace writer to Console /// </summary> public class ConsoleWriter : AbstractWriter { ITraceable _mytrace = null; public override void WriteLine() { if (_mytrace == null) { throw new Exception("traceable not set"); } Console.WriteLine(_mytrace.ReturnTrace()); } public override void SetTraceable(ITraceable myTraceable) { this._mytrace = myTraceable; } } /// <summary> /// My hello world class /// </summary> public class HelloWorld { static void Main(string[] args) { MyTraceable mt = new MyTraceable(); ConsoleWriter cw = new ConsoleWriter(); cw.SetTraceable(mt); cw.WriteLine(); } }

Quinto feedback. Ma se non si riesce a instanziare una delle classi per OUT_OF_MEMORY? Quinta e ultima implementazione:

/// vaffanc **o; an this is not a pointer pointer!
public class HelloWorld { static void Main(string[] args) {
System.Console.WriteLine("hello world"); } }

Sì, perché il codice poi non lo debugga chi dà questi geniali suggerimenti, ma chi lo "scrive".

-quack

P.S. che ci crediate o no il codice compila e funziona come da specifiche in tutte le forme!

Pubblicato venerdì 12 ottobre 2007 alle 2:54 AM - 6 commenti so far
Archiviato in: Codice, Cazzate

Amis du Brazil

Evviva i brasiliani che hanno capito tutto della vita.

Brazil

Pubblicato mercoledì 10 ottobre 2007 alle 11:08 PM - 0 commenti so far
Archiviato in: Cazzate, Politica

Buon compleanno 2600

30 anni fa nasceva l'Atari 2600, che con i suoi 128 byte di memoria fa comparire un lacrimone enorme di nostalgia a quelli della mia generazione.2600

Io non ne ho mai avuto uno, ma averlo non era importante quanto avere la possibilità di giocarci - rigorosamente dopo aver finito i compiti - a casa di qualche amico come quello del terzo piano.

La cosa favolosa è che non c'era bisogno di decine e decine di titoli, anzi si finiva per passare il tempo solo su un paio di SlotRacers2giochi. O meglio: game programs come li chiamava l'Atari (con tanto di marchio registrato). Tra i classici dei pomeriggi del terzo piano c'erano Space Invaders e Defender, fino a quando al mio amico hanno  prestato "il gioco".

Il gioco è "Slot Racers" ricevuto in prestito perenne perché giocabile solo in modalità due giocatori. Con 128 byte non c'era nessuna speranza di creare una AI adeguata e ci credo!

Si trattava di guidare una macchina dotata di cannone (?) all'interno di un labirinto cercando di colpire l'avversario in una gara spietata all'ultimo colpo. Nel gioco c'erano un paio di chicche uniche a cominciare dal modo di guidare il trabiccolo con controllo "relativo": per far girare il veicolo di 90 gradi verso destra -slot_racers1 sia che sullo schermo fosse "destra", sia che sullo schermo fosse "sinistra" perché si andava nel verso opposto - bisognava inclinare il joystick (la leva!) a destra. L'altra chicca consisteva nel fatto che una volta sparato il proiettile continuavao a girare ad infinito seguendo il percorso del labirinto (c'erano pure diversi labirinti a rendere le cose più complicate, ma quello base era decisamente il migliore) fino a quando non veniva raccolto dalla macchina o colpiva la macchina avversaria. Per gli "esperti" era possibile settare una modalità in cui la macchina non poteva sparare altri colpi fino a quando il colpo precedente non andava a segno o veniva raccolto indietro. E se dopo venticinque e passa anni ricordo tutti questi Joustdettagli il motivo è legato alle sterminate ore passate a giocare a Slot Racers. 

Il gioco nella sua semplicità e bellezza è davvero indescrivibile con le parole: incredibile quanto ci siamo appassionati a quei blocchi di pixel quadrettati.

Il post non sarebbe completo di ricordi se non facessi menzione "all'altro gioco", l'ultimo che abbiamo giocato sulla 2600 prima di passare ad altri lidi. Joust!  Se qualcuno venisse colto da nostalgia, può rifarsi con Stella, un emulatore open source della mitica console per tutti i gusti.

Tenete solo a mente che per divertirsi a slot racers c'è bisogno di 2 giocatori, nella speranza che prima o poi qualcuno implementi un network mode.

-Enjoy!

Pubblicato martedì 9 ottobre 2007 alle 7:51 PM - 1 commento so far
Archiviato in: Cazzate

Spegnere o non spegnere?

Questo è il dilemma.

Leggevo su PuntoDiVista un post che indica come cambiare le impostazioni di default del "pulsante" di spegnimento; e mi son chiesto: perché la gente vuole "spegnere" il PC?

Mi spiego meglio: una delle features che più avevo atteso in Windows 2000 era la possibilità di fare hibernate. L'ibernazione è quella feature che salva lo stato del PC (RAM, processore, IRQs, etc.) su un file che all'accensione ci farà sembrare tutto così come era prima. Da quando è stata inventata a feature di "ibernazione" io non ho mai più spento (leggi: shutdown) il mio PC se non per casi eccezionali (hardware upgrade, windows update, ecc.). Fino ad XP però l'ibernazione non era abilitata di default né era il metodo "preferenziale" di spegnimento. Col tempo la tecnologia è migliorata e l'integrazione tra hardware e software ha permesso un'ulteriore innovazione in Vista: «il sonno ibrido».

hibernation In questa pagina cortesia di Intel sono indicati tutti gli "stati" di alimentazione (che vanno da S0 completamente acceso a S5 completamente spento). Lo stato di «sonno ibrido» corrisponderebbe ad una via di mezzo tra S3 ed S4. S3 è lo stato cosidetto di sleep in cui tutta la circuiteria hardware è senza alimentazione ad eccezione della RAM: questo permette una accensione ultrarapidissima (sotto la manciata di secondi) bilanciata ad un consumo molto basso. Lo stato S4 è quello dell'ibernazione: la memoria viene appunto scaricata anch'essa in un file e all'accensione il sistema operativo si occuperà di ricaricarla richiedendo una quantità di tempo non indifferente (tempo di boot/bios + tempo di caricamento da disco in memoria). La differenza tra lo stato S4 ed S5 è puramente "software" nel senso che l'ibernazione è implementata dal SO: all'accensione infatti il BIOS si comporta come se fosse una vera e propria accensione "da spento" (POST, controllo della RAM, lancio dell'OS, ecc.). Dal punto di vista dell'esperienza dell'utente, a parte i tempi di caricamento, la differenza tra S3 ed S4 è nulla: l'utente si ritrova il desktop così come l'aveva lasciato. Il problema dello stato S3 è relativo a cosa accadrebbe se il PC non fosse più alimentato (calo di tensione, qualcuno tira la spina, ecc.): si otterrebbe la stessa cosa che si ottiene spegnendo il PC a crudo. Di qui l'idea - se mi è concesso geniale - dello stato ibrido. Al momento dello spegnimento la RAM viene copiata su file come se fosse una ibernazione ma dal punto di vista elettrico il PC viene messo nello stato S3. Se la corrente va via, il sistema operativo si occuperà di fare il boot come se il pc fosse stato ibernato, altrimenti il processo di accensione segue la via molto più veloce dell'accensione da sleep. Il migliore dei mondi possibili.

Lo stato di sleep era già stato implementato ai tempi di XP ma purtroppo una politica di gestione dei power modes che dà troppo potere agli applicativi (che sullo sleep hanno diritto di veto) ha reso lo stato di sleep in XP un terno al lotto. Con Vista tutti power modes sono stati ridisegnati e la novità principale è che i programmi hanno due secondi di clean-up time (i casi in cui un programma deve fare qualcosa per reagire allo sleep sono rarissimi) e alla fine dei due secondi il PC è già in fase di spegnimento.

C'è da aggiungere che nei portatili lo stato ibrido non è attivo di default; il motivo è banale: essendo di solito alimentati da batteria che funge da alimentazione di backup, non si corre il rischio di cadute di alimentazione. Quando la batteria raggiunge livelli critici il laptop si accende brevemente per passare a S4. Purtroppo rimuovere la batteria non attiva automaticamente lo sleep ibrido.

Una nota ecologica: lo stato S3 di sleep consuma davvero pochissimo mentre l'ibernazione dal punto di vista ecologico è praticamente identica a tenere il PC spento. Il fatto che il PC si accenda molto velocemente mi ha spinto a spegnerlo più spesso di prima (PC lasciato acceso durante la pausa pranzo).

Infine una mia curiosità: sento sempre più sovente usare la parola "spengere" come equivalente di "spegnere" anche da giornalisti non toscani. Che l'Italia si stia Toscanizzando?

-quack

Technorati tags: , ,

Pubblicato lunedì 8 ottobre 2007 alle 8:41 PM - 28 commenti so far
Archiviato in: Windows, Cazzate