andreamurru blog

Musical dedicato al Beato don Vincenzo Romano - Napoli.com

Fri, 20 Nov 2009 14:29:07 -0800

Musical dedicato al Beato don Vincenzo Romano
Napoli.com
... dovevano essere frutto di un equilibrio perfetto tra fede, religione, storia e credenza popolare. Per questa ragione il lavoro preparatorio è stato ...

Gli uomini e il futuro – Seconda parte - MondoRaro.com

Fri, 20 Nov 2009 14:22:52 -0800

Gli uomini e il futuro – Seconda parte
MondoRaro.com
Oppure si pensi a Bacone, in cui il motivo moralistico-religioso si intreccia con quello scientifico: i naufraghi sbarcati nell'isola di Bensalem scoprono ...

Luca De Netto: la ... - BrindisiSera

Fri, 20 Nov 2009 14:05:46 -0800

Luca De Netto: la ...
BrindisiSera
Una sana laicità invece comporta la distinzione tra religione e politica, tra Chiesa e Stato, senza che ciò renda Dio un'ipotesi privata, escludendo a ...

Feltrinelli I Libri e Musica - Seven Press (Abbonamento)

Fri, 20 Nov 2009 13:04:25 -0800

Feltrinelli I Libri e Musica
Seven Press (Abbonamento)
... la teologia, la storia della scienza, l'epistemologia e la religione. Oltre a numerosi articoli su quotidiani e riviste specializzate, ha pubblicato tre ...

Realista è chi combatte la fame invocando la nostra conversione - Tempi.it

Fri, 20 Nov 2009 11:57:58 -0800

Realista è chi combatte la fame invocando la nostra conversione
Tempi.it
Quella lucidità ha una fonte precisa, «la fede» come «forza spirituale che purifica la ragione nella ricerca di un ordine giusto». ...

BOLOGNA: MARCHESINI (UNINDUSTRIA), IMPRESE NON SPENGONO MOTORE - AGI - Agenzia Giornalistica Italia

Fri, 20 Nov 2009 10:24:52 -0800

BOLOGNA: MARCHESINI (UNINDUSTRIA), IMPRESE NON SPENGONO MOTORE
AGI - Agenzia Giornalistica Italia
L'enciclica "Caritas in veritate" di Benedetto XVI e' stato il tema centrale di un convegno tenuto a Bologna e organizzato dalla Fondazione Unipolis e ...

Caso Orlandi: svolta nelle indagini ma per l'esperto non sapremo ... - Tiscali Europa

Fri, 20 Nov 2009 09:35:03 -0800

Tiscali Europa

Caso Orlandi: svolta nelle indagini ma per l'esperto non sapremo ...
Tiscali Europa
Ma come mai oggi gli inquirenti prestano fede a questa testimone, che in passato è stata grande consumatrice di cocaina e ha reso testimonianze tanto ...

altro »

CARD. CAFFARRA: UOMO NON VUOLE SEMPLICEMENTE 'VIVERE',MA 'BENE' (2) - AGI - Agenzia Giornalistica Italia

Fri, 20 Nov 2009 08:47:39 -0800

CARD. CAFFARRA: UOMO NON VUOLE SEMPLICEMENTE 'VIVERE',MA 'BENE' (2)
AGI - Agenzia Giornalistica Italia
... almeno per due ragioni: ci aiuta a capire il fatto sociale nelle sue espressioni fondamentali, alla luce congiunta della ragione e della fede. ...

altro »

CARD. CAFFARRA: UOMO NON VUOLE SEMPLICEMENTE 'VIVERE',MA 'BENE' - AGI - Agenzia Giornalistica Italia

Fri, 20 Nov 2009 08:39:10 -0800

CARD. CAFFARRA: UOMO NON VUOLE SEMPLICEMENTE 'VIVERE',MA 'BENE'
AGI - Agenzia Giornalistica Italia
... magistralis' con la quale ha illustrato, stasera, gli elementi essenziali dell'enciclica "Caritas in veritate" emanato in luglio da Benedetto XVI. ...

altro »

Università cattoliche, Papa Ratzinger: è li che risiede il sapere ... - Ciaopeople Magazine

Fri, 20 Nov 2009 08:39:02 -0800

Ciaopeople Magazine

Università cattoliche, Papa Ratzinger: è li che risiede il sapere ...
Ciaopeople Magazine
A sostenerlo è Papa Benedetto XVI Benedetto XVI ricorda il valore ei compiti delle Università Cattoliche nella società moderna e di come il loro sia un ...
Benedetto XVI alle università cattoliche: il vostro ruolo è ... Radio Vaticana
Agenzia Fides Congregazione per l'Evangelizzazione dei Popoli Fides
PAPA: RUOLO UNIVERSITA' CATTOLICHE E' INSOSTITUIBILE Agenzia di Stampa Asca
Avvenire.it - AGI - Agenzia Giornalistica Italia
tutte le notizie (8) »

Benedetto XVI incontra leader chiesa anglicana - Il Sole 24 Ore

Fri, 20 Nov 2009 06:30:43 -0800

Il Sole 24 Ore

Benedetto XVI incontra leader chiesa anglicana
Il Sole 24 Ore
LONDRA - Primo incontro sabato tra il Papa e il leader della Chiesa anglicana da quando Benedetto XVI ha aperto ai protestanti piu' tradizionalisti ...
Anglicani e ortodossi. Il cardinale Kasper tra due fuochi L'Espresso
La visita a Roma del primate anglicano Rowan Williams. Domani l ... Radio Vaticana
ANGLICANI: PRIMATE WILLIAMS DOMANI A ROMA, VEDRA' PAPA E CARD. KASPER Agenzia di Stampa Asca

tutte le notizie (8) »

Papa: riaffermare legalita' Benedetto XVI: e' il primato della ... - Borsa Italiana

Fri, 20 Nov 2009 06:22:16 -0800

Borsa Italiana

Papa: riaffermare legalita' Benedetto XVI: e' il primato della ...
Borsa Italiana
In occasione della VI conferenza nazionale, tramite il segretario di Stato Bertone, Benedetto XVI ha inviato un telegramma nel quale aggiunge che il ...
BENEDETTO XVI: ALLA CONFERENZA SUI NON UDENTI, UNA DIGNITA' DA ... Toscana Oggi
L'appello di Benedetto XVI in favore dei non udenti: la società ... Radio Vaticana
Giustizia: Papa, riaffermare cultura della legalità e primato ... Blitz quotidiano

tutte le notizie (10) »

L'Europa sul web? Non è ancora unita

Fri, 20 Nov 2009 06:08:44 -0800

Una mappa fotografa la discussione politica europea online. Ancora pochi i contatti tra le varie comunità

Domani Papa Benedetto XVI incontra gli artisti nella Cappella Sistina - 06blog.it

Fri, 20 Nov 2009 04:34:45 -0800

Domani Papa Benedetto XVI incontra gli artisti nella Cappella Sistina
06blog.it
L'elenco degli ospiti che hanno confermato la loro presenza è ricco e vario, con esponenti di ogni disciplina artistica e culturale. ...
Il Papa incontra gli artisti nella Cappella Sistina Radio Vaticana

tutte le notizie (2) »

Radio Sure, un internet radio player per Windows gratuito

Fri, 20 Nov 2009 03:29:19 -0800

Chi apprezza la radio non potrà non gradire questo applicativo, che si presenta con uno slogan accattivante:

A Colurania per scoprire le parole dell'Universo - abruzzo24ore.tv

Fri, 20 Nov 2009 03:11:57 -0800

A Colurania per scoprire le parole dell'Universo
abruzzo24ore.tv
Fede e ragione collaborano perfettamente. Oltre ad illustrare le strumentazioni scientifiche realizzate con il contributo degli Istituti di ricerca e delle ...

GIUSTIZIA: BENEDETTO XVI, RIAFFERMARE CULTURA DELLA LEGALITA' - Adnkronos/IGN

Fri, 20 Nov 2009 03:07:22 -0800

GIUSTIZIA: BENEDETTO XVI, RIAFFERMARE CULTURA DELLA LEGALITA'
Adnkronos/IGN
(Adnkronos) - Il segretario di Stato Vaticano monsignor Tarcisio Bertone, ha inviato, a nome di Papa Benedetto XVI il 'saluto beneaugurante' ai partecipanti ...

CRT, LCD, Plasma e OLED a confronto: i display al plasma e i loro vantaggi (5/10)

Fri, 20 Nov 2009 02:54:38 -0800

Depeche raggiunti dal futuro - La Stampa

Fri, 20 Nov 2009 02:30:38 -0800

Depeche raggiunti dal futuro
La Stampa
Max Planck,il grande fisico, parlava di scienza ma se avesse conosciuto la musica rock avrebbe volentieri esteso il suo lucido ragionamento a quel magico ...

altro »

Approvato lo standard Power over Ethernet plus

Fri, 20 Nov 2009 02:30:01 -0800

REALbasic 2009 release 4, una recensione (3/4)

Fri, 20 Nov 2009 01:43:50 -0800

Andando a curiosare in questa variante di BASIC compilata e orientata agli oggetti, troviamo nella struttura del linguaggio qualcosa di vecchio accanto a qualcosa di nuovo, aspetto esemplificato tra... (continua...)

Attenti a inviare commenti volgari sul Web: possono costare il lavoro

Fri, 20 Nov 2009 01:23:50 -0800

Un post sul blog di un giornalista ha costretto alle dimissioni un impiegato di una scuola americana

Il cervello del gatto clonato in un chip

Fri, 20 Nov 2009 01:22:19 -0800

Lo studio degli scienziati Ibm e della Stanford University. «Daremo ai robot la facoltà cognitiva». «Tra dieci anni realizzeremo anche quello umano»

Guida ai cavi e connettori: il formato SVGA (1/2)

Fri, 20 Nov 2009 01:16:30 -0800

Il formato

Creare oggetti Flash con SwishMax (1/2)

Fri, 20 Nov 2009 00:57:05 -0800

Uno dei prodotti più interessanti tra quelli commercializzati da

Alla vigilia dell'incontro con gli artisti papa Benedetto fa da ... - L'Espresso

Thu, 19 Nov 2009 23:39:31 -0800

ExibArt

Alla vigilia dell'incontro con gli artisti papa Benedetto fa da ...
L'Espresso
La prima lezione che Benedetto XVI ne ha tratto è che l'arte e la fede cristiana si chiamano l'un l'altra, "perché entrambe possono e vogliono parlare di ...
La bellezza immutabile dell'arte nelle parole di Papa Benedetto XVI Il Sole 24 Ore
Scoprire Dio tramite l'arte La Stampa
Ecco chi ci sarà. Tutto pronto per l'Incontro di Papa Benedetto ... ExibArt
AsiaNews - Radio Vaticana
tutte le notizie (14) »

«La pirateria? Può passare di moda»

Thu, 19 Nov 2009 22:45:19 -0800

Sull'esempio di iTunes: chi fornisce buona musica a prezzi ragionevoli è destinato a un successo inaspettato

Del Noce, filosofo e profeta del fallimento del marxismo - Il Tempo

Thu, 19 Nov 2009 21:19:10 -0800

Del Noce, filosofo e profeta del fallimento del marxismo
Il Tempo
Il primo è quello sacrale caratterizzato dalle religioni secolari: nazismo, comunismo, fascismo. Il secondo è quello profano caratterizzato dal fenomeno ...
Doppio anniversario Affaritaliani.it

tutte le notizie (3) »

Sconcerto per le dichiarazioni di Frascerra - Estense.com

Thu, 19 Nov 2009 19:24:12 -0800

Sconcerto per le dichiarazioni di Frascerra
Estense.com
La terza, infine, è che si annuncia una sorta di “controconvegno” della scienza cattolica (ma perché, la scienza varia a seconda della religione?). ...

La gestione degli utenti con lo Zend Framework

Thu, 19 Nov 2009 03:53:14 -0800

L'implementazione delle funzionalità che gestiscono gli account utente in una applicazione web è un'attività tutt'altro che semplice: richiede infatti particolare attenzione, perché su tali... (continua...)

I Closure tool di Google per ottimizzare la programmazione in JavaScript

Thu, 19 Nov 2009 03:40:17 -0800

Da Microsoft un dispositivo ferromagnetico di input

Thu, 19 Nov 2009 03:31:16 -0800

Dopo i dispositivi multitouch, nei laboratori di ricerca Microsoft è allo studio un dispositivo che apre nuove prospettive di interazione utente-macchina: si tratta infatti di un device composto da

Le migliori invenzioni del 2009

Thu, 19 Nov 2009 03:26:49 -0800

Le innovazioni più significative secondo la rivista «Popular Science»

I nuovi layout per JavaFX

Thu, 19 Nov 2009 03:19:32 -0800

Un recente

Rilevare il denaro contraffatto con il sensore del mouse

Thu, 19 Nov 2009 02:27:12 -0800

Il problema del denaro contraffatto è sempre attuale; una recente statistica ha stabilito che, al momento,

Le reti di computer: indirizzi IP pubblici, privati, statici e dinamici (2/2)

Thu, 19 Nov 2009 02:16:34 -0800

