In principio era il Verbo

In principio era il Verbo,
il Verbo era presso Dio
e il Verbo era Dio.
Giovanni 1,1

Queste parole mi hanno sempre fatto riflettere. Il Verbo, la Parola.
Perché il Verbo?

La Parola è Luce, rende le cose chiare. Comprensibili.

Per comunicare la Verità abbiamo bisogno di parole chiare, definite.
Le definizioni sono ciò che legano il suono significante al significato che è sedimentato nella cultura.

Il contrario della definizione è la confusione.
La confusione impedisce il dialogo. Divide diabolicamente.

Chi non vuole la Verità, usa le parole a sproposito, confondendole e svuotandole di significato.


In questi casi, l'etimologia delle parole, la loro storia, diventa l'unico strumento per recuperarne i significati.

Gli esempi sono innumerevoli:

Solidarietà

da solidum, è ciò che rende solida una comunità. Senza solidarietà si mina la solidità di uno stato, che senza autorevolezza morale perde il monopolio dell'uso legittimo della forza. Lo sanno bene la camorra, la 'ndrangeta e la mafia che la fingono, asservendo i disperati. Se un mio organo si ammala ed il mio corpo non interviene, la malattia si allarga e contagia tutto il resto. La mafia, la 'ndrangeta e la camorra fanno affari d'oro a fronte di ogni mancanza di solidarietà. Perché uno Stato non solidale è debole. E se lo stato è debole, loro sono forti.

Giustizia

da jus ovvero diritto, legge. E' giusto solo ciò che è conforme alla legge. Una legge può essere ingiusta solo se non è conforme ad una legge di grado superiore, come la Costituzione.

Etica

da ethos, ovvero consuetudine. E' etico ciò che e conforme alle norme non scritte che regolano una comunità. Chi non lo è, di solito risponde alle critiche tacciando di moralismo il proprio interlocutore.

Terrone

da terra, ovvero chi lavora faticosamente la terra. Quando la Lega Nord usava il termine "terrone" in modo dispregiativo, in realtà insultava agricoltori e allevatori.

Comunione

da communionem, il mettere insieme, ut unum sint. E' una via ben più intransigente del comunismo.

Diavolo

da diabolos, ciò che divide. Il contrario di simbolo, che è ciò che unisce.

Si potrebbe continuare per pagine e pagine.

Sono innumerevoli le parole di cui abbiamo dimenticato il significato.

Per questo non ci capiamo. E al dialogo si sostituisce il diavolo, la divisione.
L'incomunicabilità e la solitudine.


Per sconfingere chi divide è fondamentale ricordare che In principio era il Verbo!

Fra 3 giorni, 30 anni

Lunedì 29 compirò 30 anni.

Come è strana la vita.

10 anni fa non mi immaginavo assolutamente così.
Anzi non mi immaginavo affatto.
20 anni fa ero un orfano, con un fratellino da proteggere e con una mamma meravigliosa quanto apprensiva.
Un ragazzo a rischio, a causa delle difficili condizioni economiche in cui versavamo.

Oggi sono un uomo felice, con una moglie stupenda ed una figlia... indescrivibile.

La vita è veramente bella. Imprevedibile.

Synthesis vs compromise

My job is all about complexity.

Designing and developing an enterprise application for a big bank, is a huge challenge.
It's all about understanding and solving concrete problems that are complex by nature, since they mix the human habits and needs with the rigidity of a software system.
You can't miss a word, neither when you write the code nor when you talk with customers and users.
You have to deeply understand both.

It happens that people requirements collide with developers' experience and habits.

In these cases, project managers, developers and architects brainstorms.
Such brainstorm are really similar to political talk-shows: many people talk, fews listen.

I'm actually both a developer and an architect, so I'm often required in such brainstorms.

During the last years I noticed that there are two different approaches to problems:

1. serching compromises
2. serching syntesis

The two always conflict.

Compromises are easier and faster to obtain: you only need to negotiate.

Synthesis are by far harder to achieve: everyone have to listen and understand the reasons of the others and to propose solution that others can endorse.

Compromises don't solve problems, but seem cheaper in the short term.
Synthesis avoid the problems, solving the human errors that lead to them, but are harder to get.

Recently we have a problem that has been approached with compromises: the agreement was taken in an hour by a project manager and an architect.
After 97 man/days of hard work we had to throw it all.
Than we tried to search a syntesis. It took 5 day for 5 people to understand the problem, the errors we did before and so on.

5 people brainstormed for 5 days.

