Emanuele's blog

La busta paga

2010-02-27T12:11:27Z

Iniziamo da: "il datore di lavoro ha l'obbligo di consegnare il prospetto paga" (Legge n.4 del 1953).

La busta paga si divide in:

Intestazione

Corpo

Dati previdenziali, Dati fiscali, TFR, Retribuzione netta.

Nell'intestazione si trovano tutti i dati anagrafici della ditta e del lavoratore: posizione INPS, INAIL, Matricola, Cognome, Nome, Codice Fiscale, Data di assunzione e tutti gli elementi retributivi:

Mese di retribuzione, Sede di lavoro, Contratto di lavoro con livello e qualifica, Elementi del trattamento salariale e i giorni retribuiti/lavorati del mese.

Quello che più conta nell'intestazione sono i valori di: Paga base, Contingenza, eventuale Elemento distinto della retribuzione, Scatti di anzianità, Altri elementi.

Mi soffermerei su questi altri elementi: le aziende italiane giocano molto sul superminimo assorbibile. Cosa è il superminimo? Uno dei tanti imbrogli del mondo del lavoro.

In teoria dovrebbe funzionare cosi:

2010: ho uno stipendio di mille euro

2011: chiedo o mi viene riconosciuto un aumento di 100 euro

2011: ho uno stipendio di millecento euro

2012: chiedo o mi viene riconosciuto un aumento di 100 euro

2012: ho uno stipendio di milleduecento euro

2013: chiedo o mi viene riconosciuto un aumento di 100 euro

2013: ho uno stipendio di milletrecento euro

3 aumenti, stipendio di 1300 euro

In pratica funziona così:

2010: ho uno stipendio di mille euro (di cui 900 di stipendio e 100 di superminimo)

2011: chiedo o mi viene riconosciuto un aumento di 100 euro

2011: l'azienda si avvale del superminimo e ho ancora uno stipendio di mille euro (di cui 1000 di stipendio e 0 di superminimo)

2012: chiedo o mi viene riconosciuto un aumento di 100 euro

2012: l'azienda lo deposita sul superminimo quindi ho uno stipendio di 1000 + 100 di superminimo

2013: chiedo o mi viene riconosciuto un aumento di 100 euro

2013: l'azienda si avvale del superminimo e ho ancora uno stipendio di millecento euro (di cui 1100 di stipendio e 0 di superminimo)

3 aumenti, stipendio di 1100 euro

Quiz: extension methods

2010-02-14T10:47:40Z

Quale sarà l'output?

namespace Extensions
{
  using System;
  using ExtensionMethodsDemo1;

     // Define extension methods for any type that implements IMyInterface.
     public static class Extension
     {
        public static void MethodA(this IMyInterface myInterface, int i)
        {
            Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, int i)");
        }

        public static void MethodA(this IMyInterface myInterface, string s) 
        {
            Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, string s)");
        }

        public static void MethodB(this IMyInterface myInterface) 
        {
            Console.WriteLine("Extension.MethodB(this IMyInterface myInterface)");
        }
    }
}
namespace ExtensionMethodsDemo1
{
    using System;
    using Extensions;

    public interface IMyInterface
    {
        void MethodB();
    }

    class A : IMyInterface 
    {
        public void MethodB(){Console.WriteLine("A.MethodB()");}
    } 

    class B : IMyInterface
    {
        public void MethodB() { Console.WriteLine("B.MethodB()"); }
        public void MethodA(int i) { Console.WriteLine("B.MethodA(int i)"); }
    }

    class C : IMyInterface
    {
        public void MethodB() { Console.WriteLine("C.MethodB()"); }
        public void MethodA(object obj) { Console.WriteLine("C.MethodA(object obj)"); }
    }

    class ExtMethodDemo
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            C c = new C();
            TestMethodBinding(a,b,c);
        }

        static void TestMethodBinding(A a, B b, C c)
        {

	    //copy from here...
            a.MethodA(1);        //write here     
            a.MethodA("hello");  //write here
            a.MethodB();         //write here         

            b.MethodA(1);        //write here    
            b.MethodB();         //write here       
            b.MethodA("hello");  //write here   

            c.MethodA(1);        //write here  
            c.MethodA("hello");  //write here 
            c.MethodB();         //write here

            //...to here 
        }
    }
}

[Fonte: MSDN]

Extension methods