Esistono anche altre due classi di indirizzi un po' particolari, di cui è utile avere conoscenza. La prima definisce il range di indirizzi 127.0.0.0–127.255.255.255, riservato per usi privati;

Una trasmissione coast-to-coast a 20 Gb/s

Thu, 19 Nov 2009 02:08:12 -0800

La tecnologia

Accuratezza e affidabilità di Wikipedia, alcuni dati (3/3)

Wed, 18 Nov 2009 23:56:04 -0800

Nel settembre dello stesso anno, il cofondatore di Wikipedia,

SugarCRM, un software open source per il customer relationship management (3/3)

Wed, 18 Nov 2009 23:40:05 -0800

Concludiamo questa panoramica su

Forlì, incontro tra fede e ragione: “Il cristianesimo è garanzia ... - RomagnaOggi.it

Wed, 18 Nov 2009 14:10:09 -0800

Forlì, incontro tra fede e ragione: “Il cristianesimo è garanzia ...
RomagnaOggi.it
La netta divaricazione fra fede e ragione, come due mondi a se stanti e sovrapposti, è un retaggio dell'illuminismo, ma si giustifica storicamente anche con ...

Pirate Bay, fine di un'era

Wed, 18 Nov 2009 10:18:24 -0800

Il servizio svedese ha deciso di spegnere lo storico tracker con cui era nato.Ma continua «la lotta»

Senza aldilà che fede è? - Avvenire.it

Wed, 18 Nov 2009 01:59:42 -0800

Senza aldilà che fede è?
Avvenire.it
Ragione e fede, hanno finito con il presentarsi e il giustificarsi quali forme essenzialmente differenti, e persino dialettiche, del conoscere. ...

MILANO CAPITALE DELLA 'PACE' - Milano Web

Wed, 18 Nov 2009 01:35:15 -0800

Mondo3 (Blog)

MILANO CAPITALE DELLA 'PACE'
Milano Web
Nel percorso alla pace hanno fallito la politica, la religione ei progetti militari, l'unica che può riuscirci è la scienza perchè 'uguale' in tutto il ...
SCIENZA: A MILANO 'SCIENCE FOR PEACE' PER IL DISARMO UNIVERSALE (3) Libero-News.it
Le donne di Science for peace oneBlog (Blog)
Science for Peace: quattro donne per la stessa speranza di pace Blogosfere (Blog)
Adnkronos/IGN - Key4biz (Abbonamento) - WebMasterPoint.org
tutte le notizie (65) »

Una vulnerabilità del protocollo SSL permette di attaccare Twitter

Wed, 18 Nov 2009 01:14:24 -0800

, che ha completato la sua tesi all'

Generare ID hardware univoci con il .NET Framework

Wed, 18 Nov 2009 01:08:42 -0800

Il manager

CRT, LCD, Plasma e OLED a confronto: contrasto dinamico e statico (4/10)

Wed, 18 Nov 2009 00:45:34 -0800

Esiste comunque un modo, seppure non ottimale, per aumentare il rapporto di contrasto negli LCD, ed è conosciuto come

Tutti a scuola con CoFFEE (2/2)

Wed, 18 Nov 2009 00:26:43 -0800

Concludiamo la carrellata, iniziata nel

Samsung lancia un concorso per sviluppatori

Wed, 18 Nov 2009 00:21:40 -0800

Fino al 10 dicembre è possibile iscriversi e partecipare al

La cieca fede di Erdogan nei musulmani - Medarabnews

Tue, 17 Nov 2009 22:45:25 -0800

La cieca fede di Erdogan nei musulmani
Medarabnews
Il loro istrionismo non va certo applaudito, ma non vi è ragione di peggiorare le cose, consentendo a gente come Erdogan di svolgere un ruolo di mediazione, ...

altro »

La Nasa conferma: «C'è acqua sulla Luna»

Tue, 17 Nov 2009 07:47:35 -0800

Un mese fa la sonda LCROSS aveva lanciato missile-proiettile contro un cratere alla ricerca di riserve idriche

La Groenlandia si scioglie in fretta

Tue, 17 Nov 2009 07:28:37 -0800

Uno studio rivela che la calotta della «terra verde» sta perdendo massa rapidamente

Facciamo sesso quasi per caso

Tue, 17 Nov 2009 06:16:08 -0800

Studi Usa: due miliardi di anni fa le creature asessuate cambiarono (per rafforzarsi) sistema di riproduzione

Se è la donna ad ammalarsi il rischio divorzio è più alto

repubblicawww@repubblica.it — Tue, 17 Nov 2009 05:30:10 -0800

PSICOLOGIA

(15:30 17/11/2009)

SCIENZA: ''EVOLUZIONISMO E RELIGIONE'', CONVEGNO INTERNAZIONALE A ... - Libero-News.it

Tue, 17 Nov 2009 02:20:29 -0800

SCIENZA: ''EVOLUZIONISMO E RELIGIONE'', CONVEGNO INTERNAZIONALE A ...
Libero-News.it
Nelle sessioni successive e centrali del convegno verranno affrontate problematiche inerenti alla natura del rapporto tra evoluzionismo biologico, scienze ...
CULTURA: DARWINISMO E RELIGIONE, CONVEGNO INTERNAZIONALE A FIRENZE Agenzia di Stampa Asca
CLT - Firenze, tre giorni per parlare di evoluzionismo e religione Il Velino

tutte le notizie (11) »

Benedetto XVI: Internet un'opportunità. Cattedrali nella Rete - PCWorld

Mon, 16 Nov 2009 02:44:04 -0800

euronews

Benedetto XVI: Internet un'opportunità. Cattedrali nella Rete
PCWorld
Papa Benedetto XVI, nel salutare l'evento, ha spiegato che a proposito dei nuovi media "è importante considerare non solo la loro indubbia capacità di ...
FAO: OSSERVATORE, LE PAROLE DEL PAPA SARANNO ASCOLTATE? AGI - Agenzia Giornalistica Italia
Benedetto XVI: internet è un tema di grande attualità Quomedia
BENEDETTO XVI, ANGELUS: IL SEME DELLA PAROLA DI DIO TRASFORMA IL MONDO Toscana Oggi
Il Giornale del Friuli Libero - AsiaNews - Borsa Italiana
tutte le notizie (116) »

Obama agli studenti cinesi: "Diritti umani universali e no alla ... - Adnkronos/IGN

Mon, 16 Nov 2009 00:41:48 -0800

NanoPress (Blog)

Obama agli studenti cinesi: "Diritti umani universali e no alla ...
Adnkronos/IGN
Il presidente americano Barack Obama, per l'atteso incontro con un gruppo di 500 studenti riuniti nel Museo di Scienza e Tecnologia di Shanghai, ...
Pechino, Obama: «Usa e Cina non sono avversari» Barimia
EST - Obama in Cina: "Libertà e diritti valori universali" Il Velino
Obama e Hu Jintao, gli “accordi” sul protezionismo economico e ... AsiaNews
Italiainformazioni - La Voce d'Italia
tutte le notizie (442) »

La corsa della tv. Con gli occhiali

Sun, 15 Nov 2009 12:27:08 -0800

Cambiamenti a catena per gli apparecchi televisivi: nel 2010 arriva il 3D. All’inizio serviranno lenti polarizzate per guardare gli schermi da 50 pollici

L'eros della donna la pillola del desiderio

repubblicawww@repubblica.it — Sun, 15 Nov 2009 04:02:37 -0800

FARMACI

(14:02 15/11/2009)

La tristezza aguzza l'ingegno più attenti, meno pregiudizi

repubblicawww@repubblica.it — Sat, 14 Nov 2009 07:37:04 -0800

PSICOLOGIA

(17:37 14/11/2009)

Google Books, c'è un nuovo accordo

Sat, 14 Nov 2009 07:30:26 -0800

Dovrebbe risolvere le questioni di diritti d'autore e di antitrust sollevate dal Dipartimento di Giustizia Usa

Trovata l'acqua sulla Luna "Una significativa quantità"

repubblicawww@repubblica.it — Fri, 13 Nov 2009 09:15:20 -0800

SCOPERTE

(19:15 13/11/2009)

Acqua sulla Luna, nuovi indizi Al polo sud c'è tanto idrogeno

repubblicawww@repubblica.it — Fri, 13 Nov 2009 09:02:20 -0800

SPAZIO

(19:02 13/11/2009)

Un iceberg gigante nell'oceano Pacifico

Fri, 13 Nov 2009 01:10:02 -0800

Lungo 500 metri e alto 50, rappresenta un evento raro. Se si rompesse, sarebbe un pericolo per la navigazione

Quale musica ci piace di più? A deciderlo è il nostro Dna

repubblicawww@repubblica.it — Fri, 13 Nov 2009 00:34:34 -0800

RICERCA

(10:34 13/11/2009)

Farmaci test e tanti soldi parlano le cavie umane

repubblicawww@repubblica.it — Thu, 12 Nov 2009 23:39:07 -0800

RICERCA

(09:39 13/11/2009)

Un asteroide ha sfiorato la Terra

Thu, 12 Nov 2009 05:54:48 -0800

È passato a soli 14 mila chilometri dal nostro pianeta, cioè 30 volte più vicino rispetto alla Luna

Una nuvola digitale sul cielo di Londra

Thu, 12 Nov 2009 01:49:43 -0800

«The Cloud», futuristica struttura progettata da un team di artisti e ingegneri, tra cui molti italiani

Il computer per ultra-sessantenni

Wed, 11 Nov 2009 10:43:27 -0800

Comandi ridotti all'osso e icone giganti per navigare online e fare social-networking

«La banda larga non è una scelta»

Wed, 11 Nov 2009 06:07:30 -0800

Aziende e consumatori :«Internet veloce è una necessità, e la decisione di congelare i fondi è paradossale»

Sony prova a passare prima dal web

Tue, 10 Nov 2009 08:14:01 -0800

L'azienda giapponese distribuirà negli Usa prima su internet che su dvd il suo ultimo cartoon

Faccia a faccia con il contagio un chip per prevenire la malattia

repubblicawww@repubblica.it — Tue, 10 Nov 2009 08:02:03 -0800

RICERCA

(18:02 10/11/2009)

La macchina del Big Bang si blocca. Per una briciola di pane

Mon, 09 Nov 2009 05:12:46 -0800

Lasciata cadere da un uccellino, manda in tilt l’acceleratore del Cern di Ginevra

Protesi all'anca in aumento I progressi degli ultimi anni

repubblicawww@repubblica.it — Sun, 08 Nov 2009 05:59:55 -0800

MEDICINA

(15:59 08/11/2009)

Benedetto XVI: "Il mondo ha bisogno di una chiesa povera e libera" - il Giornale

Sun, 08 Nov 2009 02:33:36 -0800

La Voce d'Italia

Benedetto XVI: "Il mondo ha bisogno di una chiesa povera e libera"
il Giornale
Brescia - Occorre pregare e lavorare "perché nasca un mondo fraterno in cui ognuno non viva per sé ma per gli altri": lo ha detto papa Benedetto XVI ...
BRESCIA: BENEDETTO XVI VISITA CASA NATALE PAOLO VI Adnkronos/IGN
Il 68 di Papa Montini La Stampa
Papa/ Benedetto XVI a Brescia per trent'anni morte Paolo VI APCOM
La Voce d'Italia - Brescia Oggi - TGCOM
tutte le notizie (288) »

Dal cinema arriva il chirurgo in 3D

repubblicawww@repubblica.it — Sun, 08 Nov 2009 00:21:20 -0800

SOFTWARE

(10:21 08/11/2009)

QI sopra la media? Non basta Essere "smart" è molto di più

repubblicawww@repubblica.it — Sat, 07 Nov 2009 13:16:05 -0800

INTELLIGENZA

(23:16 07/11/2009)

Svelato il mistero dei raggi cosmici

Sat, 07 Nov 2009 06:20:35 -0800

Come nascono e come accelerano nel cosmo grazie agli studi sul cuore della galassia M82

Google svela ciò che sa dei propri utenti

Fri, 06 Nov 2009 04:26:42 -0800

L'azienda Usa ha introdotto «dashboard» una funzione che consente agli utenti di visualizzare i dati raccolti

Porte girevoli per l'energia dalle onde

Thu, 05 Nov 2009 05:17:11 -0800

Ogni porta, posizionata da 6 a 23 metri sotto la superficie del mare, può generare 300 chilowatt

Il supercomputer Roadrunnera caccia di materia oscura

Wed, 04 Nov 2009 03:35:03 -0800

Pronto all’uso il supercomputer più veloce del mondo, che occupa 560 metri quadrati di spazio

Per il clima «noi» possiamo fare quasi quanto il protocollo di Kyoto

Wed, 04 Nov 2009 03:32:42 -0800

Uno studio indica i criteri da adottare come singoli cittadini per ridurre le emissioni riscaldanti

In vacanza tra le stelle dal 2012 l'hotel Galactic

repubblicawww@repubblica.it — Mon, 02 Nov 2009 22:25:05 -0800

SPAZIO

(08:25 03/11/2009)

POL - Papa: teologia invito a meditare Scritture e dare ragione fede - Il Velino

Wed, 28 Oct 2009 04:59:31 -0700