After that 2 developers built the solution we defined. In a week.


It was an emblematic experience.

Most italian politics search compromises.
Compromises are cheaper: all they need is to keep their voter's consensus.
Moreover with compromises you can focus to ensure a practice of favouritism.

They forgot (when they know) our wonderful Constitution that states:

Each Member of Parliament represents the Nation and carries out his
duties without a binding mandate.
Art.67 of the Constitution of the Italian Republic

They should avoid compromises.
They should always search synthesis.
They should work for all italians, not only for their voters.

Political compromises clean your garden while your home burns.
May be you are looking the garden and vote them again, but you'll eventually have to go home.


On the other hand synthesis is always possible: we all have legitimate needs and egoistic pretensions.
By mortifing such pretensions you don't win elections but you find compatible needs.

But how to find politics that avoid compromises?
How to find men that works only for the common good?

A first step: don't allow anyone to run for parliament twice.

Caratteristiche del Partito che voterò alle prossime elezioni

1. Candida solo persone nuove, mai apparse sulla scena politica o mediatica.
   Da statuto impedisce a chi ha già ricoperto una carica di candidarsi per essa.
   Perché Politica deve essere sinonimo di servizio, non di carriera.
2. Candida solo persone credibili: incensurate, non indagate, né in attesa di giudizio.
   Perché senza autorevolezza morale, lo stato non può detenere il monopolio dell'uso legittimo della forza.
3. Candida almeno il 50% di donne, molte delle quali madri.
4. Candida persone responsabili, da responsus abilem, ovvero capaci di rispondere alle critiche con i fatti.
   Persone che non alzino mai la voce, dimostrando autorevolezza, non imponendo la propria autorità.
5. Propone limitazioni al diritto di voto per chi non paga le tasse, causa indegnità morale.
6. Propone, come San Paolo, che "chi non vuol lavorare, neppure mangi".
7. Propone che un'ora di lavoro precario costi almeno il doppio di un'ora di lavoro non precario.
8. Propone la tassazione degli imballaggi in funzione del loro peso, del loro volume e della loro riciclabilità.
9. Propone la regolarizzazione degli immigrati disposti a denunciare chi li fa lavorare in nero o li fa delinquere.
10. Propone l'esenzione dalle tasse per 5 anni delle aziende che denunciano i propri estorsori.
11. Propone che "Made in Italy" possa essere usato solo per prodotti la cui filiera risiede esclusivamente in Italia.
12. Propone che la presenza dei crocifissi nelle scuole sia una decisione assunta, ogni anno, democraticamente, dagli alunni di ciascuna classe.
13. Propone una riforma del fisco credibile, la cui semplificazione eviti il commercialista ai liberi professionisti e faciliti l'operato della Guardia di Finanza.
14. Non propone modifiche alla Costituzione, in quanto questa definisce sin dal primo articolo l'Italia e noi italiani.
15. Non propone il Paese come una azienda, ma come una famiglia che deve arrivare insieme alla fine del mese.
16. Non negozia valori, ma li vive e non li strumentalizza.
    Perché prima di ridiscutere una legge che divide l'opinione pubblica, è necessario rimuovere le condizioni culturali, economiche e sociali che la rendono "il male minore".
17. Antepone il bene comune al successo elettorale. Che senso ha votare chi ci ha ripulito il giardino mentre la nostra casa crollava, divampata dalle fiamme?

Nota bene: al momento questo partito non esiste ancora, ma ormai siamo in tanti a sognarlo.
E Gesù diceva: "Chiedete e vi sarà dato".

Cultura

Perché Camilleri che racconta la Sicilia va in onda all'una di notte?

Problem 13

Work out the first ten digits of the sum of the given one-hundred 50-digit numbers.

solution :: Integer
solution = firstTenDigit $ sum $ map read numbers
    where firstTenDigit = read.(take 10).show

every  ::  Int -> [a] -> [[a]]
every _ [] = []
every n list = take n list : (every n $ drop n list)

