Com\’è dura la professione!

24 settembre 2010

Generate Flex Code from Balsamiq Mockup Sources

Filed under: Flex,Open Source,QT — lbell @ 22:07

Having the need to generate an application skeleton after having created the mockup using Balsamiq (http://www.balsamiq.com), and to poke into its file format, as explained in the page http://balsamiq.com/products/mockups/help/bmml, I wrote a plugin for my Open Source project QXmlEdit.

It is very easy to use, but you should remember that it is a very simple tool and not a full fledged IDE.

The plugin can be activated via ‘Tools’ menu, as in the following screenshot:



The plugin window is divided in two: the upper part is dedicated to the Balsamiq sources to translate, the bottom one contains the destination directory where a MXML Application file is generated for each selected source file.

The translation is done by transforming the source using templates that can refer original attributes or calculated fields.

Data bound controls are supported by generating data sources as mx:Array containing mx:Object in a global section.

Not all Balsamiq controls are supported, only a subset of most commonly used ones, controls not supported are converted to mx:Label

List of supported controls:

  • Button

  • Label

  • LinkBar

  • DataGrid

  • List

  • TabBar

  • VRule

  • HRule

  • TextInput

  • ComboBox

  • TextArea

  • Paragraph

  • CheckBox

  • RadioButton

  • Tree

Annunci

16 novembre 2009

Sfruttare il system tray per controllare i job di KDE

Filed under: kde4,Open Source,Programmazione — lbell @ 22:07

Una delle funzionalità offerte da KDE4 a sviluppatori ed utenti è quella di gestire i lavori a lungo termine delle applicazioni mediante un componente del vassoio di sistema. L’infrastruttura mette a disposizione dell’utente un unica locazione dalla quale può controllare l’andamento delle operazioni, opzionalmente sospenderle, sbloccarle o controllarne l’esito anche dopo il loro termine. Si evita così che ogni applicazione che intende avvalersi di questa funzionalità debba implementare una interfaccia di controllo. Dal punto di vista del programmatore, la fatica di imparare una nuova serie di API è ripagato dal fatto che è l’ambiente a prendersi in carico il compito di interagire con l’utilizzatore, sia per quello che riguarda l’aspetto funzionale, sia per l’interfaccia utente. Ovviamente i soli lavori di cui dovrà essere notificato lo stato di avanzamento mediante questa caratteristica sono solo quelli a lungo termine, per evitare di confondere l’utente con una miriade di messaggi irrilevanti.

Vediamo ora come si può sfruttare questa funzionalità:

Le applicazioni che intendono sfruttare il sistema di notifica devono incapsulare direttamente o indirettamente l’attività in una struttura KIO::Job, ad esempio derivando da essa la nostra classe di esempio KJobTest.

	#include <kjob.h>
	class KJobTest : public KIO::Job

Se si desidera che l’utente, una volta comparsa la notifica, possa mettere i lavori in pausa, riprenderli o annullarli occorre, nella nostra classe, chiamare la funzione

    setCapabilities()

cui va passato come argomento un insieme di flag che ne determinano il comportamento. Con il valori Kjob::Suspendable si concede all’utente la possibilità di sospendere un lavoro, con KJob::Killable anche di terminarlo. Per abilitare entrambe le funzionalità, scriveremo:

    setCapabilities(KJob::Killable|KJob::Suspendable);

Quando si è pronti per presentare il job all’utente, lo si deve registrare presso una struttura globale:

	KIO::getJobTracker()->registerJob(m_jobTest);

Da questo punto in poi il job è visibile all’utente. Emettendo il segnale ‘infoMessage‘ si può forzare il pannello a mostrare la descrizione desiderata per indicare il proprio job.

Il job può essere attivato in modalità sincrona o asincrona. Nel primo caso tutto quello che dovrà fare l’applicazione per gestire il job sarà richiamarne il metodo ‘exec‘, definito nella classe base, che restituirà l’esito mediante un valore booleano. Dietro le quinte verrà attivato un loop di messaggi nascosto. Riporto l’esempio di utilizzo definito nella documentazione KDE:

void SomeClass::methodWithSynchronousJobCall()
 {
   KJob *job = someoperation( some parameters );
   if ( !job->exec() )
   {
       // An error occurred
   }
   else
   {
       // Do something
   }
 }

Nel caso si intenda utilizzare il job in modo asincrono, metodo preferito per la gestione di operazioni a lungo termine, occorre attivare il job attraverso il metodo start(), richiamato in modo nascosto anche nel caso sincrono, e mettersi in attesa dei risultati collegando il segnale ‘result‘ ad uno slot. Ecco l’esempio relativo, sempre tratto dalla documentazione KDE:

 void SomeClass::methodWithAsynchronousJobCall()
 {
   KJob * job = someoperation( some parameters );
   connect( job, SIGNAL(result(KJob*)), this, SLOT(handleResult(KJob*)) );
   job->start();
 }
 void SomeClass::handleResult( KJob *job )
 {
   if ( job->error() )
       doSomething();
 }

Nel metodo start(), da reimplementare nella nostra classe derivata da KJob, occorre utilizzare un meccanismo asincrono, come ad esempio un timer di tipo oneShot, per innescare il job, per evitare che un’attivazione direttamente nella funzione start() provochi un malfunzionamento della gestione sincrona del job attraverso la funzione exec(), per motivi derivanti dall’implementazione della funzione exec stessa. Se abbiamo deciso di non utilizzare mai l’interfaccia sincrona potrebbe sembrare una precauzione inutile, ma scrivendo codice che si deve integrare in un ambiente, occorre sempre rispettarne i dettami.

Quando l’utente decide di intervenire nella vita del job cambiandone lo stato, il pannello del vassoio di sistema richiamerà metodi doSuspend(), doResume() e doKill() del nostro job, mediante i quali si potranno realizzare le dovute azioni.

Durante il suo ciclo di vita, il job può inviare al pannello segnali riguardo il proprio stato o la percentuale di avanzamento.

Emettendo il seguente segnale:

emit infoMessage(job, messageText, messageRichText );

si può provocare la comparsa della scritta relativa allo stato puntuale del job. Allo stesso modo è possibile inviare informazioni relative alla velocità attuale ed alla unità di misura utilizzata, nel caso sia compresa tra quelle dell’enumeratore ‘Unit’ di KJob.

Come esempio di utilizzo possiamo utilizzare un semplice programma, jobsample, mediante il quale è possibile provare le tecniche esposte, configurare i parametri principali a disposizione di un job ed osservare i risultati.

I sorgenti di jobsample sono disponibili a questo indirizzo:

http://www.tsc4.com/lbell/presentazioni/src/jobsample.tgz

Finestra principale di jobsample:

job sample in esecuzione:

19 ottobre 2009

Ma cosa fa funzionare veramente il computer?

Filed under: cosi' va il mondo,Programmazione — lbell @ 21:17

L’Apple II, il primo personal computer ad avere una diffusione ed un successo mondiali, quando nel 1977 vide la luce sembrò un miracolo di tecnologia; permetteva ad un prezzo accessibile di svolgere una quantità e varietà di compiti concreti come monitorare impianti industriali o di organizzare magazzini o di controllare le scadenze delle assicurazioni. Diciamo che gli utenti si accontentavano delle prestazioni e delle possibilità offerte, cercando di vincere le limitazioni del sistema (velocità e spazio di memoria in primis) con molta pazienza e con molto ingegno, inserendo nei programmi una serie di trucchi che oggi appaiono senza senso. Il sistema aveva 48K RAM e poteva supportarne in modo lineare al massimo 64KB.

Quando uscì il primo personal IBM la ram a disposizione era di 128 o 256KB con il codice di sistema caricato in parte di essa da disco; 640KB divennero uno standard poco dopo. All’avvento del Macintosh, il primo rivoluzionario PC con un’interfaccia grafica basata su finestre ed icone, precursore di tutti i sistemi che si usano oggi, che poteva pavoneggiarsi di una grafica di tipo interamente bitmap, si arrivò a 64K di ROM e 128K di RAM, ed in questo spazio non si trovava solo il codice per gestire la grafica, ma anche quello per permettere a tutti i programmi di terze parti di potersi adeguare ad una stessa metafora di comportamento mentre faceva timidamente la sua apparizione su sistemi di tale fascia il primo codice capace di gestire una rete.

E tutta questa meraviglia in soli 64K di ROM, più il software di sistema in un dischetto da 400K. La ram a disposizione dei programmi applicativi, al netto di quella necessaria al funzionamento del Macintosh stesso era di soli 90K (http://www.folklore.org/StoryView.py?story=Monkey_Lives.txt).

E oggi? Se consideriamo le dimensioni del kernel di Linux rispetto ai tempi dell’Apple II troviamo non solo una crescita esponenziale del software di sistema ma la nascita di una nuovo filone, quasi sconosciuto al mondo visto in precedenza; il sottosistema di rete con relativa infrastruttura di sicurezza, che tramite protocolli di tutti i tipi si avvia a rappresentare una gran parte del codice di sistema. La directory del kernel Linux occupa, con varie versioni installate, da 120 a 475MB sul mio sistema e l’installazione complessiva del sistema e dei programmi applicativi più comuni quasi 10GB.

Questa crescita è avvenuta in in pochi decenni e ricalca la legge di Moore a proposito della crescita delle capacità dell’hardware (http://en.wikipedia.org/wiki/Moore%27s_law). Il fatto è che mentre l’hardware spesso è stato progettato in scala, il software di sistema in questione è stato scritto da zero, praticamente riga dopo riga. Ogni sistema operativo sul mercato ha proposto il proprio server web, il proprio stack di protocolli di rete, con tonnellate di sorgenti spesso inutilmente riscritti solo per esigenze commerciali. I computer non sono più solo strumenti nelle mani di artigiani, ma diventa sempre più difficile sapere cosa li fa effettivamente funzionare e quanto sono sicure le basi cui cui poggia il software applicativo.

grafico ram rom

8 aprile 2009

Activities are for humans

Filed under: kde4,Programmazione — lbell @ 21:48

Computers are very versatile tools, used in a variety of situations, to work, listen music, write documents, but it is very difficult to create a comfortable user environment for each task. When working to an important document, mail notifications are very annoying, but turning off completely notifications is not the ideal solution, mails related to the activity are welcomed. What is missing is the possibility that the computer adapts his environment to different activities.

Virtual desktops are the more advanced solution to implement activities today, but this is only a start.

There is a difference between a virtual desktop and an activity: virtual desktop is a collection of resources (windows mainly), an activity is a collection of related resources. You can work for a project, read documents, contact people, receive mails and so on and all these items can stay associated to the activity you are currently operating.

We can roughly consider an activity on top of a collections of virtual desktops.

A ‘recent document’ menu can contain a lot of unrelated documents, a personal letter written in a pause together with work documents and worst, it has a finite length, so new documents of unrelated activities are pushing into oblivion very important bookmarks.

Activities are useful to categorize and filter environment items, but it is not practical to manually label each resource that can reside in an activity, so the workspace should automatically collect informations, like the mylyn plugin in Eclipse world

http://www.ibm.com/developerworks/java/library/j-mylyn2/

When in an activity you can associate not only documents related to that activity, but also contacts, sites, and so on.

We work on different projects and we use the computer for personal activity each day. Computers are universal devices and can be used for different purposes.

As a further example, it is an annoyance to receive mail notifications from people not related to projects ( with obvious exception for emergencies ) in working hours. An activity can filter what that can distract, without hiding information, but focusing out of view not relevant factors.

It is important to have a simple ‘relations’ manager to handle what resources are related to an activity and move or copy them from a workspace to another (maybe using the KDE plasmoid zoom interface).

It is important to have multiple activity configurations, you can use same laptop at work and at home, even applications menu can change in different situations.

Activities attributes and resources should be shared between teams.

There are two types of applications: specialized ones (video, audio, graphics editor for instance ) and generics ones ( word processors, time tracker, etc) that should have different behavior. How horizontal applications like file browsers should behave? Why not filter activity related directories in ‘Open File’ dialogs? Currently this dialog supports only a simple filter that maps to file type (a word processor filter documents, a spreadsheet csv and so on)

How to save data in application specific format and not using specialized Desktop Environment routines? How to integrate, for example, Open Office? We should use the metadata we are using for browsers: the tags, but there is the problem to maintain metadata in sync with data when moving files, doing backups and so on. All the files that user opens or write should be logged, but the metainformations should be stored in the document or in the filesystem?

Even phones have different modes: mute, normal, meeting etc.

Tags and activities are separate concepts, tags are traversal and additive, activities are thematic.

Desktop Environment should leads the user how to enter and how to exit from an activity. We should decrease normal desktops visual clutter that confuses the user about his state.

Another problem is how to include external resources if the filter are restrictives, maybe by adding a button in each “Open File” dialog that let us choose to stay in the current activity environment or see all the resources.

Other open problems are how to integrate in this vision externals resources like network infrastructure, network, printers, etc.

Talking about concrete cases, like the recent documents menu, why not make it central for a desktop or expand it to order it for ( I often need this ) creation date, write date, access timestamp or access frequency, category?

Why not display this menu in a cloud representation? More, the vertical list used is a very short and useless representation. A timeline can be more useful.

Different activities can be created for different purposes even using same programs.

In a desktop system I can save programs state on disk passing from an activity to another one, but not on phone system for device limits.

Anyway each journey begins with a single step, and Plasma is a good one.

http://techbase.kde.org/Projects/Plasma

19 marzo 2009

Un viaggio in WebKit transitando per Plasmaland

Filed under: kde4,Open Source,Programmazione,QT — lbell @ 22:55

Scrivendo una piccola utility per Plasma mi sono fatto tentare dall’uso della nuova versione di WebKit per gestire l’interfaccia utente.

In effetti integrare WebKit in un programma QT o KDE non è troppo difficile, grazie all’uso degli slot e delle metainformazioni che QT aggiunge alle classi. E’ possibile richiamare direttamente i metodi di oggetti residenti nel nostro programma, sfruttando il meccanismo dei segnali e degli slot, dalla pagina HTML via Javascript. Per prima cosa occorre inserire nelle pagine HTML riferimenti agli oggetti C++ della nostra applicazione come se fossero variabili Javascript native, utilizzando un identificatore che verrà mappato sugli oggetti fisici a tempo debito. Fatto ciò possiamo codificare funzioni Javascript che sfruttino i metodi dichiarati come slot, in corrispondenza di determinati eventi, come la pressione di un pulsante. Possiamo quindi dalla pagina HTML eseguire metodi dei nostri oggetti passando quali parametri entità definite al livello HTML, come ad esempio i valori di un form.

Ogni collegamento tra WebKit e la nostra applicazione avverrà sempre tramite funzioni Javascript, quindi sarà WebKit ad iniziare le operazioni.

Facciamo un esempio:

Supponiamo che il nostro obiettivo sia di richiamare da Javascript il metodo ‘reload’ di un’istanza di una classe C++ descritta in questo modo:

class DBusApplet : public
Plasma::PopupApplet
{
    Q_OBJECT
    ...
public
slots:
    void reload(const QString &selection);
private:
    ...
};

in Javascript la nostra istanza può essere mappata come segue, assumendo che sia stata associata all’identificatore ‘appletInterface’:

function execute(selection)
{
    appletInterface.reload(selection);
}

Dato che la conversione dei tipi di base è automatica, quello che occorre fare è ‘iniettare’ gli oggetti C++ all’interno del componente WebKit, ma è necessario attendere che sia il componente ad avvertirci del momento più opportuno.

Al termine del caricamento di una pagina HTML, che la si assegni direttamente da programma o attraverso un URL, il frame corrente emette infatti il segnale “javaScriptWindowObjectCleared”, che occorre avere cura di catturare nel solito modo che QT ci mette a disposizione:

connect(page()->mainFrame(),

SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(populateJavaScriptWindowObject()));

Alla ricezione del segnale possiamo, attraverso il metodo collegato (nell’esempio precedente ‘populateJavaScriptWindowObject’), passare finalmente il riferimento dei nostri oggetti a WebKit attraverso il metodo addToJavaScriptWindowObject, i cui argomenti sono il nome della variabile Javascript associata e l’indirizzo dell’oggetto stesso.

page->mainFrame()->addToJavaScriptWindowObject(“appletInterface”, this);

Se tentassimo di associare i nostri oggetti prima che la pagina sia stata effettivamente caricata, il collegamento non avrebbe successo.

http://doc.trolltech.com/4.4/qtwebkit.html

http://webkit.org/

http://code.google.com/p/dbusapplet/

9 febbraio 2009

In perfetta forma

Filed under: Programmazione,Vaneggiamenti — lbell @ 22:51
Tags:

Quando frequentavo le superiori, durante le lezioni di italiano mi era difficile accettare, nonostante gli sforzi degli insegnanti, che la forma di uno scritto potesse avere altrettanta importanza del suo contenuto.

(more…)

19 gennaio 2009

Movimentare sorgenti con subversion

Filed under: Programmazione — lbell @ 21:39

Subversion è uno strumento utilissimo nel gestire i sorgenti di progetti anche complessi, con molti punti a favore (e qualche difettuccio).

Può succedere di avere la necessità di dividere un archivio che sta diventando troppo corposo, di dover promuovere un sottoprogetto ad avere una propria dignità, oppure semplicemente di dover cambiare il server.

E’ molto semplice farlo, prima di tutto esportando i dati contenuti nel repository originale mediante il comando svnadmin dump, tuttavia occorre avere serve l’accesso fisico al filesystem del server che ospita il repository.

svnadmin dump path_del_repository >file_risultato.dump

nelle opzioni del comando vi è la possibilità di esportare anche solamente un range di revisioni.

Per importare i dati nel nuovo repository, occorre posizionarsi nel filesystem del nuovo server e utilizzare svnadmin load

svnadmin load path_del_repository <file_risultato.dump

Se il repository non esiste già, occorre crearlo.

Nel caso occorra importare solo rami del sorgente esportato, prima del comando di load si può utilizzare svndumpfilter che agisce, come fa sospettare il nome, da filtro.

Pertanto se si desidera includere solamente la directory src ed il file NEWS del nostro ipotetico repository scriveremo:

svndumpfilter include /NEWS /src < esportazione.dump > dati_filtrati.dump

Attraverso l’opzione –parent-dir possiamo caricare i sorgenti in una data sottodirectory nel nuovo repository.

svnadmin load newrepository --parent-dir nome_directory <dati_filtrati.dump

I comandi hanno molte opzioni, ma la documentazione presente nel nel sito dedicato al libro on line http://svnbook.red-bean.com/ non solo è dettagliata ed esaustiva, ma discute anche del modo migliore di progettare ed usare un repository di Subversion.

1 settembre 2008

Joel ha quasi sempre ragione

Filed under: cosi' va il mondo,Programmazione — lbell @ 21:35
Tags: , ,

La causa principale della scomparsa di Netscape secondo Joel Spolsky (http://www.joelonsoftware.com/articles/fog0000000069.html) sarebbe imputabile alla decisione di riscrivere da zero il codice su cui si basava l’ex browser, decisione che lo ha praticamente fatto uscire dal mercato in favore del suo concorrente Internet Explorer e questo fatto costituisce una lezione di vita per i project manager.

In effetti l’articolo di Spolsky è pieno di buon senso e si può senz’altro condividere.

Tuttavia nel campo del software, come più ingenerale nella vita, le conseguenze di una azione assumono a distanza di tempo un significato diverso da quello che hanno avuto nel breve.

Quali reali alternative aveva Netscape davanti a se per rimanere leader del mercato, posizione che era riuscito a raggiungere? Praticamente nessuna, si trovava a competere di colpo con un prodotto gratis (ed è difficile competere con qualcosa che è gratis) e già installato su tutti i computer. L’utente non doveva nemmeno fare la fatica di scegliere quale browser installare, se tutto quello che stava cercando era un semplice accesso ad internet.

Netscape avrebbe dovuto inseguire ogni modifica proprietaria che MS avesse introdotto nel proprio programma appositamente per distinguerlo dalla concorrenza. Si tratta di una battaglia persa comunque in partenza, come ben sanno i produttori di qualsiasi programma da ufficio che si sia scontrato con prodotti MS da Word ad Excel.

Per avere qualche possibilità in una lotta con un colosso, occorre scrivere un prodotto che sia molto migliore della concorrenza, rinnovando totalmente la base di codice se necessario e le procedure per svilupparlo. Si tratta di un investimento a lunga scadenza che richiede uno sforzo gigantesco per chi non ha risorse praticamente infinite, ma è una scommessa fatta per vincere, non per crogiolarsi placidamente in un tramonto inevitabile e tranquillo, come invece scelse di fare la Venezia del 700. Il risultato? Firefox.

Ad onor del vero Firefox sembra effettivamente nato per caso dal caos di Netscape, ma non è questa la forza dei progetti Open Source?

Link:

http://www.joelonsoftware.com/articles/fog0000000069.html

http://en.wikipedia.org/wiki/Netscape

10 luglio 2008

Database everywhere

Filed under: Programmazione — lbell @ 20:27

Con la disponibilità delle CPU multicore, le applicazioni saranno forzate a sfruttare il parallelismo, dividendo l’elaborazione fra più processi o thread, avendo il problema di gestire la concorrenza anche con la scelta delle strutture dati opportune. Scrivere programmi che gestiscano effettivamente il multi-threading non è facile.

Con l’architettura attuale di CPU l’operazione di lettura è molto più efficiente della scrittura dato che le modifiche alla memoria vengono propagate fisicamente a tutti i nodi, mentre la lettura può avvenire direttamente dalla cache locale. Per questo i task che devono accedere a parti di una struttura dati devono cercare di limitarne il blocco in modo esclusivo solo ad alcune zone per massimizzare il parallelismo e diminuire i punti di contenzioso. Alcune strutture che richiedono solo blocchi locali in accesso, come le liste linkate, si adattano meglio a questo paradigma, come spiegato da Herb Sutter in un articolo su Dr Dobbs di giugno. Per apportare una modifica ad un oggetto contenuto in una lista occorre bloccare l’accesso solo agli elementi contigui a quello selezionato. Altre strutture molto usate, come gli alberi bilanciati red black, durante una operazione di modifica possono dare origine ad una operazione di ribilanciamento, che nel caso peggiore potrebbe bloccare tutto l’albero, fino alla radice con ovvi problemi di performance.

Questi meccanismi di condivisione con la gestione della concorrenza attraverso il blocco di oggetti (o il loro versionamento) si utilizzano da tempo nella gestione di database dove si è curato l’accesso concorrente ai dati da parte di più applicazioni, con bassi costo di lettura, ed alti di modifica, con una serie di meccanismi specifici, transazioni, lock escalation, replicazioni di dati e viste materializzate, per esempio. Questi meccanismi hanno comportato anche il cambiamento del modo con cui sono scritti i programmi, attraverso l’uso cosciente e consapevole delle transazioni e dei livelli di isolamento dei processi. Probabilmente per sfruttare al meglio i multicore i programmi dovranno utilizzare strutture dati e librerie mutuate dall’esperienza ricavata dalla gestione delle basi di dati.

http://drdobbs.com/hpc-high-performance-computing/208801371

http://it.wikipedia.org/wiki/Albero_Red_Black

http://en.wikipedia.org/wiki/Multiple_granularity_locking

4 giugno 2008

‘Essere’ uguale a…

Filed under: letture,Programmazione — lbell @ 19:42

Nel suo ultimo libro, una raccolta di spunti e pensieri, quasi un blog, Odifreddi lascia una nota sulla teoria secondo cui la struttura di un linguaggio condiziona la struttura del pensiero che in tale linguaggio viene espresso. A causa di ciò nel mondo anglosassone si è più portati a pensare in termini di sostantivi ed oggetti, che in termini di azioni e verbi. Nel campo della filosofia, questo motivo sarebbe uno delle cause delle differenze di pensiero tra la scuola continentale e quella analitica di derivazione anglosassone. Questo contrasto è esemplificato dal concetto di ‘essere’; nella filosofia continentale il verbo essere può essere impiegato con ambiguità tanto nel senso di esistere, quanto manifestare appartenenza (identità), o esprimere una proprietà.

Nei linguaggi di programmazione possiamo ritrovare le stesse differenza di impostazioni, abbastanza ironicamente visto che i linguaggi di programmazione sono quasi tutti di derivazione anglosassone.

Dal Basic, linguaggio in cui l’operatore ‘=’ viene utilizzato con le stesse ambiguità del termine ‘essere’ si passa al Pascal ed al linguaggio C ed ai suoi derivati , in cui ci si preoccupa di distinguere l’assegnamento, cioè il divenire, dal confronto, usando due operatori diversi, = e == (doppio uguale). Resta comunque possibile anche in questi due linguaggi scrivere espressioni in cui si assegna un valore ad una variabile in modo ricorsivo, facendo riferimento ad un suo valore precedente.

A=A+B

Ovviamente questa espressione non va intesa come un’equazione, ma a quest’ultima ambiguità pongono rimedio i linguaggi funzionali come Erlang, che non permettono l’assegnamento di un valore ad una variabile più di una volta, rendendo di fatto impossibile concepire simili storture sintattiche. Anche il C, con l’introduzione di appositi operatori di modifica ed assegnamento ci dà la possibilità di proseguire su questa strada, utilizzando espressioni come la seguente

A+= B

dove l’operatore += è inteso semplicemente come incremento, ma basta complicare un attimo l’espressione per ricadere nel caso precedente, dopotutto il C non ha mai deluso nessuno in quanto a flessibilità.

A+= 2/(A+1);

I concetti di sostantivo, aggettivo ed azione presenti nel linguaggio umano si ritrovano comunque nei vari paradigmi della programmazione, orientata agli oggetti, funzionale o imperativa . Nessuno di questi paradigmi è tuttavia in grado di coprire completamente le necessità della programmazione ed è per questo che nei linguaggi di programmazione orientati agli oggetti si è costretti a ricorrere all’uso dei generics, o dell’Aspect Oriented Programming.

http://it.wikipedia.org/wiki/Essere

http://it.wikipedia.org/wiki/Filosofia_analitica

http://it.wikipedia.org/wiki/Erlang_(linguaggio)

http://www.erlang.org/

http://www.vialattea.net/odifreddi/impenitente.php

http://www2.polito.it/didattica/polymath/htmlS/info/BIBLIOID/Borzacchini%20Odifreddi.htm

http://it.wikipedia.org/wiki/Chiusura_%28informatica%29

http://en.wikipedia.org/wiki/Aspect-oriented_programming

Pagina successiva »

Blog su WordPress.com.