POL - Papa: teologia invito a meditare Scritture e dare ragione fede
Il Velino
Roma, 28 ott (Velino) - Il Papa ha proposto oggi “una pagina di storia” ai fedeli riuniti in Piazza San Pietro per l'udienza generale. ...
Papa: tra fede e ragione “una naturale amicizia” quando cercano la ... AsiaNews
PAPA: PIU' ATTENZIONE A LETTURE BIBBIA DURANTE LA MESSA Agenzia di Stampa Asca
Il Papa all'udienza generale: migliore attenzione alla Messa e ... Radio Vaticana
Romasette.it
tutte le notizie (8) »

The Dependency Structure Matrix

Carlo.Pescio — Wed, 21 Oct 2009 09:25:00 -0700

Design is about making decisions; diagrams encode some of those decisions. Consider this simple component diagram:

We have 3 "physical" components (e.g. DLLs) X, C, D. X is further partitioned in 2 logical components: in this real-world case, the designer used namespaces to identify separate logical components inside a single physical component. The designers is also telling us that A and B depends on D, B depends on C, C depends on D. So far, so good.

UML diagrams, however, cannot easily convey some part of the reasoning. In a sense, to fully grasp the designer's intention, we have to understand not only what is in the diagram, but also what is not in the diagram. This may seem unusual, but is easily explained. Consider the picture above again. There is no dependency between A and C. Now, maybe A doesn't currently need to access C (and therefore there is no dependency) but if we need to access C from A tomorrow, it's just fine to add a dependency. Or maybe the designer's intent was to shield A from C, possibly using B as a man-in-the-middle.
That's not obvious from the diagram, and there is no place in the diagram to say that (not with a formal, standard UML syntax). Of course, good names may help. Replacing B with something more meaningful, maybe mentioning a bridge or proxy pattern, may suggest that A is not supposed to interact with C.

Is there a better way? Maybe something that can be actually checked against code? Checking code compliance with diagrams may seem so passe' or even plain absurd, given the current trend of discarding diagrams and/or reverse-engineering diagrams from code. Still, here is a real-world story:
The design above (which is, of course, largely simplified) was handed out from the original designers-implementers to a larger (offshore) team. They explained some of the design rationale (informally), and after a while, they left the company. Months later, the offshore team needed a new service from C inside A, so they did the simplest thing that can possibly work: they called C from A. After all, A and B are inside the same physical component. Whatever B can do, A can do too.
Unfortunately, a cornerstone of the original design was that A should never talk to C. The dependency was not in the diagram, because it was not supposed to exist, ever.

The team manager knew that, but given the size of the real X (about 500 KLOC) she couldn't possibly review all the changes from the offshore team. Of course, at least someone in the offshore team didn't fully grasp the designer's intent.

So, back to the original question: is there a better way? I could say "a forcefield diagram" :-), but in this specific case, there is also a well-known engineering tool: the Dependency Structure Matrix (also known as the Design Structure Matrix). A DSM encodes dependencies between "things". Not just dependencies, but also forbidden dependencies. See the following picture:

The 5 green "Y" cells correspond to the 5 existing dependencies; the "N" cells correspond to the "missing" dependencies, but they say something more: that those dependencies are forbidden. Now, this is a useful piece of information, something that can be easily checked against code. That does not mean that we can't change the design: it simply means we don't want to change the design inadvertently, just by typing in some code that was not supposed to be there. Checking code against the abstract design should just prompt a review; the design could be wrong, in which case, it should be changed (along with the DSM).

There is some interesting literature about DSM in software, most from Baldwin and Clark of "Design Rules" fame, but also from others (like one I mentioned back in 2005). There are also quite a few tools to reverse-engineer a DSM from code, which makes checking code against the designed DSM relatively trivial (the bad side is that some languages, like C++, are notably hard to reverse engineer, so tools are lacking; Java and C# have both free and commercial tools available). I'm not aware of any UML tool that can generate a DSM from the diagrams, but that's theoretically trivial, and could even be built as a plug-in for some CASE tools.

As usual, there is more to say about the DSM, gravity, and the forcefield. I'll save that for my next post!

A ForceField Diagram

Carlo.Pescio — Mon, 05 Oct 2009 05:35:00 -0700

The Design Rationale Diagram I discussed in my previous post is hardly complete, and it could be vastly improved by asking slightly different questions, leading to different decision paths. Still, it's a reasonable first-cut attempt to model the decision process. It can be used to communicate the reasoning behind a specific decision, in a specific context.

That, however, is not the way I really think. Sure, I can rationalize things that way, but it's not the way I store, recall, organize information inside my head. It's not the way I see the decision space.
In the end, software design is about things going together and things staying apart, at all the granularity levels (see also my post on partitioning).
As I progress in my understanding of forces, I tend to form clusters. Clusters are born out of attraction and rejection inside the decision space. I've found that thinking this way helps me reach a better understanding of my design instinct, and to communicate my thoughts more clearly.

Now, although I've been thinking about this for long while (not full-time, lucky me :-), I can't say I have found the perfect representation. The decision space in inherently multi-dimensional, and I always end up needing more dimensions that I can fit either in 2D or 3D. Over time, I tried several notations, inventing things from scratch or borrowing from other domains. Most were dead ends. In the end, I've chosen (so far :-) a very simple representation, based on just 3 concepts (possibly 4 or 5).

- nodes
Nodes represent information, which is our material. Information has fractal nature, and I don't bother if I'm mixing up levels. Therefore, a node may represent a business goal, or the adoption of a tool or library, or a nonfunctional requirement, or a specific component, class, function. While most methods are based on a strict separation of concepts, I find that very limiting.

- an attraction relationship
Nodes can attract each other. For instance, a node labeled "reliable" may attract a node labeled "redundant" when reasoning about the large display problem. I just connect the two nodes using a thick line with little "hands" on the ends. I place attracted nodes close to each other.

- a rejection relationship
Nodes can reject each other. For instance, stateful most clearly reject stateless :-). Some technology might be at odd with another. A subsystem must not depend on another. And so on. Nodes that reject each other are placed at some distance.

It's all very simple and unsophisticated. Here is an example based on the large display problem, inspired by the discussion on design rationale:

and here are two diagrams I've used in real-world projects recently, scaled down to protect the innocent:

The relationship between a node, a cluster, and an Alexandrian center is better left for another time. Still, a node in one diagram may represent an entire cluster, or an entire diagram. Right now I'm tempted to use a slightly different symbol (which would be the fourth) to represent "expandable" nodes, although I'm really trying to keep symbols to a bare minimum. I'm also using colors, but so far in a very informal way.

As simple as it is, I've found this diagram to be very effective as a reasoning device, while too many diagrams end up being mere documentation devices. I can sit in front of my (large :-) screen, think and draw, and the drawing helps me focus. I can draw this on a whiteboard in a meeting, and everyone get up to speed very quickly on what I'm doing.

This, however, is just half the story. We can surely work with informal concepts and diagrams, and that's fine, but what I'm trying to do is to add precision to the diagram. Precision is often confused with details, like "a class diagram is more precise if you show all the parameters and types". I'm not looking for that kind of "precision". Actually, I don't want this diagram to be redundant with code at all; we already have many code-like diagrams, and they all get down the same roads (generate code from diagrams or generate diagrams from code). I want a reasoning device: when I want to code, I'm comfortable with code :-).

I mostly want to add precision about relationships. Why, for instance, is there an attraction between Slow Client and Stateful? Informally, because if we have a stateful system, the slow client can poll on its own terms, or alternatively, because the client may use a sophisticated subscription based on the previous state. Those options, by the way, could be represented on the forcefield diagram itself (adding more nodes, or a nested diagram); but that's still the "informal" reasoning. Can we make it any more formal, precise, grounded on sound principles?

This is where the ongoing work on concepts like gravity, frequency, and so on kicks in. Slow Client and Stateful are attracted because on a finer granularity (another, perhaps better, diagram) "Slow Client" means a publisher and a subscriber operating at different frequencies, and a stateful repository is a well-known strategy (a pattern!) to provide Isolation between systems operating at different frequencies (together with synchronization or transactions).

Now, I haven't introduced the concept of Isolation yet (though I mentioned something on my Facebook page :-), so this is sort of a spoiler :-)), but in the end I hope to come up with a simple reasoning system, where you can start with informal concepts and refine nodes and forces until you reach the "universal", fractal forces I'm discussing in the "Notes on Software Design" posts. That would give a solid ground to the entire diagram.

A final note on the forcefield diagram: at this stage, I'm just using Visio, or more exactly, I'm abusing some stencils in the Visio library. I wanted something relatively organic, mindmap-like. Maybe one day I'll move back to some 3D ideas (molecular structures come to mind), but I've yet to see how this scales to newer concepts, larger problems, and so on. If you want to play with it, I can send you the VSS file with the stencils.

Ok, I'll get back to Frequency (and Interference and Isolation and more :-) soon. Before that, however, I'd like to take a diversion on the Dependency Structure Matrix. See ya!

Representing Design Rationale Inside Activity Diagrams

Carlo.Pescio — Mon, 31 Aug 2009 11:11:00 -0700

Design is about making choices. We often do so on the fly, leaning on experience and intuition, by talking about the problem with colleagues, or borrowing from literature (e.g. patterns). We also make some choice by habit, which is a different form of experience, one that has higher risk of becoming disconnected with the real problem.
Most of this process is tacit, and even when we discuss choices openly, it doesn't get recorded. Sometimes, a list of pros/cons is made when there is some disagreement about the best option.

This all works well when the problem is simple, but sometimes even experienced designers feel like they're not grasping the essential issues, that something has not yet been found, named, disentangled. This is when having yet one more tool can prove useful.
Now, I don't usually go through the effort to model and transcribe the rationale behind each and every design choice I make. It could be interesting, also from a pedagogical point of view, but it would take a lot of time and would probably disrupt my thought processes. However, when the issues are particularly thorny/unclear, or when there is a large disagreement on the best choice (or even on the goals and criteria), I've found that getting design rationale out of our individual heads and talk on a shared representation can move things a little forward.

Over the years, I've tried out a number of tools, approaches, and so on; lately, I've tried using Activity Diagrams in a rather unorthodox way, to represent my reasoning about design, not design itself. The idea is not to encode your decisions ex-post, but ex-ante, while you're thinking (that is, while they're still options, not decisions). Also, the diagram must be considered quite fluid, as it shows our current understanding, and we're building the diagram to improve our understanding.

Enough talk, let's see a realistic example. I'll refer to the Large Display problem I discussed a few months ago. Actually, I'll just cover the initial choice between using a real-time database or an IPC/messaging system. It's gonna be quite a mouthful anyway!

To start, I'll have to draw a line between a messaging system and a RTDB, and that in itself is not easy. I'll go for a very simple distinction, because my goal here is not really to talk about RTDBs, but about design rationale (the usual "look at the moon, not at the finger" concept).
So, consider a control system that reads some data from the field and then needs to publish those data for other processes. It could just send data through a messaging (publish/subscribe) system. Here I define a messaging system as stateless, meaning it simply keeps track of subscriptions, and sends everything that is published to the subscribers (according to some criteria, like message type or tag). It does not keep an history, or a snapshot of what has been last sent. Therefore, it cannot apply some filters, like "notify me only if the difference between the previous value and the current value is above a threshold" because the previous value is just not stored. Also, when a subscriber is started, it cannot get the current snapshot of the system, because it is not there: it will have to wait for messages to come, incrementally. Shortly stated, a RTDB will keep a snapshot of the system, and well, you can figure out the difference. Of course, a RTDB is also more complex.

So, how do we choose between a messaging system and a RTDB? We may write down a long list of pro/cons, but that's really unstructured, and that's not the way our brain works. To provide more structure, I use an Activity Diagram with orthogonal swimlanes (all the following pictures are taken from Star UML, a free tool that is rather fast and unobtrusive).
The vertical swimlanes are flexible: they represent the main concerns. The horizontal swimlanes are fixed: they provide structure.

For the Large Display problems, we could start with a few main concerns like performance, reliability, cost, and so on. We just drop the names on the vertical swimlanes. My template is then partitioned in 3 horizontal bands: the root question, the reasoning, the outcome. Everything inside is dynamic, and changes as we understand more: even the root questions may change, as we discover larger or smaller, independent problems. Sometimes, even the main concerns change, as we discover options or issues we didn't consider before.

We can focus on just one concern right now, let's say performance (don't we all like performance? :-). A first-cut, interesting top-level question could be: is the published data rate high or low? If the rate is low and we have no persistent state, when you turn on the large display you see nothing: you have to wait till some data gets published. On the other hand, if the rate is high, it may even overwhelm the display system: there is little need to refresh a value a thousand times per second. That actually depends on the display: if it's a real-time plot, you may want a high refresh rate too.

Ok, we could start modeling this part of our reasoning using the familiar activity diagram symbols. Actually, since most of the nodes here would be decision nodes, I just omit the diamond and use an activity node with multiple outgoing paths to show choices.

Note: The empty boxes are just placeholders for some later reasoning. It's just laziness on my side :-) and they wouldn't appear in a real diagram.