numbers = every 50 "37107287533902102798797998220837590246510135740250\
\46376937677490009712648124896970078050417018260538\
\74324986199524741059474233309513058123726617309629\
\91942213363574161572522430563301811072406154908250\
\23067588207539346171171980310421047513778063246676\
\89261670696623633820136378418383684178734361726757\
\28112879812849979408065481931592621691275889832738\
\44274228917432520321923589422876796487670272189318\
\47451445736001306439091167216856844588711603153276\
\70386486105843025439939619828917593665686757934951\
\62176457141856560629502157223196586755079324193331\
\64906352462741904929101432445813822663347944758178\
\92575867718337217661963751590579239728245598838407\
\58203565325359399008402633568948830189458628227828\
\80181199384826282014278194139940567587151170094390\
\35398664372827112653829987240784473053190104293586\
\86515506006295864861532075273371959191420517255829\
\71693888707715466499115593487603532921714970056938\
\54370070576826684624621495650076471787294438377604\
\53282654108756828443191190634694037855217779295145\
\36123272525000296071075082563815656710885258350721\
\45876576172410976447339110607218265236877223636045\
\17423706905851860660448207621209813287860733969412\
\81142660418086830619328460811191061556940512689692\
\51934325451728388641918047049293215058642563049483\
\62467221648435076201727918039944693004732956340691\
\15732444386908125794514089057706229429197107928209\
\55037687525678773091862540744969844508330393682126\
\18336384825330154686196124348767681297534375946515\
\80386287592878490201521685554828717201219257766954\
\78182833757993103614740356856449095527097864797581\
\16726320100436897842553539920931837441497806860984\
\48403098129077791799088218795327364475675590848030\
\87086987551392711854517078544161852424320693150332\
\59959406895756536782107074926966537676326235447210\
\69793950679652694742597709739166693763042633987085\
\41052684708299085211399427365734116182760315001271\
\65378607361501080857009149939512557028198746004375\
\35829035317434717326932123578154982629742552737307\
\94953759765105305946966067683156574377167401875275\
\88902802571733229619176668713819931811048770190271\
\25267680276078003013678680992525463401061632866526\
\36270218540497705585629946580636237993140746255962\
\24074486908231174977792365466257246923322810917141\
\91430288197103288597806669760892938638285025333403\
\34413065578016127815921815005561868836468420090470\
\23053081172816430487623791969842487255036638784583\
\11487696932154902810424020138335124462181441773470\
\63783299490636259666498587618221225225512486764533\
\67720186971698544312419572409913959008952310058822\
\95548255300263520781532296796249481641953868218774\
\76085327132285723110424803456124867697064507995236\
\37774242535411291684276865538926205024910326572967\
\23701913275725675285653248258265463092207058596522\
\29798860272258331913126375147341994889534765745501\
\18495701454879288984856827726077713721403798879715\
\38298203783031473527721580348144513491373226651381\
\34829543829199918180278916522431027392251122869539\
\40957953066405232632538044100059654939159879593635\
\29746152185502371307642255121183693803580388584903\
\41698116222072977186158236678424689157993532961922\
\62467957194401269043877107275048102390895523597457\
\23189706772547915061505504953922979530901129967519\
\86188088225875314529584099251203829009407770775672\
\11306739708304724483816533873502340845647058077308\
\82959174767140363198008187129011875491310547126581\
\97623331044818386269515456334926366572897563400500\
\42846280183517070527831839425882145521227251250327\
\55121603546981200581762165212827652751691296897789\
\32238195734329339946437501907836945765883352399886\
\75506164965184775180738168837861091527357929701337\
\62177842752192623401942399639168044983993173312731\
\32924185707147349566916674687634660915035914677504\
\99518671430235219628894890102423325116913619626622\
\73267460800591547471830798392868535206946944540724\
\76841822524674417161514036427982273348055556214818\
\97142617910342598647204516893989422179826088076852\
\87783646182799346313767754307809363333018982642090\
\10848802521674670883215120185883543223812876952786\
\71329612474782464538636993009049310363619763878039\
\62184073572399794223406235393808339651327408011116\
\66627891981488087797941876876144230030984490851411\
\60661826293682836764744779239180335110989069790714\
\85786944089552990653640447425576083659976645795096\
\66024396409905389607120198219976047599490197230297\
\64913982680032973156037120041377903785566085089252\
\16730939319872750275468906903707539413042652315011\
\94809377245048795150954100921645863754710598436791\
\78639167021187492431995700641917969777599028300699\
\15368713711936614952811305876380278410754449733078\
\40789923115535562561142322423255033685442488917353\
\44889911501440648020369068063960672322193204149535\
\41503128880339536053299340368006977710650566631954\
\81234880673210146739058568557934581403627822703280\
\82616570773948327592232845941706525094512325230608\
\22918802058777319719839450180888072429661980811197\
\77158542502016545090413245809786882778948721859617\
\72107838435069186155435662884062257473692284509516\
\20849603980134001723930671666823555245252804609722\
\53503534226472524250874054075591789781264330331690"