2010-02-14T10:14:53Z

Gli extension methods permettono a metodi statici di essere richiamati usando la sintassi dei metodi di istanza. Questi metodi devono avere almeno un parametro che rappresenta l'istanza del metodo su cui operare. In C# su questo parametro si utilizza la parola chiave this.

public static class StringExtensions{

    public static bool IsPalindrome(this string s){

...

Questo metodo viene richiamato nel seguente modo:

if("hello world".IsPalindrome()){

  ....

La classe che definisce l'extension method viene definita "sponsor" e deve essere statica. Ovviamente va importato il namespace della classe sponsor.

Vanno usati il minimo indispensabile ;)

[Fonte: Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) - K. Cwalina, B. Abrams - Addison Wesley - 2009]

Malattia nel Contratto del Commercio

2010-02-07T10:55:29Z

Un'altra di quelle cose che mi ha sconcertato...

Nel Contratto del Commercio (e parlo di quello nazionale) la malattia viene retribuita in maniera davvero singolare:

Per i primi 3 giorni viene corrisposto il 100% dello stipendio (periodo di carenza) ed è carico del datore di lavoro.

Dal 4° al 20° giorno è previsto il 75% (!) della paga: 50% a carico dell'INPS e 25% a carico del datore di lavoro.

Dal 21° giorno in poi (fino al limite di 180 giorni) è previsto nuovamente il 100% ma suddiviso tra: 66,66% INPS, 33,34% a carico del datore di lavoro.

Rinvio a un secondo post il calcolo perchè è davvero complicato.

Rimborsi chilometrici

2010-02-05T19:54:23Z

Buono a sapersi...

In caso di trasferta al dipendente è dovuto il rimborso delle spese che ha sostenuto in base alle tabella ACI. Ma attenzione ne esistono di due tipi:

1. Costi chilometrici (Per calcolare i rimborsi al dipendente (o al professionista) che faccia uso del proprio veicolo svolgendo attività a favore del datore di lavoro.)

http://www.aci.it/index.php?id=1850

2. Fringe benefit (Per calcolare la retribuzione in natura derivante dalla concessione di veicoli aziendali in uso ai dipendenti, per esigenze di lavoro e per esigenze private.)

http://www.aci.it/index.php?id=93

I servizi sono accessibili direttamente dal sito dell'ACI (dove viene spiegata chiaramente la differenza):

http://www.aci.it/index.php?id=86

Attenzione che i secondi sono più bassi nei primi (almeno nei casi che ho verificato). Per la mia auto addirittura si dimezzano!

Pseudoquiz - Tanti modi per fare una cosa

2010-01-15T20:22:35Z

Stimolerei il vostro "modo di programmare". Immaginate di avere una combo su una pagina web [c#].

Vi chiedo di riempirla con i giorni della settimana sapendo che nell'applicazione ci sono molte combo di quel tipo.

La pagina web deriva da una BasePage : System.Web.UI.Page e ha un metodo già pronto richiamato dalla OnLoad che si chiama PrepareCombo().

Sentiamo varie soluzioni (ovviamente ottimizzate tempi di sviluppo con buon codice). Nei commenti sono ben accette le critiche alle soluzioni proposte.

Rinnovo patente

2010-01-07T18:26:28Z

Vediamo di mettere in codice anche questo evento della vita quotidiana che mi è capitato proprio oggi.

Come prima idea mi verrebbe da scrivere una classe Patente non statica, istanziarla:

Patente myPatente = new Patente();

poi per il rinnovo:

myPatente.Rinnova();

dove il metodo non fa altro che aggiornare una proprietà pubblica Anni o privata _anni:

public void Rinnova()

     _anni += 10;

Questo è sbagliato per vari motivi:

1. La proprietà privata ha un nome troppo generico (cosa indicano questi anni?);

2. La nomenclatura più appropriata sarebbe Durata e non Anni;

3. Bisognerebbe aggiornarla ogni anno e per il momento non ci interessa. Ci interessa conoscere la validità non per quanti anni è ancora valida.

Già da queste riflessioni si capisce che dovremo agire su delle date. Salto quindi il passaggio di aggiornare una proprietà chiamata Durata. Cambio il codice:

public void Rinnova()

   _dataDiScadenza.AddYears(10);

Questo codice va già meglio. Leggendo però il funzionamento di rinnovo di una patente, c'è un altro errore. Cambio il codice:

public void Rinnova(DateTime dataRinnovo)

   _dataUltimoRinnovo = dataRinnovo;

E si nota subita che non occorre un metodo ma basta utilizzare il set della proprietà. Quindi semplicemente nel codice (non nella classe):

myPatente.DataUltimoRinnovo = Convert.ToDateTime(txtDataRinnovo.Text);

Soprassediamo sul Convert e sui controlli da effettuare dato che non è l'intento di questo post.

Nella classe Patente avremo invece la proprietà

public DateTime DataScadenza

   get {return _dataUltimoRinnovo.AddYears(10);}

Anche qui non mi soffermo sul giorno effettivo di scadenza. In questo caso è importante aggiungere (correggetelo con il commento appropriato con tre ///):

// Indica la data di scadenza della patente calcolata come data del rinnovo incrementata di 10 anni.

public DateTime DataScadenza

{

get {return _dataUltimoRinnovo.AddYears(10);}

}

Ovviamente quel 10 non va bene cablato nel codice. E' risaputo inoltre che la durata dipende dall'età della persona; d'altro canto una patente esiste se collegata a una persona. Il rapporto è 1 a 1 (spero). Su un ipotetico database sarebbe (imho) mettere la fk sulla tabella Patenti (quindi un IDPersona). Analogamente dovrebbe accadere nella classe. Qui si può discutere se collegare solo la data di nascita della persona o l'intera Persona. Nel primo caso, probabilmente, ci occorrerebbe anche l'IDPersona, quindi opterei per il secondo caso se non è particolarmente oneroso. Da valutare se stiamo costruendo una classe per un'applicazione specifica o una classe in stile "utility".

[continua]

Tutto il codice di questo articolo è scritto di getto; mi scuso per eventuali errori.

Buon Natale e Felice Anno Nuovo!

2009-12-22T17:42:27Z

Buon Natale a tutti! Ci rivediamo l'anno prossimo!

I programmatori colpiscono ancora

2009-12-04T21:08:01Z

Ho comprato un appartamento da un annetto e sono subentrato al precedente proprietario a ottobre 2008. Nel rendiconto condominiale di quest'anno mi sono state addebitate (erroneamente secondo me) dei conti e conguagli antecedenti a ottobre 2008 e sono quindi andato a contestare dal mio amministratore.

Lui ha guardato nel suo software della Buffetti (mi ha detto) e ha estrapolato il conto per suddividerlo tra me e il precedente proprietario. Ha premuto un tasto e ha ottenuto un calcolo pesato in base ai giorni del rendiconto (ad esempio se il rendiconto partiva dal 1 settembre e io sono subentrato il 15 ottobre, veniva fatta la divisione del conto per il numero dei giorni tra il 1/9 e il 14/10 per il precedente proprietario, il resto per me).

Al che la mia natura di ingegnere informatico si è risvegliata: il conto non era corretto! O meglio, questo tipo di calcolo si poteva attribuire solo a determinati conti di difficile separazione rispetto alla data del 15 ottobre. Ma tutto ciò che era antecedente andava attribuito al precedente proprietario senza pesare (figuratevi alcuni conti del 2006!!!). La risposta è stata che tutti fanno così e che il programma non lo permette!!!

Che per fare una modifica ci si mette anche un anno... etc etc. Io gli ho risposto che i programmi non possono coprire tutti i casi e che per alcune questioni occorre fare i calcoli a mano proprio come avevo fatto io (io infatti avevo rifatto tutti i calcoli a manina seguendo l'esempio del rendiconto annuale). La sua risposta? E ma ora c'è il programma... questo funziona così... è prassi... Gli ho dovuto dire che ero un ingegnere informatico per far valere la mia attendibilità...

In realtà ho scoperto che il programma è ovviamente personalizzabile per determinate necessità.

Morale delle favola è sempre lo stesso: smettiamola di facilitare il lavoro degli altri e continuiamo a renderci necessari!

General naming conventions

2009-11-21T19:06:52Z

Sarebbe bello che tutti le seguissero (per ora enuncio solo quelle basilari):

1. Scegliere nomi LEGGIBILI per gli identificatori

2. Favorire la LEGGIBILITA' e non la BREVITA' (!)

3. Usare solo caratteri alfanumerici (niente underscore)

4. Non usare la notazione ungherese (ammessa la I per le interfacce)