Now, this seems just like a decision tree, but it's slightly different. First, it's a decision graph: common choices between paths are shared, and this is a precious information because it shows crucial choices (more on this later). Second, it's a multifaceted graph: every vertical swimlane shows a facet of a more complex reasoning; for instance, what is good for performance might not be good for reliability or cost.

Let's try to move ahead a little. When the incoming data rate is higher than what [most] clients need, we have basically two choices:
1) smarter subscriptions; they could still be rather dumb, like "no more than 3 times per second" or much smarter like "when relative change is higher than 5%, but no more than 5 times per second". Note that the latter is more suited to a RTDB than to a stateless messaging system.
2) change paradigm and move to client-initiated polling. The clients will ask for data with their own timing. Of course, at this point we give up the possibility of not asking for data if the value has not changed. Anyway, this again requires some kind of stateful middleware; a messaging system won't do.
When data rate is low, but high startup time for clients is not an option, we can't wait for data to come: we have to poll, at least at startup. So, polling can solve two problems, of course at expense of bandwidth if it is the only available option.

While drawing this, we may come to the conclusion that we need to ask better questions: are we building a publisher-driven or a client-driven system? If it's client-driven, it cannot be stateless! What do we really know about clients? How many there will be? What about publishers? What is the typical data rate and configuration? What are we aiming for? Do we need to narrow the expectations? This might change the top question (client Vs. publisher driven) or even some concern. That's fine, it means the technique is working :-) and that it's helping us thinking.

Now, it would take quite a lot of time to explore all the facets of even a simple system like this. Actually, most people won't even do it in real life: they will fall in love with one idea, spend most of their time preaching and rationalizing about the virtues of their idea, and never really take the time to go through this kind of process. Still, trying to work out the "Reliability" swimlane would prove interesting. For instance, a common technique to achieve reliability is redundancy. Redundancy is much easier for a stateless system. Redundancy is easier when clients don't have to subscribe at all, but can simply poll. And so on. If you have some spare time, you may want to give it a try.

The notation I use is quite informal. I could improve that easily: UML is fairly flexible; so far I didn't, because people can grasp it anyway, even when I drop in the < < or > > to represent options or when I have just one arrow coming out, meaning that I've just decomposed a choice and a consequence. It's just a reasoning workflow, and I haven't felt the need to make it any more precise than that.

Back to the forcefield: the rationale is not the forcefield. The rationale, however, is talking about forces and centers. Outcomes (messaging and RTDB) are centers. Main choices, like "client driven" or "stateless", are again centers. Those centers are attracting or rejecting each other. This is the forcefield. This is closer to the way I think in the back of my mind, how I "see" the system, how I keep options open. Now, I just need a way to show this. That's for my next post :-).

When in doubt, do the right thing

Carlo.Pescio — Wed, 08 Jul 2009 02:43:00 -0700

The bright side of spending most of my professional time on real-world projects is that I have an endless stream of inspiration, and what is even more important, the possibility of trying out new ideas, concepts, and methods. The dark side is that the same source of inspiration is taking away the precious time I would need to encode, structure, articulate knowledge, that therefore remains largely implicit, tacit, intuitive. The pitch black side is that quite often I'd like to share some real-world story, but I can't, as the details are kinda classified or just to protect the innocent. Sometimes, however, the story can be told with just a little camouflage.

Weeks ago, I was trying to figure out the overall architecture of a new system, intended to replace an obsolete framework. I could see a few major problems, two of which were truly hard to solve without placing a burden on everyone using the framework. Sure, we had other details to work out, but I could see no real showstoppers except for those two. The project manager, however, didn't want to face those problems. She wanted to start with the easy stuff, basically re-creating structures she was familiar with. I tried to insist about the need to figure out an overall strategy first, but to no avail. She wanted progress, right here, right now. That was a huge mistake.

Now, do not misunderstand me: I'm not proposing to stop any kind of development before you work every tiny detail out. Also, in some cases, the only real way to understand a system is by building it. However, building the wrong parts first (or in this case, building the easy parts first) is always a big mistake.

Expert designers know that in many cases, you have to face the most difficult parts early on. Why? Because if you do it too late, you won't have the same options anymore; previous decisions will act like constraints on late work.

Diomidis Spinellis has recently written a very nice essay on this subject (IEEE Software, March/April 2009). Here is a relevant quote: On a blank sheet of paper, the constraints we face are minimal, but each design decision imposes new restrictions. By starting with the most difficult task, we ensure that we’ll face the fewest possible constraints and therefore have the maximum freedom to tackle it. When we then work on the easier parts, the existing constraints are less restraining and can even give us helpful guidance.

I would add more: even if you take the agile stance against upfront design and toward emergent design, the same reasoning applies. If you start with the wrong part, the emergent design will work against you later. Sure, if you're going agile, you can always refactor the whole thing. But this reasoning is faulty, because in most cases, the existing design will also limit your creativity. It's hard to come up with new, wild ideas when those ideas conflict with what you have done up to that moment. It's just human. And yeah, agile is about humans, right? :-)

Expert designer start with the hard parts, but beginners don't. I guess I can quote another nice work, this time from Luke Hohmann (Journey of the Software Professional - a Sociology of Software Development): Expert developer's do tend to work on what is perceived to be the hard part of the problem first because their cognitive libraries are sufficiently well developed to know that solving the "hard part first" is critical to future success. Moreover, they have sufficient plans to help them identify what the hard part is. Novices, as noted often fail to work on the hard-part-first for two reasons. First, they may not know the effectiveness of the hard part first strategy. Second, even if they attempt to solve the hard part first, they are likely to miss it.

Indeed, an expert analyst, or designer, knows how to look at problems, how to find the best questions before looking for answers. To do this, however, we should relinquish preconceived choices. Sure, experts bring experience to the table, hopefully in several different fields, as that expands our library of mental plans. But (unlike many beginners) we don't approach the problem with pre-made choices. We first want to learn more about the forces at play. Any choice is a constraint, and we don't want artificial constraints. We want to approach the problem from a clean perspective, because freedom gives us the opportunity to choose the best form, as a mirror of the forcefield. By the way, that's why zealots are often mediocre designers: they come with too many pre-made choices, or as a Zen master would say, with a full cup.

Of course, humans being humans, it's better not to focus exclusively on the hard stuff. For instance, in many of my design sessions with clients, I try to focus on a few simple things as we start, then dig into some hard stuff, switch back to something easy, and so on. That gives us a chance to take a mental break, reconsider things in the back of our mind, and still make some progress on simpler stuff. Ideally, but this should be kinda obvious by now, the easy stuff should be chosen to be as independent/decoupled as possible from the following hard stuff, or we would be back to square one :-).

In a sense, this post is also about the same thing: writing about some easy stuff, to take a mental break from the more conceptual stuff on the forcefield. While, I hope, still making a little progress in sharing some useful design concept. See you soon!

Design Rationale

Carlo.Pescio — Tue, 09 Jun 2009 07:34:00 -0700

In the past few weeks I've taken a little time to write down more about the concept of frequency; while doing so, I realized I had to explore the concept of forcefield better, and while doing so (yeap :-)) I realized there was a rather large overlap between the notion of forcefield and the notion of design rationale.

Design rationale extends beyond software engineering, and aims to capture design decisions and the reasoning behind those decisions. Now, design decisions are (ideally) taken as trade-offs between several competing forces. Those forces creates the forcefield, hence the large overlap between the two subjects.

The concept of design rationale has been around for quite a few years, but I haven't seen much progress either in tools or notations. Most often, tools fall into the “rationalize after the fact” family, while I'm more interested in reasoning tools and notations, that would help me (as a designer) get a better picture about my own thoughts while I'm thinking. That resonates with the concept of reflection in action that I've discussed in Listen to Your Tools and Materials a few years ago.

So, as I was reading a recent issue of IEEE Software (March/April 2009), I found a list of recent (and not so recent) tools dealing with design rationale in a paper by Philippe Kruchten, Rafael Capilla, Juan Carlos Dueñas (The Decision View’s Role in Software Architecture Practice), and I decided to take a quick ride. Here is a very quick summary of what I've found.

Seurat
Seurat (see also the PDF tutorial on the same website) is based on a very powerful language / model, but the tool (as implemented) is very limiting. It's based on a tree structure, which makes for a nice todo list, but makes visual reasoning almost impossible. Actually, in the past I've investigated on using the tree format myself (and while doing so, I discovered others have done the same: see for instance the Reasoning Tree pattern), but restricting visualization to (hyperlinked) nodes in a tree just does not work when you're facing difficult problems.

Sysiphus
Sysiphus seems to have recently morphed into another tool (UniCase), but from the demo of UniCase it's hard to appreciate any special support for design rationale (so far).

AREL
(see also some papers from Antony Tang on the same page; Antony also had an excellent paper on AREL in the same issue of IEEE Software)
AREL is integrated with Enterprise Architect. Integration with existing case tools (either commercial or free) seems quite a good idea to me. AREL uses a class diagram (through a UML profile) to model design rationale, so it's not limited to a tree format. Still, I've found the results rather hard to read. It seems more like a tool to give structure to design knowledge than a tool to reason about design. As I go through the examples, I have to study the diagram; it doesn't just talk back to me. I have to click around and look at other artifacts. The reasoning is not in the diagram, it's only accessible through the diagram.

PAKME
Honestly, PAKME seems more like an exercise in building a web-based collaboration tool for software development than a serious attempt at providing a useful / usable tool to record design rationale. It does little more than organize artifacts, and it requires so many clicks / page refresh to get anything done that I doubt a professional designer could ever use it (sorry guys).

ADDSS
ADDSS is very much like PAKME, although it adds a useful Patterns section. It's so far from what I consider a useful design tool (see my for more) that I can't really think of using it (sorry, again).

Knowledge Architect
Again, a tool with some good ideas (like Word integration) but far from what I'm looking for. It's fine to create a structured design document, but not to reason about difficult design problems.

In the end, it seems like most of those tools suffer from the same problems:
- The research is good; a nice metamodel is built, some of the problems faced by professional designers seem to be well understood.
- The tool does little more than organize knowledge, would get in the way of the designer thinking about thorny issues, does not help through visualization, and is at best useful at the end of the design process, possibly to fake some rationality, a-la Parnas/Clements.

That said, AREL is probably the most promising tool of the pack, but in the end I've being doing pretty much the same for years now, using (well, abusing :-) plain old use case diagrams to model goals and issues, with a few ideas taken from KAOS and the like.

Recently, I began experimenting with another standard UML diagram (the activity diagram) to model some portion of design reasoning. I'll show an example in my next post, and then show how we can change our perspective and move from design reasoning to the forcefield.

Good Design

Carlo.Pescio — Tue, 02 Jun 2009 04:49:00 -0700

I rarely (if ever) blog about technology, mostly because once you cut the marketing cr@p, consumer technology is often so moot. Still, a few days ago I read about local dimming in the news section of IEEE Computer. A good designer should be quick to spot good (or intriguing) design, and that idea struck me as an excellent use of technology.

It's also interesting to look at it from a forcefield perspective. CCFLs had several drawbacks as light sources for LCD displays. Some of those issues have been resolved using LED backligthing instead, but if we stop there, we're just using new technology to solve the exact same problem we solved with yesterday's technology. That's usually the wrong approach, as the old technology was part of a larger design, a larger forcefield, and it managed to resolve only some of those forces.

Back to local dimming, the idea is amazingly simple from the forcefield perspective: instead of using lamps for ligthing and LCD for contrast, color, etc, split some of the work between the LEDs and the LCD. This can be done because once we introduce a LED matrix, the forcefield itself changes. This has long been known: when we introduce technology, we can even change the problem itself.

Of course, we face similar issues in software all the time. I wrote something along the same lines in IEEE Software back in 1997 (When Past Solutions Cause Future Problems). I wasn't talking forcefield back then, but the "ask why" suggestion is very much forcefield friendly. More on this shortly, as I'm trying to catch up with many ideas I didn't have time to blog about, and write them down in small chunks...

Interesting paper

Carlo.Pescio — Sun, 10 May 2009 09:24:00 -0700

While looking for something else, I stumbled on a paper with an intriguing title: The Ambiguity Criterion in Software Design by Álvaro García and Nelson Medinilla.

I encourage readers interested in the concepts of design and form to take a look. Although I don't really like the term "ambiguity" (it makes for a catchy title, but it's commonly used with quite a different semantics) I think the paper is dealing with an interesting, pervasive attribute of software.

If you have read my previous posts on software design, you may recognize (although not spelled that way) the [almost] fractal nature of "ambiguity". Actually, as I spoke of "n-degrees of separation" in a previous post, I had some overlapping concepts in mind. Curiously enough, subtyping is also mentioned in another article I've recommended time ago about symmetry and symmetry breaking.

I think there is something even more primitive than that at play here, something more fractal in nature, something that has to do with names and identities or (as the authors note) abstractions and instances. I also mentioned a problem with compile-time names in the post above, so there is a lot of stuff pointing the same direction!

I have to think more about that, but first I'll have to write down what's left about frequency...

Einstellung

Carlo.Pescio — Fri, 01 May 2009 12:51:00 -0700