Since Haskell's Integer type is unbounded, this solution was very easy.

Problem 12

The sequence of triangle numbers is generated by adding the natural numbers. So the 7^th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.
What is the value of the first triangle number to have over five hundred divisors?

solution = findResult $ halveEvens [1..]
    where findResult (x:y:xs)
            | (divisors x * divisors y) > 500 = triangleAt x
            | otherwise = findResult (y:xs)
          halveEvens (x:y:xs) = x : (div y 2) : halveEvens xs

triangleAt x = div (x * (x + 1)) 2

divisors :: Int -> Int
divisors x = product $ map ((+1).primePowers x)
                     $ filter (isDivisorOf x)
                     $ takeWhile (<=(div x 2)) primes
    where isDivisorOf v = (==0).(mod v)
          primePowers v p
              | mod v p /= 0 = 0
              | otherwise = 1 + primePowers (div v p) p

primes :: Integral a => [a]
primes = 2 : iterate nextPrime 3
    where nextPrime x = head $ filter isPrime[(x+1)..]

isPrime :: Integral a => a -> Bool
isPrime x = and $ [mod x p /= 0 | p <- takeWhile lowerThanSqrtX primes]
    where lowerThanSqrtX candidate = candidate <= (round $ sqrt $ fromIntegral x)

This time I avoided brute force, since I've got some useful math insights.

I remember from primary school that "the sum of all numbers from 1 to n is equal to n (n + 1) / 2". Later I learned that the such numbers are named Triangular numbers.

From such definition I derived the function triangleAt.

Looking at the function I got an insight: the factors of a triangular number should be equal to the product of the factors of its root and the factors of the root + 1.

After some google search I found a wikipedia page about the Divisor function that gave me the info I required.

First the divisors function definition:

Moreover I read that actually the divisor function is multiplicative: for any coprime pair a b it is true that d(a*b) = d(a) * d(b).

Since for all integer numbers are coprime with the succeeding one we can state that the

• d(triangularAt(x)) = d(x/2) * d(x + 1) when x is even
• d(triangularAt(x)) = d(x) * d((x + 1)/2) when x is odd

So to get the solution I simply had to halveEvens in the sequence of natural numbers and findResult between each number and the succeeding one.

Pubblicità

Per la prima volta guardo la pubblicità con riconoscenza.

Ho assistito ad un tale spettacolo, con Fazio, Saviano, Benigni e Abbado a Vieni via con me, che per avermelo offerto queste aziende meritano la mia riconoscenza.

• Divani e Divani
• Wind
• Pavesini
• Ford
• The social network
• Amadori
• Vodafone

Grazie.

Problem 11

What is the greatest product of four numbers on the same straight line in the given 20 by 20 grid?

import Data.List

solution = maximum $ map product $ allChunks [orizzontals, verticals, diagonals]
    where allChunks = concatMap (\f -> f 4 matrix) 

matrix = every 20 $ map read $ words "\
    \08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 \
    \49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 \
    \81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 \
    \52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 \
    \22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 \
    \24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 \
    \32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 \
    \67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 \
    \24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 \
    \21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 \
    \78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 \
    \16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 \
    \86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 \
    \19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 \
    \04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 \
    \88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 \
    \04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 \
    \20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 \
    \20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 \
    \01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"

every :: Int -> [a] -> [[a]]
every _ [] = []
every n list = take n list : (every n $ drop n list)

chunks :: Int -> [a] -> [[a]]
chunks size line = take (length line - size + 1) $ map (take size) $ tails line

orizzontals :: Int -> [[a]] -> [[a]]
orizzontals size = concat.(map $ chunks size)
    
verticals :: Int -> [[a]] -> [[a]]
verticals size = (orizzontals size).transpose 

diagonals :: Int -> [[a]] -> [[a]]
diagonals size matrix = (orizzontals size) $ getValues $ filter rightSize allDiagonals
    where getValues = map (map $ \(x,y) -> matrix!!y!!x)
          compareBy op (x, y) (x', y') = compare (op x y) (op x' y')
          sameBy    op (x, y) (x', y') = (op x y) == (op x' y')
          rightSize = (((<=) size).length)
          xAxe = [0..(length $ matrix!!0)-1]
          yAxe = [0..(length $ matrix)-1]
          allCoordinates = [(x,y) | y <- yAxe, x <- xAxe]
          diagonalsBy op = groupBy (sameBy op) $ sortBy (compareBy op) allCoordinates
          allDiagonals = diagonalsBy (+) ++ diagonalsBy (-)