As I mentioned in previous posts, one of the projects I've been recently involved with is a complete rewriting of the GUI layer for a rather large system. We want to move from an MFC-based framework to .NET, mostly to improve productivity.
Initially, we'll basically move the GUI as-is, without re-designing the human-computer interaction. Therefore, it would pay to recover as much information as possible from the existing system, and do it automatically.

Among other things, we have about 250 dialog boxes to port, so I thought it would be a good idea to write a translator from the Win32 RC format to whatever new format we need. This way, we can recover layout (positioning and sizes) and also translate each control to their nearest equivalent.

That means, of course, that we know the target, and today, the .NET game boils down to choosing between Windows Forms and WPF. The choice is rather hard, althogh I know many programmers would jump immediately on the WPF bandwagon. Anyway, as we discussed the translator above, the project manager observed that WinForms stores everything in code. If we ever have to do this kind of change again, she said, we will miss the simplicity of RC. XAML would make layout and controls easier to move to another technology, just as RC.

That's true; I don't particularly like the idea of having to parse C# to recover layout information, control initialization parameters, and so on.

Funny thing is, for a while I got trapped in this parsing concept. I guess it has to do with education. Any computer scientist will recognize this as a parsing and translation problem. It's a well known problem frame. And that calls for a parser, of course :-).

It took me a while to realize I didn't have to write a parser at all: I could just use reflection! To test the idea, I wrote a simple C# program (about 60 lines of code) which takes a form and recursively dumps layout and initialization parameters in an XML format.

For instance, given this form:

where the blue rectangle is a panel, and the label and button are nested controls, I'll get this XML.

The idea is pretty simple: I dump every property without a Browsable(false) attribute, that is, everything that you can change at design-time. If the Controls collection is not empty, I'll recurse into it. The nice part is that it could be made to work also for dynamic controls, created at run-time and not a design-time. Just call the translator after all the controls have been created, and that's it.

Things could be easily improved. Right now, I don't handle collections (see bindings), non-visual components, and I dump every single property. It would be useful, perhaps, to dump only values that have been changed. That's easy, just create a control of the same class on the fly, and check for differences. Piece of cake.

Now, I wish I could say I thought of this through my understanding of the forcefield :-). But I can't. It just came to me. Dunno how. The problem, of course, is moving past the Einstellung effect of education. What can I say? Keep your mind open, practice lateral thinking, never give up :-). And yeah, well, keep an eye on that forcefield, as that may help too...

Bad Luck, or "fighting the forcefield"

Carlo.Pescio — Sun, 26 Apr 2009 13:08:00 -0700

In my previous post, I used the expression "fighting the forcefield". This might be a somewhat uncommon terminology, but I used it to describe a very familiar situation: actually, I see people fighting the forcefield all the time.

Look at any troubled project, and you'll see people who made some wrong decision early on, and then stood by it, digging and digging. Of course, any decision may turn out to be wrong. Software development is a knowledge acquisition process. We often take decisions without knowing all the details; if we didn't, we would never get anything done (see analysis paralysis for more). Experience should mitigate the number of wrong decisions, but there are going to be mistakes anyway; we should be able to recognize them quickly, backtrack, and take another way.

Experience should also bring us in closer contact with the forcefield. Experienced designers don't need to go through each and every excruciating detail before they can take a decision. As I said earlier, we can almost feel, or see the forcefield, and take decisions based on a relatively small number of prevailing forces (yes, I dare to consider myself an experienced designer :-).
This process is largely unconscious, and sometimes it's hard to rationalize all the internal reasoning; in many cases, people expect very argumentative explanations, while all we have to offer on the fly is aesthetics. Indeed, I'm often very informal when I design; I tend to use colorful expressions like "oh, that sucks", or "that brings bad luck" to indicate a flaw, and so on.

Recently, I've found myself saying that "bad luck" thing twice, while reviewing the design of two very different systems (a business system and a reactive system), for two different clients.
I noticed a pattern: in both cases, there was a single entity (a database table, a in-memory structure) storing data with very different timing/life requirements. In both cases, my clients were a little puzzled, as they thought those data belonged together (we can recognize gravity at play here).
Most naturally, they asked me why I would keep the data apart. Time to rationalize :-), once again.

Had they all been more familiar with my blog, I would have pointed to my recent post on multiplicity. After all, data with very different update frequency (like: the calibration data for a sensor, and the most recent sample) have a different fourth-dimensional multiplicity. Sure, at any given point in time, a sensor has one most recent sample and one set of calibration data; therefore, in a static view we'll have multiplicity 1 for both, suggesting we can keep the two of them together. But bring in the fourth dimension (time) and you'll see an entirely different picture: they have a completely different historical multiplicity.

Different update frequencies also hint at the fact that data is changing under different forces. By keeping together things that are influenced by more than one force, we expose them to both. More on this another time.

Hard-core programmers may want more than that. They may ask for more familiar reasons not to put data with different update frequencies in the same table or structure. Here are a few:

- In a multi-threaded software, in-memory structures requires locking. If your structure contains data that is seldom updated, that means it's being read more than written: if it's seldom read and seldom written, why keep it around at all?
Unfortunately, the high-frequency data is written quite often. Therefore, either we accept to slow down everything using a simple mutex, or we aim for higher performances through a more complex locking mechanism (reader/writer lock), which may or may not work, depending on the exact read/write pattern. Separate structures can adopt a simpler locking mechanism, as one is being mostly read, the other mostly written; even if you go with a R/W lock, here it's almost guaranteed to have good performance.

- Even on a database, high-frequency writes may stall low-frequency reads. You even risk a lock escalation from record to table. Then you either go with dirty reads (betting on your good luck) or you just move the data in another table, where it belongs.

- If you decide to cache database data to improve performances, you'll have to choose between a larger cache with the same structure of the database (with low frequency data too) or a smaller and more efficient cache with just the high-frequency data (therefore revealing once more that those data do not belong together).

- And so on: I encourage you to find more reasons!

In most cases, I tend to avoid this kind of problems instinctively: this is what I really call experience. Indeed, Donald Schön reminds us that good design is not for everyone, and that you have to develop your own sense of aesthetics (see "Reflective Conversation with Materials. An interview with Donald Schön by John Bennett", in Bringing Design To Software, Addison-Wesley, 1996). Aesthetics may not sound too technical, but consider it a shortcut for: you have to develop your own ability to perceive the forcefield, and instinctively know what is wrong (misaligned) and right (aligned).

Ok, next time I'll get back to the notion of multiplicity. Actually, although I've initially chosen "multiplicity" because of its familiarity, I'm beginning to think that the whole notion of fourth-dimensional multiplicity, which is indeed quite important, might be confusing for some. I'm therefore looking for a better term, which can clearly convey both the traditional ("static") and the extended (fourth-dimensional, historical, etc) meaning. Any good idea? Say it here, or drop me an email!

Notes on Software Design, Chapter 5: Multiplicity

Carlo.Pescio — Mon, 30 Mar 2009 06:54:00 -0700

Gravity, as we have seen, provides a least resistance path, leading to monolithic software. If gravity was the only force at play, all software would be a monolithic blob. That being not the case, there must be other forces at play. Pervasive, primitive forces just like gravity, setting up a different forcefield, so that it's more convenient to keep things apart.

Consider an amateur programmer, writing a simple program to keep track of his numerous books. He starts with a database-centric approach, and without much knowledge of conceptual modeling, he jumps into creating tables. He creates a Book table, and adds a few fields:
AuthorFirstName, AuthorLastName, Title, Publisher, ISBN, …
It doesn't take much for him to realize that an author could be present several times in his database. He may begin to realize that he could perhaps add an Author table and move AuthorFirstName and AuthorLastName to that table.

Why? He doesn't know squat about database normalization. It's just a simple matter of multiplicity. One author - many books. Different multiplicity suggests to keep things apart. It is quite a good suggestion, as different multiplicity basically requires different gravitational centers, lest we end up with an unfavorable forcefield.
Consider what happens when our amateur programmer discovers he wants to add more biographical data about authors. Without an Author table, there is not any good gravitational center that could possibly attract those data. There is only the Book table, so there they go - adding more data redundancy.

Our amateur programmer, however, might not be so eager to give in. A single table is easier to manage. No foreign keys, no referential integrity, no nothing. It's just simpler, and he doesn't live in the future. He wants to do the simplest thing that could possibly work, so he keeps the Author fields inside the Book table.

He doesn't need much more, however, to realize that many books have more than one author. One book - many authors. That's a different forcefield again, with a many-to-many relationship. Now, our amateur is rather stubborn. He wants to keep things inside a single table anyway. So he goes on and adds more fields:

AuthorFirstName1, AuthorLastName1, AuthorFirstName2, AuthorLastName2, AuthorFirstName3, AuthorLastName3, Title, Publisher, ISBN, …

Of course, at this point he can basically feel he's no longer going along the path of least resistance. Actually, he's fighting the forcefield. Sure, gravity wants him to keep things together, but multiplicity doesn't. The form he's trying to give to the Book table is not in frictionless contact with the forcefield. The forcefield wants Book and Author to stay on their own.

Multiplicity is the primordial force that keeps [software] things apart. It shouldn't come as a surprise, then, that a great emphasis is given to multiplicity in the Entity-Relationship model and also in the static view of OO models (class diagram).
Multiplicity, however, goes much deeper than that. Reusability is a special case of multiplicity. What? :-). Well, it that sounds odd, you're not thinking fourth dimensionally (as Doc said in "Back to the future").

Consider a different problem, at a different granularity. Our amateur programmer is writing another small application, to keep track of who has borrowed some of his precious books. He's doing the simplest thing again, so he's basically going GUI-centered, and he's putting all the business logic inside the form itself. When you click on "Ok", the form will validate data and store a record into some table. The form requires, among other things, a phone number, which must be validated. It's the only place where he has to validate a phone number, so he puts the validation logic right inside the OnOk method generously provided by his RAD tool.

What's wrong? Apparently, there is no multiplicity at play here. There is one function, where he's doing two distinct things (validation and insertion), and inside validation he's doing different things, but each one is intended to validate one field, so it wouldn't pay to move the field validation logic elsewhere. Gravity keeps things together.

Multiplicity is hidden in the fourth dimension: time. Reusability means being able to take something you have already written (in the past) and use it again, unchanged, in the future. It means you have multiple callers, just not at the same time. If you think fourth dimensionally, multiplicity comes out quite clearly.

Multiplicity is an interesting force, one we need to be very familiar with. It will take a few posts to give it justice. Right now, it's time for me to put my running shoes on and hit the road :-). Still, here are a few pointers to some important issues that I'm going to cover in the next weeks (or months :-)

The fractal nature of multiplicity
Maintainability
Scalability
Conway's Law
Tools and Languages - lowering costs
Good questions to ask while doing analysis and design.
Is multiplicity stronger than gravity?
Examples from patterns. On truly understanding Abstract Factory.
N-degrees of separation.
Interfaces and Multiplicity - what is separation, anyway?
Cross-cutting concerns.
Down-to-earth guidelines.
The Display problem, once again.

Notes on Software Design, Chapter 4: Gravity and Architecture

Carlo.Pescio — Sun, 22 Feb 2009 14:40:00 -0800

In my previous posts, I described gravity and inertia. At first, gravity may seem to have a negative connotation, like a force we constantly have to fight. In a sense, that's true; in a sense, it's also true for its physical counterpart: every day, we spend a lot of energy fighting earth gravity. However, without gravity, like as we know it would never exist. There is always a bright side :-).

In the software realm, gravity can be exploited by setting up a favorable force field. Remember that gravity is a rather dumb :-) force, merely attracting things. Therefore, if we come up with the right gravitational centers early on, they will keep attracting the right things. This is the role of architecture: to provide an initial, balanced set of centers.

Consider the little thorny problem I described back in October. Introducing Stage 1, I said: "the critical choice [...] was to choose where to put the display logic: in the existing process, in a new process connected via IPC, in a new process connected to a [RT] database".
We can now review that decision within the framework of gravitational centers.

Adding the display logic into the existing process is the path of least resistance: we have only one process, and gravity is pulling new code into that process. Where is the downside? A bloated process, sure, but also the practical impossibility of sharing the display logic with other processes.
Reuse requires separation. This, however, is just the tip of the iceberg: reuse is just an instance of a much more general force, which I'll cover in the forthcoming posts.

Moving the display logic inside a separate component is a necessary step toward [independent] reusability, and also toward the rarely understood concept of a scaled-down architecture.
A frequently quoted paper from David Parnas (one of the most gifted software designers of all times) is properly titled "Designing Software for Ease of Extension and Contraction" (IEEE Transactions on Software Engineering, Vol. 5 No. 2, March 1979). Somehow, people often forget the contraction part.
Indeed, I've often seen systems where the only chance to provide a scaled-down version to customers is to hide the portion of user interface that is exposing the "optional" functionality, often with questionable aesthetics, and always with more trouble than one could possibly want.

Note how, once we have a separate module for display, new display models are naturally attracted into that module, leaving the acquisition system alone. This is gravity working for us, not against us, because we have provided the right center. That's also the bright side of the thorny problem, exactly because (at that point, that is, stage 2) we [still] have the right centers.

Is the choice of using an RTDB to further decouple the data acquisition system and the display system any better than having just two layers?
I encourage you to think about it: it is not necessarily trivial to undestand what is going on at the forcefield level. Sure, the RTDB becomes a new gravitational center, but is a 3-pole system any better in this case? Why? I'll get back to this in my next post.

Architecture and Gravity
Within the right architecture, features are naturally attracted to the "best" gravitational center.
The "right" architecture, therefore, must provide the right gravitational centers, so that features are naturally attracted to the right place, where (if necessary) they will be kept apart from other features at a finer granularity level, through careful design and/or careful refactoring.
Therefore, the right architeture is not just helping us cope with gravity: it's helping us exploit gravity to our own advantage.

The wrong architecture, however, will often conjure with gravity to preserve itself.
As part of my consulting activity, I’ve seen several systems where the initial partitioning of responsibility wasn’t right. The development team didn’t have enough experience (with software design and/or with the problem domain) to find out the core concepts, the core issues, the core centers.
The system was partitioned along the wrong lines, and as mass increased, gravity kicked in. The system grew with the wrong form, which was not in frictionless contact with the context.
At some point, people considered refactoring, but it was too costly, because mass brings Inertia, and inertia affects any attempt to change direction. Inertia keeps a bad system in a bad state. In a properly partitioned system, instead, we have many options for change: small subsystems won’t put up much of a fight. That’s the dream behind the SOA concept.
I already said this, but is worth repeating: gravity is working at all granularity levels, from distributed computing down to the smallest function. That's why we have to keep both design and code constantly clean. Architecture alone is not enough. Good programmers are always essential for quality development.

What about patterns? Patterns can lower the amount of energy we have to spend to create the right architecture. Of course, they can do so because someone else spent some energy re-discovering good ideas, cleaning them up, going through shepherding and publishing, and because we spent some time learning about them. That said, patterns often provide an initial set of centers, balancing out some forces (not restricted to gravity).
Of course, we can't just throw patterns against a problem: the form must be in effortless contact with the real problem we're facing. I've seen too many good-intentioned (and not so experienced :-) software designers start with patterns. But we have to understand forces first, and adopt the right patterns later.

Enough with mass and gravity. Next time, we're gonna talk about another primordial force, pushing things apart.

See you soon, I hope!

Ricerca Programmatore .NET / C#

Carlo.Pescio — Sun, 15 Feb 2009 02:31:00 -0800

Un mio cliente in zona Bologna cerca un programmatore .NET / C# per assunzione a tempo indeterminato. Il progetto, che seguo anche io con una certa frequenza, riguarda la migrazione della user interface di un prodotto molto grande dal C++ al C#/.NET.
Caratteristiche desiderabili: buon programmatore al di la' del linguaggio usato, conoscenza del C# e della piattaforma .NET, delle Windows Form e magari anche un po' di WPF, capacita' di lavorare in team, voglia di scrivere codice ma anche di pensare e confrontarsi su scelte progettuali (no cowboy programming), niente fondamentalismi perche' capitera' spesso di integrarsi con la piattaforma nativa. In quest'ottica, un po' di conoscenza del C++ e del C++/CLI (o la voglia di acquisirla) non farebbero male.
Come dicevo, seguo il progetto piuttosto da vicino, e posso dire che sara' una buona occasione di crescita professionale per chi vuole muoversi all'interno di prodotti di grandi dimensioni. E' richiesta la presenza in sede.
Mandate a me il CV, all'indirizzo jobs@eptacom.net, le candidature interessanti le discutero' con l'azienda e vi mettero' direttamente in contatto.

Visual C++ 2008 bug (C++/CLI)

Carlo.Pescio — Mon, 19 Jan 2009 01:24:00 -0800

I wrote some faulty code recently. Actually, the code was right, but the compiler didn't like it anyway. It took a while to discover it was a (known) compiler bug, so I hope I can save someone else's time by providing a link to relevant the Microsoft page: Static variable in native method causes exception c0020001 during process exit.

Shortly stated, if you use a local static variable (inside a function/method), and the type of that variable has a native/unmanaged destructor, the compiler gets confused and emits a managed destructor instead. Of course, that happens if your compilation unit is in mixed mode (native + managed).

Unfortunately, in my case the local static variable was inside a template, shared between native and mixed compilation units. In the end, we didn't adopt Microsoft suggestion of a separate unit (which kinda makes all the C++/CLI magic to disappear), but I just changed the type of the static to remove the destructor. That requires some tweaking, and I still hope we'll get a fix from Microsoft, although the page above reports a discouraging "Won't fix" decision...

Notes on Software Design, Chapter 3: Mass, Gravity and Inertia

Carlo.Pescio — Wed, 14 Jan 2009 10:15:00 -0800

I thought I could discuss the whole concept of Gravity and its implications in 2 or 3 (long) posts. While writing, I realized I'll need at least 4 or 5. So, this time I'll talk a little about how we can cope with gravity, and about the concept of Inertia. Next time, I'll discuss how we can exploit gravity, and why (despite the obvious cost) it is important that we do not surrender to (or ignore) gravity.

How do we cope with gravity? Needless to say, we have to spend some energy to move away from the amorphous big blob. As usual, we can also borrow some of that energy from someone (or something) else. Here are a few well-proven ideas:

- Architecture. I used to define architecture as "an overall structure, providing a natural place for features and concepts". I could now say that architecture must provide the right centers, or (from the viewpoint of mass and gravity) the right gravitational centers, so that the system can grow harmoniously. The right architecture is also the key to exploit gravity. More about this (and about the role of design patterns) next time.

- Refactoring. While architecture requires some kind of upfront investment, refactoring fights gravity in a more piecemeal, continuous fashion.
Although Refactoring and Emergent Design are often seen as the arch-enemies of Architecture, they are not. Experienced developers know that both are needed, as they work at different scales.
No amount of architecture, for instance, will ever prevent small-scale gravity to attract more code into existing functions. When we add a new feature (maybe under a tight deadline) gravity suggests to add that feature in place, often without even breaking the smallest separation unit – the function.
Conversely, gravity (and even more so Inertia) does not allow refactoring to scale economically beyond some (hard to identify) threshold.

- Measurement and Correction. While refactoring is often performed on-the-fly by programmers, fixing bad smells as they go, we can also use automatic tools to help us keep the code within some quality bounds. See Simple Metrics and More on Code Clones for a few ideas. Of course, measures provide guidance, but then the usual refactoring techniques must be applied.

- Visualization. More on this another time.

- Better Languages and Technologies. At some granularity level, technology becomes either a boon or an hindrance. Consider components: creating binary, release-to-release compatible components in C++ is a nightmare. .NET, for instance, does a much better job. Languages with a simple grammar, like Java and C#, or with strong support for reflection, also allows better tools to be built (see next point)

- Better Tools. Consider web services. They provide a relatively painless way to create a distributed system. The lack of pain doesn't really come from SOAP (which isn't that stroke of genius), but from the underlying HTTP/XML infrastructure and from the widely available, easily interoperable WSDL tools. Consider also refactoring: without good tools, it's a relatively error-prone activity. Refactoring tools make it much easier to fight gravity, moving code around with relatively little effort.

On Inertia
Mass brings gravity. Gravitational attraction works to preserve the existing structure (at the fractal levels I discussed in Chapter 1). In the physical world, however, we have another interesting manifestation of mass, called Inertia. There are many formulations of the concept (see the wikipedia page for details), but what is most interesting here is the simple F=m*a equation. We apply external forces (human work) to a system, but systems with a large mass won't easily change their state of rest or motion (including their current direction).

What is, then, the state of rest/motion for a software system? We could provide several analogies. To find the best analogy for acceleration, we need the best analogy for speed. To find the best analogy for speed, we need the best analogy for space.

The underlying idea must be that we apply some effort to move our software through space. What is the nature of that space? A few real-world examples are needed. Consider a C++/MFC application; we want to migrate the GUI layer to C#/.NET (interestingly, "migration" is commonly used to indicate motion in space). Consider a monolithic, legacy application that must be exposed as a service; or a web application that requires some performance improvement. Sure, all this may require some change in mass too (as some code will be added, some removed), but what is required is to move the software to a different place. What is that place, or, inside which kind of space do we want to move? I encourage you to think about this on your own for a while, before reading further.

My answer is rather simple: that space is the decision space. Software is built by making a number of decisions: we choose languages, technologies, architectural styles, coding styles (e.g. error handling styles, readability/efficiency trade offs, etc.), and so on. We also choose a development process, a team, etc.
Some of those decisions are explicit and carefully worked out. Some are taken on the fly as we code. At any given time, our software is located in a specific (albeit difficult to define) place inside a huge, multi-dimensional decision space. Each decision affects some portion of code. Some are clearly separated. Some are pervasive or cross-cutting.

Software development is a learning process; therefore, some of those decisions will be wrong. Some will be right for a while, but since real-world software does not live in a vacuum, we'll have to change them anyway later.
Changing a decision requires moving our software through the decision space: every decomposition unit affected by that decision will be touched, therefore adding to the mass to be moved (hence the deadly cost of cross-cutting, pervasive concerns).

Inertia explains why some decisions are so hard to change. Any decision we change is bound to require a change in the state of rest, or motion, of our software, because we want to move it into another place.
Some of those decisions impact a large mass of software, and therefore a strong force must be applied. Experience shows that after a critical mass is reached, it becomes so hard to even understand what to do, that software becomes an immovable object (therefore requiring an irresistible force :-).

Of course, small systems won't show much inertia, which explains why the dynamics of programming in the small are different from the dynamics of programming in the large.

Also, speed and acceleration depends also on time. I'll save this for a later time, as I still have to understand a few things better :-)

Enough for today. See you guys soon!

Merry Christmas!

Carlo.Pescio — Wed, 24 Dec 2008 04:53:00 -0800

May peace, joy and... fun be with you!

DisableProcessWindowsGhosting

Carlo.Pescio — Mon, 08 Dec 2008 03:31:00 -0800

I tend to think that I know the Windows API quite well. In the past few years I've been using mostly the Kernel API, since .NET has made most (but not all) of the others kinda useless. Still, there are times when only knowledge of the right API can save the day. There are also times when the right API can save the day, but nobody (myself included) knows about it :-).

A few days ago, while working on a large, legacy application that we're slowly moving into modern times, we faced an unexpected challenge. The process was busy doing some math. There is only one thread involved, so the GUI was supposed to be frozen, as we do not dispatch Windows messages while doing math. We actually counted on that, for reasons too long to be explained here.

Unfortunately, as we know, in Windows XP and Vista we can move a top-level window around even if the process is not responding, and that broke our expectations.

Now, armed with some background on Windows internals, that XP/Vista feature always seemed odd. Moving a window requires, among other things, that the window itself answers the WM_NCHITTEST message. If our process is stuck doing math, it's unlikely to answer that message.

Looking around with Spy++ we discovered that (most reasonably) the movable window was a fake (ghost) window, hosted by Windows itself into another process. Great: we just needed a way to disable that behavior for our application. Unfortunately, I didn't know any :-).

It took a careful digging to discover the magic API: DisableProcessWindowsGhosting. We never stop learning :-).

As an aside, that old app is supposed to run on Windows 2000 as well (yeap :-), and the magic API requires Windows XP or above, but good old GetProcAddress will take care of that...

Notes on Software Design, Chapter 2: Mass and Gravity

Carlo.Pescio — Sat, 06 Dec 2008 11:28:00 -0800

Mass is a simple concept, which is better understood by comparison. For instance, a long function has bigger mass than a short one. A class with several methods and fields has bigger mass than a class with just a few methods and fields. A database with a large number of tables has bigger mass than a database with a few. A database table with many fields has bigger mass than a table with just a few. And so on.

Mass, as discussed above, is a static concept. We don't look at the number of records in a database, or at the number of instances for a class. Those numbers are not irrelevant, of course, but they do not contribute to mass as discussed here.

Although we can probably come up with a precise definition of mass, I'll not try to. I'm fine with informal concepts, at least at this time.

Mass exerts gravitational attraction, which is probably the most primitive force we (as software designers) have to deal with. Gravitational attraction makes large functions or classes to attract more LOCs, large components to attract more classes and functions, monolithic programs to keep growing as monoliths, 1-tier or 2-tiers application to fight as we try to add one more tier. Along the same lines, a single large database will get more tables; a table with many fields will attract more fields, and so on.

We achieve low mass, and therefore smaller and balanced gravity, through careful partitioning. Partitioning is an essential step in software design, yet separation always entails a cost. It should not surprise you that the cost of [fighting] gravity has the same fractal nature of separation.

A first source of cost is performance loss:
- Hardware separation requires serialization/marshaling, network transfer, synchronization, and so on.
- Process separation requires serialization/marshaling, synchronization, context switching, and so on.
- In-process component separation requires indirect function calls or load-time fix-up, and may require some degree of marshaling (depending on the component technology you choose)
- Interface – Implementation separation requires (among other things) data to be hidden (hence more function calls), prevents function inlining (or makes it more difficult), and so on.
- In-component access protection prevents, in many cases, exploitation of the global application state. This is a complex concept that I need to defer to another time.
- Function separation requires passing parameters, jumping to a different instruction, jumping back.
- Mass storage separation prevents relational algebra and query optimization.
- Different tables require a join, which can be quite costly (here the number of records resurfaces!).
- (the overhead of in-memory separation is basically subsumed by function separation).