Again a funny problem! :-)

The only interesting function is diagonals that extracts allDiagonals coordinates from the given matrix and than filters those that have the rightSize (greater or equal than the given size).
Finally it getValues from the matrix.

Naming domain model's unit tests

After some thought about a consistent naming convention for unit tests related to domain models, I reached a conclusion.

First of all I have to refactor my tests to get a single logical assertion per test.

I will prefix test fixtures with QA (for quality assurance): while "Test" and "Unit" are terms that appeares in many ubiquitous language (eg StressTest or MeasurementUnit).

I will keep the current namespace organization, that diverge from the organization of the classes under test, since it make it easer to check coverage with mono.

The method name will follow the following convention:

• each unit test name will start with the verb/method/message under test, followed by an underscore
• a description of the scenario/preconditions (tipically a semantical description of the arguments), followed by an underscore
• a description of the assertion

The form will be Verb_Scenario_Assertion.

Here some examples:

Claim_inValidLocation_replaceCargoState()
Unload_fromWrongVoyage_throwArgumentException()
SpecifyNewRoute_ValidSpecification_fireNewRouteSpecified()
Ctor_withNullIdentifier_throwArgumentNullException();
Append_ValidLeg_returnItinerary()

I'll add some words to the names (like "with", "fire" or "return") to clarify the test's semantic.

I'd really like to take some comment about this convention (since I've to refactor more than 400 tests right now, and I'd like to do such work only once).

Problem 10

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

solution = sum $ takeWhile (<2000000) primes
    
primes :: Integral a => [a]
primes = 2 : iterate nextPrime 3
    where nextPrime x = head $ filter isPrime[(x+1)..] 

isPrime :: Integral a => a -> Bool
isPrime x = and $ [mod x p /= 0 | p <- takeWhile lowerThanSqrtX primes]
    where lowerThanSqrtX candidate = candidate <= (round $ sqrt $ fromIntegral x)

Problem 9

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which, a² + b² = c².

For example, 3² + 4² = 9 + 16 = 25 = 5².

There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.

solution = head [a*b*(1000-a-b) | a <- [1..999], b <- [1..999], solveSystem a b]
    where solveSystem x y = 2000*x + 2000*y - (2*x*y) - 1000^2 == 0

Appling a bit of my liceal math I found that the system contains two equations:

• a² + b² - c² = 0
• a + b + c - 1000 = 0

From the second equation derive that c = 1000 - a - b that applied to the first equation produce the following equation (some step omitted :-D): 2000*x + 2000*y - (2*x*y) - 1000^2 == 0.


This time it was funny...

Problem 8

Find the greatest product of five consecutive digits in the 1000-digit number.

import Data.List

digits :: [Int]
digits = map (read.(:[])) "73167176531330624919225119674426574742355349194934\
         \96983520312774506326239578318016984801869478851843\
         \85861560789112949495459501737958331952853208805511\
         \12540698747158523863050715693290963295227443043557\
         \66896648950445244523161731856403098711121722383113\
         \62229893423380308135336276614282806444486645238749\
         \30358907296290491560440772390713810515859307960866\
         \70172427121883998797908792274921901699720888093776\
         \65727333001053367881220235421809751254540594752243\
         \52584907711670556013604839586446706324415722155397\
         \53697817977846174064955149290862569321978468622482\
         \83972241375657056057490261407972968652414535100474\
         \82166370484403199890008895243450658541227588666881\
         \16427171479924442928230863465674813919123162824586\
         \17866458359124566529476545682848912883142607690042\
         \24219022671055626321111109370544217506941658960408\
         \07198403850962455444362981230987879927244284909188\
         \84580156166097919133875499200524063689912560717606\
         \05886116467109405077541002256983155200055935729725\
         \71636269561882670428252483600823257530420752963450"

solution = maximum $ foldl (zipWith (*)) (repeat 1) $ take 5 $ tails digits

Emblematic of life: it require more effort to express the problem than the solution.

UnitTests' naming

I'm considering a rename for the 400+ unit tests of the DDDSample implementation I'm building for Epic.NET.

I've found differents approaches:

1. Roy Osherove's MethodName_StateUnderTest_ExpectedBehavior
2. Steve Sanderson’s subject_scenario_result
3. Google Testing's verbosily describing a responsibility of the object

Theorically speaking I think that they should all converge when applied to a domain model that expose an ubiquitous language.

Still I need to think a bit more about the best convention to adopt.

The worse problems relates to complex pre condition, multiple postconditions and events.