A second source of cost is scaffolding and plumbing:
- Hardware separation requires network services, more robust error handling, protocol design and implementation, bandwidth estimation and control, more sophisticated debugging tools, and so on.
- Process separation requires most of the same.
- And so on (useful exercise!)

A third source of cost is human understanding:
Unfortunately, many people don’t have the ability to reason at different abstraction levels, yet this is exactly what we need to work effectively with a distributed, component-based, multi-database, fine-grained architecture with polymorphic behavior. The average programmer will find a monolithic architecture built around a single (albeit large) database, with a few large classes, much easier to deal with. This is only partially related to education, experience, and tools.

The ugly side of gravity is that it’s a natural, incremental, attractive, self-sustaining force.
It starts with a single line of code. The next line is attracted to the same function, and so on. It takes some work to create yet another function; yet another class; yet another component (here technology can help or hurt a lot); yet another process.
Without conscious appreciation of other forces, gravity makes sure that the minimum resistance path is followed, and that’s always to keep things together. This is why so much software is just a big ball of mud.

Enough for today. Still, there is more to say about mass, gravity and inertia, and a lot more about other (balancing) forces, so see you guys soon...

Breadcrumb trail: instance/record count cannot be ignored at design time. Remember to discuss the underlying forces.

Notes on Software Design, Chapter 1: Partitioning

Carlo.Pescio — Sun, 30 Nov 2008 11:36:00 -0800

In a previous post, I discussed Alexander’s theory of Centers from a software design perspective. My (current) theory is that a Center is (in software) a locus of highly cohesive information.

It is worth noting that in order to create highly cohesive units, we must be able to separate things. This may seem odd at first, since cohesion (as a force) is about keeping things together, not apart, but is easily explained.
Without some way to partition knowledge, we would have to keep everything together. In the end, conceptual cohesion will be low, because a multitude of concepts, abstractions, etc., would all mash up into an incoherent mess.

Let’s focus on "executable knowledge", and therefore leave some artifacts (like requirement documents) away for a while. We can easily see that we have many ways to separate executable knowledge, and that those ways apply at different granularity levels.

- Hardware separation (as in distributed computing).
- Process separation (a lightweight form of distributed computing, with co-located processes).
- In-process component separation (e.g. DLLs).
- Interface – Implementation separation (e.g. interface inheritance in OO languages).
- In-component access protection, like public/private class members, or other visibility mechanism like modules in Modula 2.
- Function separation (simply different functions).

Knowledge is not necessarily encoded in code – it can be encoded in data too. We have several ways to partition data as well, and they apply to the entire hierarchy of storage.

- Mass storage separation (that is, using different databases).
- Different tables (or equivalent concept) within the same mass storage.
- Module or class static data (inaccessible outside the module).
- Data member (inaccessible outside the instance).
- Local / stack based variables (inaccessible outside the function).

It is interesting to see how poor data separation can harm code separation. Sharing tables works against hardware separation. Shared memory works against process separation. Global data with extern visibility works against module separation. Get/Set functions work against in-component access protection.
Code and data separation are not orthogonal concepts, and therefore they can interfere with each other.

There is more to say about separation and its relationship with old concepts like coupling (straight from the '70s). More on this another time; right now, I need to set things up for Chapter 2.

In the same post above, I mentioned the idea that centers have fractal nature, that is, they appear at different abstraction and granularity levels. If there are primordial forces in software, it seems reasonable that they follow the same fractal nature: in other words, they should apply at all abstraction levels, perhaps with a different slant.

The first force we have to deal with is Gravity. Gravity works against separation, and as such, is a force we cannot ignore. Gravity, as in physics, has to do with Mass, and another manifestation of Mass is Inertia. Gravity, like in the physical world, is a pervasive force, and therefore, separation always entails a cost. Surrending to gravity, however, won't make your software fly :-). I’ll talk about all this very soon.

On a more personal note, I haven’t said much about running lately. I didn’t give up; I just have nothing big to tell :-). Anyway: there is still a little snow around here, but I was beginning to feel like a couch potato today, so I geared up and went for a 10Km (slow :-) run. At Km 4 it started raining :-)), but not so much to require an about face. At Km 8 the rain stopped, and I ran my last 2 Km slightly faster. It feels so great to be alive :-).

A Tale of Two Methods

Carlo.Pescio — Tue, 25 Nov 2008 12:34:00 -0800

Once again, I’ve been absent for quite a while. Lot of work to do, many things to ponder, and some fun too (far away from computers :-) all kept me busy. Still, I’m coming back with a few new insights, which I’d like to share over the next few weeks.

Some of you may remember when, in the late ‘90s, I proposed a transformational approach to object oriented design, which I called Systematic Object Oriented Design, or SysOOD. Most of my writings on the subject are now online, some in English, some in Italian.

The reasoning behind the method was quite simple: in many cases, it's rather easy to devise a working solution to any given problem. However, there is large gap between a working solution and an elegant solution. Elegance is an elusive concept, which is often mapped to a large set of nonfunctional attributes like separation of concerns, information hiding, reusability, scalability, and so on. Still, in practice, we can often go through a transformational process and turn our first-cut solution into a carefully crafted design.

Experienced designers apply those transformations on the fly, as part of their conversation with the material. My idea was to make those transformations explicit, to give them a name, a context and a purpose. I drew heavily from the design patterns movement: ideally, I thought, we should be able to generate patterns by transforming a trivial design. To some extent, I succeeded, as documented in some of my works.

I kept exploring. My ultimate goal is to understand “what we really do as we design”, which is quite ambitious. Hence my investigation of Schon, Alexander, the concept of form and force field, etc.

In the last month or so, I've found myself walking a familiar path, one that I already walked during the SysOOD days. Although I tend to design intuitively, borrowing on several years of experience, I started asking myself (again) the familiar question: how did this came to my mind? Is there a systematic process behind this reasoning? Can I make this reasoning explicit?

This time, however, my focus is different. I'm not looking for transformations anymore. I know I could do more on that side, but I also know the limits of a transformational approach. This time I'm against “primordial” forces, and hopefully against a way to describe and reason upon those forces.

It's a difficult endeavor, and the probability of failure is high. But it's also an excellent learning opportunity, and in a sense, an excellent teaching opportunity, as I'm sure I'll learn a few things worth teaching along the way.

I don't expect to discover anything revolutionary. It's about understanding what we do, not what we don't know how to do. But the same understanding, I believe, can help us when we don't know what to do. If anything comes out of it, it will be an explorative approach, a way to frame and understand our own ideas while we design.

What I've collected so far are a few ideas about partitioning and the fractal nature of software (as I hinted to in a previous post), and a few early attempts to visually model the force field. At some point, I'll probably use the Large Display problem to show how some of those concepts can point us toward a better solution.

More on this very soon, I hope :-)

Microblogging is not my thing...

Carlo.Pescio — Sun, 26 Oct 2008 07:03:00 -0700

A few weeks ago I got a phone call from a client. They want to insource a mission-critical piece of code. I talked about the concept of Habitable Software and thought I could write something here.

As I started to write, words unfolded in unexpected rivers. Apparently, I've got too much to say [and too little time].

So, I tried to use a mind map to get an overview of what I was trying to say.

Here it is (click to get a full-scale pdf):

Strictly speaking, it's not even a mind map, as I drew a graph, not a tree. I find the tree format very limiting, which is probably a side-effect of keeping a lot of connections in my mind.

Another side effect is that I find micro-blogging unsatisfactory. Sure, I could post something like:

interesting book, take a look

and get over, but it's just not my style.

Anyway, I'll try to keep this short and just add a link to the presentation on form Vs. function that I mentioned in the mind map: Integrating Form and Function. Don't mind the LISP stuff :-). That thing about the essential and contingent interpreter is great.

More on all this another time, as I manage to unravel the fabric of my mind :-)

Some Small Design Issues (part 2)

Carlo.Pescio — Sat, 18 Oct 2008 11:07:00 -0700

So far, so good. The only important choice we had to make was the placement of the display logic (stage 1). That choice was easy, so to speak: a little speculative thinking, along the lines of "do we want to reuse the same display logic with another process control system" would have been enough to choose. The "do the simplest thing" approach would have lead us in the wrong direction, but even in that case, refactoring the display logic outside process control would have been easy. Now, unfortunately, things are going to get messy.

Stage 4 - different data in different states
The system can be in different internal states. For instance, some physical components may undergo maintenance, so the corresponding software component would go into an offline state. The process itself may go into an idle state between different shifts, and so on.

Sometimes, the internal state is irrelevant. Sometimes, however, we may want to display different variables in different states. For instance, if the process is idle, we might want to see the time of day and a the seconds of idle time. It would make little sense to display any data about the product, as there is no product in the idle state.

Of course, the set of internal states can change between one system and another. In many cases, the state is stored internally and not published into the database. Even the internal model of "state" can be different: in some cases, the state manifests itself implicitly, through a set of internal variables; in some cases, a single variable holds the explicit system state.

Now, we basically have two main choices, with several sub-choices and consequences. We may keep the state inside the system, or we may require the system to publish its own state.

Keeping the state inside the system seems like a good choice: after all, it's what good ol' information hiding would like us to do. However, that doesn't really fit with the idea of an external display logic. How do we know which variables to show in each state, if we don't even know the state? Of course, we may come up with some kludge, like publishing "artificial" or "synthetic" variables. These variables are published only for the display module, and they change meaning as the internal state changes. That's ugly and would get worse in the next stages. Note, however, how information hiding is now going against the clean separation of concern we aimed for in stage 1.

We may therefore decide to publish the internal state. That's not completely correct either. If the state is implicitly stored inside several internal variables, we do not want to publish those variables. In general, we don't want to publish the actual state: we want to publish a business-relevant abstraction of the internal state.

At this point, however, configuration becomes harder. We have to decide which variables we want to show, in which display, in which state. The state has to be made explicit, and visible to the user (at least, as far as configuration goes). The display subsystem has to know about state too - not the internal state, but the published state. That's an undesirable form of coupling, and it's the first sign that our solution is not going to be great.

Stage 5 - different display types
Back in stage 2, we just wanted to handle different protocols. The display type, however, was "fixed": a few rows, each with a label and a floating-point value. Now we have to handle different display types too.

In some simplified systems, or in some areas of a plant, a a standard green-yellow-red semaphore can be used as a cheaper (and more intuitive :-) display, based on 2 thresholds.

In other cases, an LCD or plasma screen is adopted, and here we have a wide choice: show more data, show more text, show trends (graphically), and so on.

Again, here we face a relatively difficult coupling/cohesion choice. Consider the semaphore: where do we configure the thresholds, and were do we place the logic? We could do both inside the control system, and publish a new variable to control the lights. That's easy, but in a sense, we are moving some display concerns inside the system. The new variable is there only because we want a semaphore. We could put that logic inside the display subsystem (actually, inside the semaphore class). But a threshold is a process concept, and we also need some logic to prevent flickering, which is more akin process control logic, not display logic.

The trend is even worse. So far, each variable had one single slot inside the [real-time] database. There was no history. A trend requires history. Where do we put that? It's easier to store history inside the display logic (the trend class) because no changes are required to the control system and (more importantly) to the database. However, that's kinda clumsy. If the display subsystem is shut down for any reason, we won't be able to show a trend when it's started up again (not for a while, at least).

Also, we may have a performance issue here. When we want to show a few numeric values, we don't need to be fast (quite the opposite :-). So the process control system can publish once in a while, or the display can sample the database once in a while (if we can't push from the database). A trend, however, may require a much faster publishing/sampling than we were prepared to handle.

Again, it's hard to find a clear-cut winning solution. The two domains are entangled, and we seem to lack the right abstractions, something that would make the control and display more independent on each other.

Stage 6 - different data sources
This just adds to the mess. Now, different control systems are implemented by different teams, working on different kind of industrial processes. We have slow processes, where data could be stored in a plain, cheap relational database. We also have moderately fast processes, where we need a real-time database. We also have hard real-time systems, where data are published periodically through a proprietary, TCP-based messaging protocol (and not stored anywhere), and so on.

Now, unfortunately, we can't store the configuration inside the real-time database anymore, because there might not be a real-time database. Overall, is no big deal, but we have to reference a variable while we configure the display, and that reference can easily break if we change the process control system. What's worse,we may not have a way to know, besides running the system, which ain't nice.

So, here it is. The problem itself is relatively easy. We also have several simple solutions. However, most of them lack elegance and quality. The natural temptation is to go after higher levels of abstractions, along the "enterprise data bus" concept on one side and the OPC initiative on the other. I've seen that, and what you get is usually a slow behemoth that nobody really likes. Another natural temptation is to go after the MVC idea and to create several "controllers" to mediate between processes and displays. In practice, we just give up and declare that mixing display concerns and process concerns is not that bad, and we name that [gordian] knot "controller". Not really elegant.

Curiously enough, I have seen similar (although superficially quite different) problems in different domains, like cab dispatching. There is probably a meta-problem pattern at play, but I haven't got the time to investigate the issue (I do have a few ideas though).

Still, it's damn hard to find a simple, elegant, flexible solution where the processes and the displays are nicely separated. Part of the problem, I think, is that we lack a way to model the force field.
More on this another time: meanwhile, if you've got any brilliant idea, just let me know :-).

Some Small Design Issues (part 1)

Carlo.Pescio — Sun, 12 Oct 2008 12:35:00 -0700

In a previous post, I talked about some small, yet thorny design problems I was facing. As I started writing about them, it became clear that real-world design problems are never so small: there is always a large context that is somehow needed to fully understand the issues.

Trying to distill the problem to fit a blog post is a nightmare: it takes forever, it slows me down to the point I'm not blogging anymore, and is exactly the opposite of what I meant when I wrote Blogging as Destructuring a few years ago. On a related note, Ed Yourdon (at his venerable age :-) is moving toward microblogging for similar reasons.

Still, there is little sensible design talk around, so what does a [good] man gotta do? Simplify the problem even more, split the tale in a few episodes, and so on.
I said "tale" because I'll frame the design problem as a story. I don't mean to imply that things went exactly this way. Actually, I wasn't even there at the time. However, looking at the existing artifacts, it seems reasonable that they somehow evolved that way.
Also, an incremental story is an interesting narrative device for a design problem, as it allows to put every single decision in perspective, and to reason about the non-linear impact of some choices.

Stage 1 - the beginning
We have some kind of industrial process control system. We want to show a few process variables on a large-size numeric display, like in the picture below:

At this point the problem is quite simple, yet we have one crucial choice to make: where do we put the new logic?
We have basically three alternatives:
1) inside an existing module/process, that is, "close to the data"
2) in a new/external process, connected via IPC to the existing process[es]. Connection might be operating in a push or pull mode, depending on update rate and so on (we'll ignore this for sake of simplicity).
3) in a new/external process, obtaining data through a [real-time] database or a similar middleware. The existing processes would have to publish the process variables on the database. The new process might pull data or be pushed data, depending on the data source.
Even at this early stage, we need to make an important architectural decision. It's interesting to see that in very small systems, where all the data is stored inside one process, alternative (1) is simpler. Everything we need "is just there", so why don't we add the display logic too?
This is how simple, lean systems get to be complex, fragile, bulky systems: it's just easier to add code where the critical mass is.
So, let's say our guys went for alternative (3). We have one data source where all the relevant variables are periodically stored.

Now, we just need to know which variables we want to show, and in which row. For simplicity, the configuration could be stored inside the database itself, like this (through an OO perspective):

Using an ugly convention, "-1" as a row value indicates that the process variable isn't shown at all.

Stage 2 - into the real world
Customers may already have a display, or the preferred supplier may discontinue a model, or sell a better/cheaper/more reliable one, and so on. Different displays have different protocols, but they're just multi-line displays nonetheless.
Polymorphism is just what the doctor ordered: looking inside the Display component, we might find something like this:

It's trivial to keep most of the logic to get and format data unchanged. Only the protocol needs to become an extension point. Depending on the definition of protocol (does it extend to the physical layer too?) we may have a slightly more complex, layered design, but let's keep it simple - there are no challenges here anyway.

Stage 3 - more data, more data!
Processes gets more and more complex, and customers want to see more data. More than one display is needed. Well, it's basically trivial to modify the database to store the display number as well.
A "display number" field is then added to the Process Variable Descriptor. Note that at this point, we need a better physical display, as the one in the picture above has hard-coded labels. We may want to add one more field to the descriptor (a user-readable name), and our protocol class may or may not need some restyling to account for this [maybe optional] information. The multiplicity between "Everything Else" and "Display Protocol" is no longer 1. Actually, we have a qualified association, using the display number as a key (diagram not shown). No big deal.
Note: at this stage, a constraint has been added, I guess by software engineers, not process engineers: the same process variable can't be shown on two different displays. Of course, a different database design could easily handle this limitation, but it wasn't free, and it wasn't done.

Hmmm, OK, so far, so good. No thorny issues. See you soon for part 2 :-).

Ricerca Sviluppatori

Carlo.Pescio — Wed, 01 Oct 2008 13:04:00 -0700

Un mio cliente in Emilia sta cercando un paio di nuovi sviluppatori. Metto di seguito un po' di caratteristiche desiderabili (non serve averle tutte ma aiuta :-) ed una descrizione di quali sarebbero le prime attivita' di cui occuparsi.
Se siete interessati mandate a me il vostro CV, all'indirizzo jobs@eptacom.net, anche perche' sui primi progetti sicuramente lavoreremmo spesso insieme...

Caratteristiche ideali [ripeto, non serve averle tutte]:
- Neolaureato, ma siamo interessati anche candidati con 2/3 anni di esperienza
- Preferibile laurea in Informatica o Ingegneria Informatica
- Mente elastica, niente fissazioni pseudo-religiose su linguaggi, tool, metodi e quant'altro.
- Buona conoscenza del C++, idealmente del C++ moderno (smart pointers, stl, eccezioni, template, ecc)
- Familiarita' con i concetti dell'OOP (polimorfismo e compagni)
- Non farebbe male una certa conoscenza delle API di Windows, cosi' come di C# e .NET
- Una certa sensibilita' alle questioni di design, capacita' di leggere un diagramma UML, conoscenza di qualche pattern, ecc
- Conoscenza dei principali algoritmi e un buon "pensiero algoritmico" per la soluzione di problemi
- Una base di ingegneria del software, anche quella "limitata" tipica dei corsi universitari. Diciamo che se gli passo un articolo di IEEE Transactions on Software Engineering da leggere (tipicamente perche' inerente il lavoro) mi piacerebbe che non cascasse dalle nuvole.
- La sede del lavoro e' in Emilia, e' necessario lavorare in sede.

Di cosa si occuperanno:
inizialmente lavoreremo insieme su alcuni tool di sw engineering (che non sono il core business dell'azienda, ma ci servono per fare alcune analisi, prendere alcune decisioni, e capire se riusciamo a realizzare alcune cose in modo automatico).
Sicuramente lavoreremo anche sul refactoring di codice esistente, in ottica anche "formativa" per gli altri sviluppatori (ovvero, il risultato sara' "di metodo" oltre che "di codice"). Anche qui, idealmente penseremo un po' a come automatizzare alcune trasformazioni.
Dopodiche' seguiranno un po' di progetti "speciali" dentro il core business, ma sicuramente ci sara' spesso da leggere / capire codice esistente, quindi se guardare il codice altrui vi fa proprio paura :-), purtroppo non fa per voi, altrimenti, fatevi sentire :-).

... and Found?

Carlo.Pescio — Sun, 21 Sep 2008 03:47:00 -0700

What is a center in software? Although I gave the subject some serious thinking, my answer is quite simple; in fact, we knew it all along.

Let's recap Alexander's definition:
Centers are those particular identified sets, or systems, which appear within the larger whole as distinct and noticeable parts. They appear because they have noticeable distinctness, which makes them separate out from their surroundings and makes them cohere, and it is from the arrangements of these coherent parts that other coherent parts appear.

We might be tempted to define centers as the main decomposition mechanism in some paradigm. For instance, we could say that centers are classes. In fact, if you change "centers" with "classes" in the text above, it still makes sense. Of course, that would be the wrong answer. Is is functions, then? This is the path Jim took, until he got down to the spatial properties of code and so on. I'll try the road less traveled by.

I've often quoted Philip Armour saying that software development is a knowledge acquisition activity. In Listen to your Tools and Materials, I went one small step further and said "Our material is knowledge, or information.We acquire, understand, filter, and structure information".

Information is often assimilated with data, as in data structures, databases, and so on. That's a limiting view, as it could only be applied to finite sets, defined extensionally. Information can also be captured intensionally, by defining predicates. Information can be captured procedurally, by defining processes. This is where I first depart from Jim. I see no need to transform procedures into spatial data structures. Procedures are fine just as they are: information encoded through a process.

It is interesting to see that the act of acquiring and encoding information permeates all phases (or activities) of software development. We analyze requirements by understanding, classifying, encoding information. It doesn't really matter if the result is a use case, a class diagram, a piece of code, some natural text, a set of test cases. We structure information during design, while coding, even while indenting text. It may be turtles :-) all the way down in meatspace, but it's information all the way down in cyberspace.

This is exactly the kind of fractal nature we were looking for. However, the magic X is not simply information: it's highly cohesive information. OK, that was it :-).

The concept scales very well across a number of paradigms, artifacts, scales. A few examples:
- a good class is a set of cohesive methods and data
- a good module is a set of cohesive classes or functions
- a good function (or method) manipulates cohesive input through a cohesive process (separation of concerns) giving out a cohesive output (information hiding)
- a good aspect brings scattered concerns together into a single, cohesive point of development, maintenance, and reuse.
- empty lines in source code are used to separate highly cohesive portions of code.
- proper layout in UML class/component diagrams is used to aggregate highly cohesive portions.
- and so on.

So what is a center? A center is a locus of highly cohesive information. The form of a center is influenced by our paradigm and our material. But as I contended a couple of years ago in a post I prophetically :-) titled Unifying Concepts, paradigms are all about one single principle. Partitioning knowledge, I said then. Partitioning information in highly cohesive sets (or loci), I should say now.

What about Jim question? What kind of x is there that makes it true to say that every successful program is an x of x's? Highly cohesive information, of course! From subsystems to components, down to grouping and indentation of source code.

I began this post by saying we knew it all along. In a sense, we did: in another prophetic post (More synchronicity, do I need to say more? :-), I quoted Yourdon saying that he got the concept of cohesion while reading Alexander.
That kinda closes the circle, doesn't it?

Lost

Carlo.Pescio — Sat, 13 Sep 2008 13:47:00 -0700

I’ve been facing some small, tough design problems lately: relatively simple cases where finding a good solution is surprisingly hard. As usual, it’s trivial to come up with something that “works”; it’s also quite simple to come up with a reasonably good solution. It’s hard to come up with a great solution, where all forces are properly balanced and something beautiful takes shape.

I like to think visually, and since standard notations weren’t particularly helpful, I tried to represent the problem using a richer, non-standard notation, somehow resembling Christopher Alexander’s sketches. I wish I could say it made a huge difference, but it didn’t. Still, it was quite helpful in highlighting some forces in the problem domain, like an unbalanced multiplicity between three main concepts, and a precious-yet-fragile information hiding barrier. The same forces are not so visible in (e.g.) a standard UML class diagram.

Alexander, even in his early works, strongly emphasized the role of sketches while documenting a pattern. Sketches should convey the problem, the process to generate or build a solution, and the solution itself. Software patterns are usually represented using a class diagram and/or a sequence diagram, which can’t really convey all that information at once.

Of course, I’m not the first to spend some time pondering on the issue of [generative] diagrams. Most notably, in the late ‘90s Jim Coplien wrote four visionary articles dealing with sketches, the geometrical properties of code, alternative notations for object diagrams, and some (truly) imponderable questions. Those papers appeared on the long-dead C++ Report, but they are now available online:

Space-The final frontier (March 1998)
Worth a thousand words (May 1998)
To Iterate is Human, To Recurse, Divine (July/August 1998)
The Geometry of C++ Objects (October 1998)

Now, good ol’ Cope has always been one of my favorite authors. I’ve learnt a lot from him, and I’m still reading most of his works. Yet, ten years ago, when I read that stuff, I couldn’t help thinking that he lost it. He was on a very difficult quest, trying to define what software is really about, what beauty in software is really about, trying to adapt theories firmly grounded in physical space to something that is not even physical. Zen and the Art of Motorcycle Maintenance all around, some madness included :-).

I re-read those papers recently. That weird feeling is still here. Lights and shadows, nice concepts and half-baked ideas, lot of code-centric reasoning, overall confusion, not a single strong point. Yeah, I still think he lost it, somehow :-), and as far as I know, the quest ended there.
Still, his questions, some of his intuitions, and even some of his most outrageous :-) ideas were too good to go wasted.

The idea of center, that he got from The Nature of Order (Alexander’s latest work) is particularly interesting. Here is a quote from Alexander:
Centers are those particular identified sets, or systems, which appear within the larger whole as distinct and noticeable parts. They appear because they have noticeable distinctness, which makes them separate out from their surroundings and makes them cohere, and it is from the arrangements of these coherent parts that other coherent parts appear.

Can we translate this concept into the software domain? Or, as Jim said, What kind of x is there that makes it true to say that every successful program is an x of x's?. I’ll let you read what Jim had to say about it. And then (am I losing it too? :-) I’ll tell you what I think that x is.

Note: guys, I know some of you already think I lost it :-), and would rather read something about (e.g.) using variadic templates in C++ (which are quite cool, actually :-) to implement SCOOP-like concurrency in a snap. Bear with me. There is more to software design than programming languages and new technologies. Sometimes, we gotta stretch our mind a little.

Anyway, once I get past the x of x thing, I’d like to talk about one of those wicked design problems. A bit simplified, down to the essential. After all, as Alexander says in the preface of “Notes on the Synthesis of Form”: I think it’s absurd to separate the study of designing from the practice of design. Practice, practice, practice. Reminds me of another book I read recently, an unconventional translation of the Analects of Confucius. But I’ll save that for another time :-).