La versione 7 segna un punto di svolta rispetto alle versioni precedenti, esso infatti ha subito un processo di restyling completo, distaccandosi molto dalle versioni precedenti come se fosse a tutti gli effetti un prodotto nuovo , che tuttavia può contare sulla grande esperienza accumulata negli anni dal gruppo di sviluppo.

Di seguito vengono riportate alcuni punti di forza del nuovo Jboss che forniscono notevoli vantaggi rispetto agli altri AS.

+ Velocità

All'avvio di AS7 i servizi sono lanciati in maniera concorrente. Questo elimina inutili attese e sfrutta maggiormente i processori con architetture multi-core. I servizi non indispensabili rimangono inattivi fino a quando non vengono effettivamente utilizzati. Queste modifiche hanno permesso di ridurre i tempi di avvio di ben 10 volte rispetto alle versioni precedenti.

+ Modularità

Il tempo del caricamento delle classi in modo gerarchico, e con lui il comportamento non convenzionale che ha provocato è stato surclassato; infatti AS7 vanta di un metodo di caricamento delle classi in grado di garantire l'isolamento dell'applicazione dalle classi del server. I moduli sono formati da un insieme di classi che restano isolate dagli altri moduli a meno che non si definisce espressamente la dipendenza da un altro modulo. Saranno caricati solo i moduli necessari e in maniera concorrente.

+ Leggerezza

AS7 ha migliorato la gestione della memoria con il Garbage Collector per ridurre al minimo le pause caricando solo i file JAR di cui ha realmente bisogno e indicizzando tutti i meta-dati. Tutto questo consente di ridurre l'occupazione della memoria con la diretta conseguenza di poter girare su dispositivi con meno risorse, inoltre lascia più spazio a disposizione delle applicazioni e supporta una maggiore scalabilità. I profili personalizzabili del server consentono di escludere le funzionalità non necessarie e rendere il server quanto più snello possibile.

+ Amministrazione

La configurazione di AS7 è centralizzata, semplice e orientata all'utente. Il file di configurazione si basa su un modello molto essenziale, completo ed elegante. A differenza delle versioni precedenti è stata unificata la configurazione su un solo file XML, non dovremo più andare alla ricerca dei file di configurazione per modificare un parametro. Quest'unificazione ha permesso anche la nascita di nuovi strumenti di amministrazione come la console, sia web che a linea di comando, e le api java e http. Con questi nuovi strumenti è inoltre possibile modificare la configurazione in run time, molto utile in ambienti di produzione.

+ Portabilità

Il team di Jboss è da sempre impegnato sulla portabilità delle applicazioni, ecco perché hanno reso AS7 certificata Java EE 6 web profile. Quest'attenzione consente di far girare applicazioni in AS7, purché rispecchino le linee guida Java EE.

+ Robustezza

AS7 è stato disegnato per facilitare il debugging delle applicazioni, tutto questo è dovuto alla scelta di utilizzare Arquillian che mette a disposizione un modello per i test di integrazione eseguiti all'interno dell'ambiente runtime reale. Viene fornita agli sviluppatori la possibilità di scrivere test per tutta la casistica che l'applicazione può incontrare durante il suo uso.

+ Scalabilità

Jboss AS7 può essere avviato in due modalità differenti, standalone e dominio. La prima gestisce una sola istanza mentre la seconda consente di gestire una tipologia multi server.

Struttura

Capire la struttura delle directory dell'AS7 ci permette di trovare con facilità i file di configurazione, i file di log, i deploy delle applicazioni utente. Per familiarizzare con la struttura vedremo in dettaglio le le directory più importanti.
.
|-- bin
| |-- domain.conf
| |-- domain.sh
| |-- jboss-admin.sh
| |-- scripts
| |-- standalone.conf
| `-- standalone.sh
|-- bundles
|-- docs
| |-- licenses
| `-- schema
|-- domain
| |-- configuration
| |-- content
| |-- lib
| | `-- ext
| |-- log
| `-- servers
|-- modules
|-- standalone
| |-- configuration
| |-- data
| |-- deployments
| |-- lib
| | `-- ext
| |-- log
| `-- tmp
`-- welcome-content


bin: Script per avviare e fermare il server e script di configurazione per settare le variabili d'ambiente e le impostazioni della java virtual machine.
bundles: Posto per i bundles OSGi.
docs/schema: Definizioni in xsd dei file XML usati da jboss.
modules: I moduli usati dal server sono in questa directory. (AS 7 è basato su una architettura modulare per il caricamento delle classi).
welcome-content: Pagina di default di benvenuto.

standalone: File di configurazione, deploy, e aree scrivibili usate dal server quando avviato nella modalità standalone.
standalone/configuration: File di configurazione per il server standalone. Questo è il solo posto dove ci sono tutte le informazioni di configurazione per il server standalone.
standalone/data: Informazioni persistenti memorizzate dal server.
standalone/deployments: I deploy degli utenti verranno rilevati e caricati automaticamente da questa directory anche a runtime.
NOTA: Le API per l'amministrazione del server sono la strada consigliata per installare i contenuti dei deploy. La capacita di scansione del file system per i deploy resta una funzionalità consigliata per lo sviluppo.
standalone/lib/ext: Luogo per l'installazione di jars per le applicazioni utilizzando il meccanismo dell'Extension-list.
standalone/log: File di log per il server standalone.
standalone/tmp: Directory per i file temporanei scritti dal server.

domain: File di configurazione, deploy, e aree scrivibili usate dal server quando avviato nella modalità domain.
domain/configuration: File di configurazione per il server domain. Questo è il solo posto dove ci sono tutte le informazioni di configurazione per il server domain.
domain/content: Area interna di lavoro per l'Host Controller. Questo è il posto dove vengono memorizzati internamente i contenuti dei deploy; questo non significa che le informazioni possono essere manipolate dagli utenti e sviluppatori. Da notare che la modalità dominio non prevede i deploy automatici basati sulla scansione del file system.
domain/lib/ext: Luogo per l'installazione di jars per le applicazioni utilizzando il meccanismo dell'Extension-list.
domain/log: Directory dove il processo Host Controller scrive i log. Il Process Controller, un piccolo processo che genera gli altri processi Host Controller, ed ogni processo Application Server che a sua volta utilizza questo path.
domain/servers: Area scrivibile da ogni istanza di Application Server. Ogni istanza, ha la sua sotto directory creata al primo avvio del server. In ogni sotto directory, per ogni istanza troviamo: data, log e tmp che hanno la stessa funzione delle omonime utilizzate dal server standalone.

Creazione di un modulo

Uno dei punti di forza di AS7 è la gestione del caricamento delle classi; questa funzionalità è cambiata radicalmente rispetto alle versioni precedenti di Jboss. In AS7 è basata sui moduli che hanno sostituito la più familiare organizzazione gerarchica delle classi. Le dipendenze dei moduli sono definite esplicitamente nella configurazione. I moduli hanno permesso all'application server di ridurre i tempi di startup sfruttando l'hiperthtreading dei moderni processori e la separazione delle classi del web server con quelle delle applicazioni.
Il nuovo Jboss è retro compatibile con i metodi di deploy di archivi jar e war. È Sufficiente mettere il file nell'apposita directory e l'application server lo carica in automatico come nella vecchia versione. In questo modo, però, non si sfruttano le potenzialità introdotte con l'uso dei moduli.
Ecco dei semplici passi per la configurazione di un Datasource MySql con la creazione di un nuovo modulo per il driver.

Installare il driver

Una volta definito il datasource, abbiamo due modi per installare il driver JDBC. Come si è già specificato precedentemente la creazione di un nuovo modulo è la strada più pulita e performante da seguire anche se leggermente più lunga. Si dovrànno aggiungere 2 file: module.xml e il jar della libreria nel path $JBOSS_HOME/modules/com/mysql/main
Il file module.xml definisce il modulo in cui è semplicemente indicato il nome, la risorsa utilizzata e le sue dipendenze. Sarà fatto in questo modo:

<?xml version="1.0" encoding="UTF-8"?>
<module xmlns="urn:jboss:module:1.0" name="com.mysql">
  <resources>
    <resource-root path="mysql-connector-java-5.1.17-bin.jar"/>
  </resources>
  <dependencies>
    <module name="javax.api"/>
    <module name="javax.transaction.api"/>
  </dependencies>
</module>

Il secondo metodo per installare il driver JDBC nell'application server è quello di effettuare il deploy del jar. Questa opzione è particolarmente utile quando l'application server gira in modalità domain. In questo scenario il deploy del jar verrà automaticamente propagato a tutti i server del dominio.

Definizione datasource

Il file di configurazione $JBOSS_HOME/standalone/configuration/standalone.xml per la versione standalone è nel formato XML. Il seguente esempio mostra la configurazione del datasource:

<subsystem xmlns="urn:jboss:domain:datasources:1.0">
 <datasources>
  <datasource jndi-name="MySqlDS" pool-name="MySqlDS_Pool" enabled="true"
                       jta="true" use-java-context="true" use-ccm="true">
   <connection-url>jdbc:mysql://localhost:3306/database</connection-url>
   <driver>mysql</driver>
   <pool>
    <min-pool-size>5</min-pool-size>
    <max-pool-size>10</max-pool-size>
   </pool>
   <security>
    <user-name>jboss</user-name>
    <password>jboss</password>
   </security>
  </datasource>
 
  <drivers>
   <driver name="mysql" module="com.mysql"/>
  </drivers>
 
 </datasources>
</subsystem>

La struttura dell'XML è definita nella specifica $JBOSS_HOME/docs/schema/jboss-as-datasources_1_0.xsd. Possiamo editare manualmente il file oppure utilizzare gli strumenti per l'amministrazione che mette a disposizione AS7, come la console web, raggiungibile all'indirizzo http://localhost:9990/console
Se tutto è andato a buon fine allo start di AS7 vediamo il caricamento del modulo:
JBoss Bootstrap Environment

19:09:28,300 INFO [org.jboss.modules] JBoss Modules version 1.0.1.GA
19:09:29,711 INFO [org.jboss.msc] JBoss MSC version 1.0.0.GA
19:09:29,917 INFO [org.jboss.as] JBoss AS 7.0.1.Final "Zap" starting
19:09:33,048 INFO [org.jboss.as.domain-management] Starting 'TestRealm' Security Realm Service
19:09:33,378 INFO [org.jboss.as] creating http management service using network interface (management) port (9990)
19:09:33,381 WARN [org.jboss.as] No security realm defined for http management service, all access will be unrestricted.
19:09:33,442 INFO [org.jboss.as.logging] Removing bootstrap log handlers
19:09:33,602 INFO [org.jboss.as.connector.subsystems.datasources] (Controller Boot Thread) Deploying JDBC-compliant driver class org.h2.Driver (version 1.2)
19:09:33,751 INFO [org.jboss.as.connector.subsystems.datasources] (Controller Boot Thread) Deploying non-JDBC-compliant driver class com.mysql.jdbc.Driver (version 5.1)
19:09:33,836 INFO [org.jboss.as.clustering.infinispan.subsystem] (Controller Boot Thread) Activating Infinispan subsystem.
19:09:34,200 INFO [org.jboss.as.naming] (Controller Boot Thread) Activating Naming Subsystem
19:09:34,255 INFO [org.jboss.as.naming] (MSC service thread 1-1) Starting Naming Service
19:09:34,275 INFO [org.jboss.as.osgi] (Controller Boot Thread) Activating OSGi Subsystem
19:09:34,359 INFO [org.jboss.as.security] (Controller Boot Thread) Activating Security Subsystem
19:09:34,377 INFO [org.jboss.remoting] (MSC service thread 1-2) JBoss Remoting version 3.2.0.Beta2
19:09:34,492 INFO [org.xnio] (MSC service thread 1-2) XNIO Version 3.0.0.Beta3
19:09:34,578 INFO [org.xnio.nio] (MSC service thread 1-2) XNIO NIO Implementation Version 3.0.0.Beta3
19:09:35,291 INFO [org.apache.catalina.core.AprLifecycleListener] (MSC service thread 1-2) The Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: /opt/jdk1.6.0_18/jre/lib/amd64/server:/opt/jdk1.6.0_18/jre/lib/amd64:/opt/jdk1.6.0_18/jre/../lib/amd64:/usr/java/packages/lib/amd64:/usr/lib64:/lib64:/lib:/usr/lib
19:09:35,385 INFO [org.jboss.as.ee] (Controller Boot Thread) Activating EE subsystem
19:09:35,442 INFO [org.jboss.as.remoting] (MSC service thread 1-2) Listening on /127.0.0.1:9999
19:09:35,693 INFO [org.jboss.as.jmx.JMXConnectorService] (MSC service thread 1-1) Starting remote JMX connector
19:09:35,756 INFO [org.apache.coyote.http11.Http11Protocol] (MSC service thread 1-2) Starting Coyote HTTP/1.1 on http--127.0.0.1-8080
19:09:36,619 INFO [org.jboss.as.connector] (MSC service thread 1-1) Starting JCA Subsystem (JBoss IronJacamar 1.0.3.Final)
19:09:36,946 INFO [org.jboss.as.connector.subsystems.datasources] (MSC service thread 1-1) Bound data source [java:jboss/datasources/MySqlDS]
19:09:38,014 INFO [org.jboss.as] (MSC service thread 1-2) JBoss AS 7.0.1.Final "Zap" started in 11360ms - Started 147 of 208 services (61 services are passive or on-demand)


Nel'articolo useremo per convenzione che i comandi shell preceduti dal # (cancelletto) dovranno essere lanciati dall'utente amministratore o in alternativa utilizzando sudo. I comandi preceduti da $ (dollaro) possono essere lanciati da un normale utente che non ha i privilegi di root.

Per prima cosa abbiamo bisogno del client OpenShift che ci servirà per la creazione del cloud, la configurazione e l’aggiunta di applicazioni e servizi. E` possibile scegliere 3 profili di OpenShift, noi faremo riferimento a quella gratuita chiamata Express, ci sono poi la Flex e la Power in caso abbiamo bisogno di maggiori performance.

Di seguito i passi per l'installazione del client OpenShift su un sistema RHEL 6 o superiore, oppure Fedora 14 o una versione più recente. Questa guida non ha lo scopo di coprire tutti i casi, per gli altri sistemi operativi si rimanda alla documentazione del progetto.
Installazione del client per OpenShift:
# cd /etc/yum.repos.d/
# wget https://openshift.redhat.com/app/repo/openshift.repo
# yum -y install rhc

Al termine dell'installazione abbiamo sul nostro computer tutti i pacchetti necessari per lanciare il nostro portale Joomla. Vedremo che grazie a GIT non sarà necessario neanche scaricare il pacchetto di Joomla. Ora possiamo utilizzare i comandi appena installati di OpenShift per creare il nostro sotto dominio che chiameremo joomla. Quando questo comando verrà eseguito per la prima volta verranno create delle chiavi SSH che saranno usate per comunicare con Openshift Express. E` possibile creare un solo sottodominio per ogni utente registrato.
$ rhc-create-domain -n joomla -l guest@example.it

Password:
Generating OpenShift Express ssh key to /home/guest/.ssh/libra_id_rsa
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/guest/.ssh/libra_id_rsa.
Your public key has been saved in /home/guest/.ssh/libra_id_rsa.pub.
The key fingerprint is:
3e:88:b7:e9:a4:c8:6c:e3:9a:16:d4:32:b7:70:06:61 guest@example.com
The key's randomart image is:
+--[ RSA 2048]----+
| E.              |
|..               |
|  o              |
| = =             |
|. B .   S        |
| . . . o         |
|  . . + o        |
| =o. + o .       |
|++=...+          |
+-----------------+
Contacting https://openshift.redhat.com
Creation successful

You may now create an application.

Ora possiamo creare la nostra applicazione, prima però vediamo il contenuto del file di configurazione:
$ cat .openshift/express.conf

# SSH key file
#ssh_key_file = 'libra_id_rsa'
# Default rhlogin to use if none is specified
default_rhlogin=guest@example.it

C'è specificato l'rhlogin che userà di default se non specificato. Questo ci semplifica il lancio dei successivi comandi perché da ora in poi non sarà più necessario specificarlo.

Ora possiamo creare un'applicazione, Joomla necessita del PHP ed è la prima cosa che andremo ad installare nel nostro cloud. Con rhc-create-app --help abbiamo la lista delle applicazioni supportate.
Creiamo una directory che diventerà il repository di GIT, in poche parole la nostra directory di lavoro:
$ mkdir rhc-joomla
$ cd rhc-joomla
$ rhc-create-app -a test -t php-5.3

Password:

Found a bug? Post to the forum and we'll get right on it.
      IRC: #openshift on freenode
      Forums: https://www.redhat.com/openshift/forums

Attempting to create remote application space: test
Contacting https://openshift.redhat.com
API version: 1.1.1
Broker version: 1.1.1

RESULT:
Successfully created application: test
Checking ~/.ssh/config
Contacting https://openshift.redhat.com
      Adding rhcloud.com to ~/.ssh/config
Now your new domain name is being propagated worldwide (this might take a
minute)...
Pulling new repo down
Warning: Permanently added 'test-joomla.rhcloud.com,107.22.25.216' (RSA) to the
list of known hosts.
Confirming application test is available
Attempt # 1

Success! Your application is now published here:

http://test-joomla.rhcloud.com/

The remote repository is located here:

     ssh://791a8fe8bd1c48c1820f933c6cad3579@test-joomla.rhcloud.com/~/git/test.git/

To make changes to your application, commit to test/.
Then run 'git push' to update your OpenShift Express space

Abbiamo creato la nostra applicazione chiamata test e gli abbiamo specificato che userà il php.
Niente di più semplice, non dobbiamo installare il php direttamente sul cloud partendo dal pacchetto o dai sorgenti perché OpenShift lo fa per noi in modo del tutto trasparente. Vediamo se è altrettanto semplice aggiungere un altro servizio di cui Joomla ha bisogno, un server MySql.
$ rhc-ctl-app -a test -e add-mysql-5.1

Password:
Contacting https://openshift.redhat.com
Contacting https://openshift.redhat.com
API version: 1.1.1
Broker version: 1.1.1

RESULT:

Mysql 5.1 database added.
Please make note of these credentials:

    Root User: admin
    Root Password: Q2eXtiXqcXXX
    Database Name: test

Connection URL: mysql://127.1.33.XXX:3306/

In meno di un secondo abbiamo anche il nostro database server installato ed avviato. L'output ci fornisce le informazioni per l'accesso e ci comunica che è stato creato un database con lo stesso nome che abbiamo scelto per la nostra applicazione.
Ora il nostro ambiente è pronto per l'installazione di Joomla.
Grazie alla potenza di GIT possiamo fare tutto in modo molto pulito e veloce. GIT infatti ci permettere di aggiungere un ulteriore repository al nostro branch di lavoro. Dopo essere entrati nella directory "test" digitiamo il comando
$ git remote add upstream -m master git://github.com/openshift/joomla-example.git

Fatto. Facciamo ora il fetch e il merge con il nuovo repository:
$ git pull -s recursive -X theirs upstream master

warning: no common commits
remote: Counting objects: 3805, done.
remote: Compressing objects: 100% (2963/2963), done.
remote: Total 3805 (delta 818), reused 3805 (delta 818)
Receiving objects: 100% (3805/3805), 4.83 MiB | 340 KiB/s, done.
Resolving deltas: 100% (818/818), done.
From git://github.com/openshift/joomla-example
* branch      master        -> FETCH_HEAD

*** Please tell me who you are.

Run

    git config --global user.email "you@example.com"
    git config --global user.name "Your Name"

to set your account's default identity.
Omit --global to set the identity only in this repository.

fatal: empty ident  not allowed

Ci ha restuito un errore perché il repository di github necessita dell'autenticazione. Quindi andiamo sul sito github ed effettuiamo la registrazione. Poi diciamo a git di utilizzare lo username appena registrato.
$ git config user.name "guest"

Lanciamo il comando precedente ed ora vediamo che l'operazione va a buon fine.
$ git pull -s recursive -X theirs upstream master

From git://github.com/openshift/joomla-example
 * branch            master     -> FETCH_HEAD
Auto-merging .openshift/action_hooks/build
Auto-merging php/index.php
Merge made by recursive.
 .openshift/action_hooks/build                      |   38 +-
 .openshift/action_hooks/joomla.sql                 | 1860 +++
 README.md                                          |   51 +
 php/LICENSE.txt                                    |  340 +
 php/README.txt                                     |   70 +
 php/administrator/cache/index.html                 |    1 +
 php/administrator/components/com_admin/admin.php   |   20 +
 php/administrator/components/com_admin/admin.xml   |   30 +
 .../components/com_admin/controller.php            |   24 +
 .../components/com_admin/controllers/index.html    |    1 +
 .../components/com_admin/controllers/profile.php   |   89 +
 .../com_admin/helpers/html/directory.php           |   61 +
 .../components/com_admin/helpers/html/index.html   |    1 +
 .../com_admin/helpers/html/phpsetting.php          |   81 +
 .../components/com_admin/helpers/html/system.php   |   37 +
 .../components/com_admin/helpers/index.html        |    1 +
 php/administrator/components/com_admin/index.html  |    1 +
 .../components/com_admin/models/forms/index.html   |    1 +
 .../components/com_admin/models/forms/profile.xml  |  136 +
[...]

Facciamo il push del repository upstream, questa operazione serve per aggiornare refs remoto usando quello locale, e va fatta ogni volta che vogliamo pubblicare le modifiche di Joomla.
$ git push

Counting objects: 3811, done.
Compressing objects: 100% (2966/2966), done.
Writing objects: 100% (3805/3805), 4.83 MiB | 327 KiB/s, done.
Total 3805 (delta 819), reused 3800 (delta 818)
remote: Stopping application...
remote: Waiting for stop to finish
remote: Done
remote: Running .openshift/action_hooks/build
remote: ERROR 1146 (42S02) at line 1: Table 'test.tt7ki_assets' doesn't exist
remote:
remote: Database schema not found, importing 'joomla.sql' schema.
remote:
remote:
remote: done.
remote: ==================================================
remote: Joomla admin login: admin
remote: Joomla admin password: 4dm1n
remote: Don't forget to change your Joomla admin password!
remote: ==================================================
remote: Starting application...
remote: Done
To
ssh://791a8fe8bd1c48c1820f933c6cad3579@test-joomla.rhcloud.com/~/git/test.git/
    0f9bf26..fff3d3e   master -> master

Dall'output possiamo vedere che il database non era inizializzato e lui si è preoccupato di farlo. Questa operazione normalmente veniva effettuata durante il processo configurazione di Joomla, che però in questo contesto non abbiamo bisogno di eseguire perché chi ha creato joomla-example su github lo ha già configurato per girare sul cloud di Red Hat. Abbiamo terminato l'installazione, ora possiamo utilizzare Joomla. Aprimo la url http://test-joomla.rhcloud.com/ la url è formata in questo modo http://$app_name-$your_domain.rhcloud.com quindi se abbiamo scelto nomi diversi per l'applicazione o il dominio dovremmo modificarla opportunamente.
Se abbiamo eseguito tutti i passi correttamente dovremmo poter iniziare ad utilizzare Joomla. Ho utilizzato il condizionale perché in realtà se apriamo l'url viene visualizzato solamente il seguente messaggio di errore:

Infinite loop detected in Jerror

Questo è meno grave di quanto sembra, innanzi tutto è un errore generato da Joomla, quindi è stata lanciata l'applicazione che abbiamo appena installato. Il loop infinito si riferisce ad un errore che indirizza ad un errore, nel nostro caso avviene che ho una query che va in errore nella homepage e sull'errore faccio una redirect in homepage, ed è così che si genera un loop infinito. Quindi c'è qualcosa che non va nella configurazione del database. Apriamo il file php/configuration.php e modifichiamo i parametri per la connessione del db settandoli con i valori che abbiamo ottenuto durante la generazione del database.

public $host = '127.1.33.XXX';
public $user = 'admin';
public $password = 'Q2eXtiXqcXXX';
public $db = 'test';

Non ci resta che rendere effettive le modifiche.
$ git add php/configuration.php
$ git commit -m 'alter db configuration'

[master 28bb973] alter db configuration
 1 files changed, 4 insertions(+), 4 deletions(-)

$ git push

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 419 bytes, done.
Total 4 (delta 3), reused 0 (delta 0)
remote: Stopping application...
remote: Waiting for stop to finish
remote: Done
remote: Running .openshift/action_hooks/build
remote: Database found, skipping import.
remote: Starting application...
remote: Done
To ssh://791a8fe8bd1c48c1820f933c6cad3579@test-joomla.rhcloud.com/~/git/test.git/
   fff3d3e..28bb973  master -> master

Ora tutto è pronto per essere utilizzato, all'indirizzo http://test-joomla.rhcloud.com/ c'è la nostra homepage, l'amministrazione possiamo raggiungerla alla url http://test-joomla.rhcloud.com/administrator/ le credenziali di accesso sono utente admin e password 4dm1n che è preferibile cambiare dopo il primo accesso.

Licenza d'uso "Attribuzione - Non commerciale - Non opere derivate", secondo i criteri internazionali Creative Commons

Nelle impostazioni di rete di VirtualBox per una macchina virtuale non vengono mostrati i dispositivi Wireless Broadband. Se ad esempio siamo collegati ad internet tramite una chiavetta USB non potremmo utilizzare la connessione nella macchina virtuale. Per risolvere questo problema abbiamo bisogno di una configurazione di rete un pò più complessa.

Dobbiamo creare un bridge e configurare l'interfaccia di rete della macchina virtuale per utilizzarlo. Poi dobbiamo dargli l'accesso alla rete e questo lo facciamo grazie ad un NAT.

Di seguito c'è un piccolo script che ci aiuta a configurare il tutto.

#!/bin/bash
 
# set PATH for the case we are called via sudo or su root
 
PATH=/sbin:/usr/bin:/bin:/usr/bin
USER=<user>
INTIF="br0"
EXTIF="ppp0"
 
NUMBER_OF_VM=1
# create the bridge
/usr/sbin/brctl addbr br0
 
# create the taps and insert them into the bridge
 
NB=1
while [ $NB -lt $NUMBER_OF_VM ]; do
   tunctl -t tap$NB -u $USER
   ip link set up dev tap$NB
   /usr/sbin/brctl addif br0 tap$NB
   let NB=$NB+1
done
 
# set the IP address and routing
ip link set up dev br0
ip addr add 10.1.1.1/24 dev br0
ip route add 10.1.1.0/24 dev br0
 
####
# Connecting the internal network to the world.
####
echo 1 > /proc/sys/net/ipv4/ip_forward
 
# clear existing iptable rules, set a default policy
iptables -P INPUT ACCEPT
iptables -F INPUT
iptables -P OUTPUT ACCEPT
iptables -F OUTPUT
iptables -P FORWARD DROP
iptables -F FORWARD
iptables -t nat -F
 
# set forwarding and nat rules
iptables -A FORWARD -i $EXTIF -o $INTIF -j ACCEPT
iptables -A FORWARD -i $INTIF -o $EXTIF -j ACCEPT
iptables -t nat -A POSTROUTING -o $EXTIF -j MASQUERADE
 
 
echo "Virtual host network setup:"
echo ""
echo "   ip link set up dev eth0"
echo "   ip addr add 10.1.1.2/24 dev eth0"
echo "   ip route add default via 10.1.1.1 dev eth0"

Lo script è abbastanza chiaro, per adattarlo alle nostre esigenze potrebbe bastare il settaggio della variabile USER, e gli indirizzi IP utilizzati non devono andare in conflitto con l'ip principale del tuo PC che probabilmente sta nella rete 192.168.0.0/16.

Passi da eseguire

• Lanciare lo script da utente root dopo aver impostato USER
• Configurare l'interfaccia di rete della macchina virtuale come in figura

[lg_image folder="virtualbox" image="ScreenshotWinXPSettings.png" width="570px"]

• Avviare la macchina virtuale
• Settare manualmente l'indirizzo ip della macchina virtuale, si potrebbe saltare questo passaggio configurando opportunamente un server dhcp.

  IP: 10.1.1.2
  NETMASK: 255.255.255.0
  DEFAULT GATEWAY: 10.1.1.1

I giorni di /etc/inittab sembrano essere ormai finiti per Ubuntu. Ma niente paura se per qualche motivo non si vuole la grafica al login (GDM, KDM, ecc...) durante il boot di Ubuntu, ecco come fare. Vi mostrerò anche come disabilitare l'immagine spash durante il boot e tornare al buon vecchio schermo nero con i log del processo di avvio.

Questo procedimento si applica ad Ubuntu 10.04 (Lucid), 10.10 (Maverick) e non escludo alcune versioni precedenti. Il modo più semplice, senza modificare il file /etc/init/gdm.comf, è questo:

• Per disabilitare GDM,KDM, ecc, editare /etc/default/grub e modificare la riga GRUB_CMDLINE_LINUX = "" con GRUB_CMDLINE_LINUX = "text"
• Per visualizzare i messaggi di avvio e disattivare la splash image, togliere quiet splash da GRUB_CMDLINE_LINUX_DEFAULT. Se si vuole la splash image e del testo, utilizzare splash.
• Eseguire il comando sudo update-grub

Fine.

Panoramica

Il progetto, come abbiamo già accennato, è composto da più parti. Un sensore sonar da posizionare nella parte alta del pozzo (lontano dall'acqua) che guarda verso il basso così da misurare la distanza tra il punto più alto del pozzo e l'acqua. Facendo una semplice differenza tra l'altezza dal fondo al sensore e la misura letta otteniamo l'altezza dell'acqua. Ad intervalli di tempo prestabiliti verrà letta la quantità dell'acqua e visualizzata sul display. Se il livello supera una soglia scatterà un allarme che fa suonare il buzzer fino a quando il livello scenderà di nuovo sotto la soglia o quando si disattiva manualmente la suoneria.

Arduino controlla la logica di funzionamento, tramite un programma che vedremo di seguito, e gestisce tutti i dispositivi.

Arduino

Arduino è una piattaforma elettronica open-source basata sulla semplicità e la facilità di utilizzo. È proprio per queste sue caratteristiche che viene utilizzata da artisti, design, hobbisti e chiunque si interessi di creare oggetti o ambienti interattivi.

Supporta un vasto numero di sensori ed è programmabile attraverso un linguaggio che ha molte affinità con il C. Dal sito del progetto è possibile scaricare un enviroment con editor, compilatore e funzione di upload. Tutto ciò di cui abbiamo bisogno per programmare Arduino. È possibile anche utilizzare strumenti a linea di comando ma ora non ci occuperemo di questo.

Schema elettrico

PCB

Download pcb per ExpressPCB

File size: 0 Byte

Sketchbook

Di seguito c'è il programma caricato su Arduino. Il codice è molto semplice soprattutto se già si conosce il C o il C++. Da notare che manca la funzione main(), l'esecuzione inizia invocando la funzione setup() una sola volta all'avvio del dispositivo e poi ciclicamente la funzione loop().

/* -*- mode: c -*- */
/**
 * pozzo.pde
 * version: 1.2
 */
 
#include <liquidCrystal.h>
 
#define PING_PIN 13
#define BUZZER_PIN 8
#define SWITCH_INT 0 /* 0 => pin 2 */
#define PI 3.1415926535898
#define SUPERFICE_BASE (R_POZZO * R_POZZO * PI)
#define SIZE_BAR (16 * 5)
#define ALARM_ICON 0 /* code */
#define SOUND_ICON 6 /* code */
#define SOUND_ICON_ON 7 /* code */
 
#define R_POZZO 0.5 /* raggio pozzo (m) */
#define H_POZZO 146.0 /* cm */
#define SOGLIA_ALLARME_1 100 /* cm */
#define SOGLIA_ALLARME_2 120 /* cm */
#define DELAY_0 60000 /* ms; 1000 * 60 * 1 = 1 min */
#define DELAY_1 600 /* ms */
#define DELAY_2 200 /* ms */
 
/* initialize the library with the numbers of the interface pins */
LiquidCrystal lcd(12, 11, 5, 4, 3, 6);
 
int mute = 0;
 
byte *getChar(int n, byte newChar[]) {
  int i;
  byte code[5] = {
    B10000,
    B11000,
    B11100,
    B11110,
    B11111};
 
  for (i = 0; i < 8; i++)
    newChar[i] = code[n - 1];
 
  return newChar;
}
 
void setup() {
  int i;
  float h;
  byte newChar[8];
 
  /* set up the LCD's number of rows and columns: */
  lcd.begin(16, 2);
 
  for (i = 1; i < 6; i++)
    lcd.createChar(i, getChar(i, newChar));
 
  newChar = {
    B00000,
    B00100,
    B01010,
    B01010,
    B11111,
    B00100,
    B00000,
  };
 
  lcd.createChar(ALARM_ICON, newChar);
 
  newChar = {
    B00011,
    B00101,
    B11001,
    B11001,
    B11001,
    B00101,
    B00011,
  };
 
  lcd.createChar(SOUND_ICON, newChar);
 
  newChar = {
    B00100,
    B10010,
    B01001,
    B01001,
    B01001,
    B10010,
    B00100,
  };
 
  lcd.createChar(SOUND_ICON_ON, newChar);
 
  pinMode(BUZZER_PIN, OUTPUT);
 
  /**
   * LOW to trigger the interrupt whenever the pin is low,
   * CHANGE to trigger the interrupt whenever the pin changes value
   * RISING to trigger when the pin goes from low to high,
   * FALLING for when the pin goes from high to low.
   */
  attachInterrupt(SWITCH_INT, button, RISING);
 
  /* initialize serial communication */
  Serial.begin(9600);
}
 
void loop() {
  long hWatherCm;
  int litres;
 
  hWatherCm = read_height();
  if (check_alarm(hWatherCm) != 0) /* read again wather height */
    hWatherCm = read_height();
 
  lcd.clear();
 
  print_histogram(hWatherCm);
 
  lcd.setCursor(0, 1);
 
  lcd.print(hWatherCm);
  lcd.print(" cm - ");
 
  // litres = SUPERFICE_BASE * (hWather / 100.0) * 1000
  litres = floor(SUPERFICE_BASE * hWatherCm * 10);
  lcd.print(litres);
  lcd.print(" l ");
 
  lcd.setCursor(14, 1);
  lcd.write(SOUND_ICON);
  lcd.setCursor(15, 1);
  if (!mute)
    lcd.write(SOUND_ICON_ON);
  else
    lcd.write('X');
 
/*
  Serial.print("cm = ");
  Serial.println(hWatherCm);
*/
 
  switch (check_alarm(hWatherCm)) {
  case 1:
    lcd.setCursor(0, 0);
    lcd.write(ALARM_ICON);
 
    buzz(200);
    delay(DELAY_1);
    break;
 
  case 2:
    lcd.setCursor(0, 0);
    lcd.write(ALARM_ICON);
 
    buzz(200);
    delay(200);
    buzz(200);
    delay(DELAY_2);
    break;
 
  case 0: // no alarm
    delay(DELAY_0);
  }
}
 
void print_histogram(int hWatherCm) {
  int i;
  int bloks;
  float histogram;
 
  // hWatherCm : HPOZZO = histogram : SIZE_BAR
  histogram = (SIZE_BAR * hWatherCm) / H_POZZO;
  histogram = histogram + 0.5;
 
  bloks = (int)histogram / 5;
 
  for (i = 0; i < bloks; i++)
    lcd.write(5);
 
  if ((int)(histogram) % 5 > 0)
    lcd.write((int)(histogram) % 5);
}
 
long read_height() {
  /**
   * establish variables for duration of the ping,
   * and the distance result in centimeters:
   */
  long duration, hWatherCm;
 
  /**
   * The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
   * Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
   */
  pinMode(PING_PIN, OUTPUT);
  digitalWrite(PING_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(PING_PIN, HIGH);
  delayMicroseconds(5);
  digitalWrite(PING_PIN, LOW);
 
  /**
   * The same pin is used to read the signal from the PING))): a HIGH
   * pulse whose duration is the time (in microseconds) from the sending
   * of the ping to the reception of its echo off of an object.
   */
  pinMode(PING_PIN, INPUT);
  duration = pulseIn(PING_PIN, HIGH);
 
  /* convert the time into a distance */
  hWatherCm = H_POZZO - microseconds_to_centimeters(duration);
 
  if (hWatherCm < 0)
    return 0;
 
  if (hWatherCm > H_POZZO)
    return H_POZZO;
 
  return hWatherCm;
}
 
void buzz(int msec) {
  if (!mute)
    digitalWrite(BUZZER_PIN, HIGH);
  delay(msec);
  digitalWrite(BUZZER_PIN, LOW);
}
 
int check_alarm(int hWatherCm) {
  if (hWatherCm > SOGLIA_ALLARME_1) {
     if (hWatherCm < SOGLIA_ALLARME_2)
       return 1;
     else
       return 2;
  }
  return 0;
}
 
long microseconds_to_centimeters(long microseconds) {
  /**
   * The speed of sound is 340.29 m/s or 29.4 microseconds per centimeter.
   * The ping travels out and back, so to find the distance of the
   * object we take half of the distance travelled.
   */
  return microseconds / 29.387 / 2;
}
 
void button() {
  //  Serial.println("Pulsante premuto");
  mute = !mute;
 
  lcd.setCursor(15, 1);
  if (!mute)
    lcd.write(SOUND_ICON_ON);
  else
    lcd.write('X');
}

Immagini

Potete evitare tutti questi problemi semplicemente organizzando i sorgenti Java e usando un Makefile scritto ad hoc.

Cos'è un Makefile

Un makefile è un file che descrive i passi da efftuare per arrivare ai file che vorremmo ottenere e tutto l'albero delle sue dipendenze. È molto usato nelle piattaforme basate su Unix e può essere utilizzato per compilare ogni tipo di programma. L'utility make interpreta i makefile e compila il codice sorgente per ottenere programmi eseguibili e librerie.

Vantaggi nell'uso di make

Molti di voi saranno scettici nell'utilizzo di un makefile per ogni progetto Java per la semplice ragione che il makefile richiede di specificare tutte le dipendenze tra i files, che sicuramente cambia da progetto a progetto. Quindi dovremmo scrivere un makefile diverso per ogni nostro progetto. Questo limite può essere superato scrivendo un makefile generico e in grado di calcolarsi tutte le dipendenze per il progetto da compilare in modo da utilizzare lo stesso script per tutti i progetti senza bisogno di moficare niente all'interno del makefile.

Un vantaggio sicuramente non trascurabile è la capacità di make di compilare solo il necessario. Evita quindi di compiare ciò che è già compilato e non è stato modificato con un risparmio notevole di tempo.

Con un solo makefile si riesce a compilare tutti i sorgenti del progetto.

Come usarlo

Il makefile che ho scritto per compilare progetti Java può può essere utilizzato senza alcuna modifica per progetti che hanno una certa struttura di directory. I sorgenti Java devono avere una directory per i .java, una per i file .class, e una per le librerie jar.
Come ad esempio:

|-- src
|  `-- main
|      |-- java
|      |  `-- com
|      |      `-- example
|      |          |-- ExampleA.java
|      |          |-- ExampleB.java
|      |          `-- ExampleC.java
|      `-- resources
|          `-- Res.java
|-- classes
|-- libs
|   |-- general
|   |   |-- DataBase
|   |   |   |-- DB1.jar
|   |   |   `-- DB2.jar
|   `-- Logging
|       `-- log.jar
|-- jars

Per usarlo quindi basta scrivere il codice quì sotto nel file Makefile nella directory root del progetto, verificare che il nome delle directory sia quello specificato nel file (classes per i .class; src per i .java e libs per i jar) e lanciare il comandomake
questo è tutto. Se vogliamo anche un jar contenente tutto il progetto basta lanciaremake && make jar

Makefile

#
# Makefile
# author: Danilo Abbasciano
#
 
# set here the directories for classes and sources
CLASS_DIR = classes
SOURCE_DIR = src
JARS_DIR = jars
 
SUBDIRS := $(shell find $(SOURCE_DIR) -name "*.java" -printf %h\\n | sort | uniq | sed 's/$(SOURCE_DIR)\/\?//')
 
JAVA_HOME=/usr/local/java/bin
 
# compiler field
#JDEBUGFLAGS = -g -deprecation
#JDEBUGFLAGS = -O -depend -nowarn
JCC = $(JAVA_HOME)/javac
 
.PHONY: clean classes compile jar
 
all:
	@@for p in $(SUBDIRS); do \
		echo 'compile ' ; \
		export SUBDIR=" />$</span>p<span style="color: #004400;">;</span> \
		<span style="color: #666622; font-weight: bold;">export</span> SUBDIR<span style="color: #004400;">=</span><span style="color: #000088; font-weight: bold;">$p; \
		make --no-print-directory compile; \
	done
 
clean:
	-rm -f *~ *.class *.bak $(foreach dir,$(SUBDIRS),$(CLASS_DIR)/$(dir)/*.class)
 
 
LOCAL_CLASS_DIR=$(CLASS_DIR)/$(SUBDIR)
LOCAL_SOURCE_DIR=$(SOURCE_DIR)/$(SUBDIR)
 
jar:
	cd $(CLASS_DIR); jar -cf ../$(JARS_DIR)/project.jar *
 
compile: classes
 
# create target class dir if not present.
$(LOCAL_CLASS_DIR):
	mkdir -p $(LOCAL_CLASS_DIR)
 
 
# new rule for java
.SUFFIXES:
.SUFFIXES: .java .class
 
 
# magical command that tells make to find class files in another dir
vpath %.class $(LOCAL_CLASS_DIR)
vpath %.java $(LOCAL_SOURCE_DIR)
 
# classpath; all in ./jars and ./libs
LIBCLASSPATH:=$(CLASS_DIR):$(SOURCE_DIR):$(subst .jar ,.jar:,$(wildcard libs/*.jar libs/*/*.jar libs/*/*/*.jar jars/*.jar))
 
# compil command
.java.class:
	CLASSPATH=$(LIBCLASSPATH) $(JCC) -nowarn -d $(CLASS_DIR) $(JDEBUGFLAGS) $<
 
# find out target files
PATHFILES = $(wildcard $(LOCAL_SOURCE_DIR)/*.java)
FILES = $(subst $(LOCAL_SOURCE_DIR)/,,$(PATHFILES))
classes: $(FILES:.java=.class)

Buona compilazione.

unpkg.sh: Un piccolo ma molto utile script

Quante volte ci è capitato di estrarre archivi e ritrovarci con centinaia di files e directories sparsi ovunque. Questo accade quando gli archivi sono sono creati senza includere la cartella di lavoro. Quello che potevate fare fino a ieri è di cancellare tutti i file nuovi facendo molta attenzione a non toccare i file che erano lì precedentemente.

Oggi grazie a questo piccolo script Bash è possibile fare questo in modo del tutto automatico e senza rischi per il sistema e per i nostri files. Basta lanciare lo script passandogli come argomento il package. $ unpkg.sh <archivio1(.tar|.tgz|.tar.gtz|.tar.gz2|.zip)> [ ... <archivioN>]Come abbiamo visto lo script può accettare anche più di un archivio e supporta i formati: tar, tgz, tar.gz2 e zip.

#!/bin/bash
 
for file; do
    case "$file" in
        *.tgz)
            rm -rf `tar ftz "$file"`
            ;;
        *.tar.gz)
            rm -rf `tar ftz "$file"`
            ;;
        *.tar.gz2)
            rm -rf `tar ftj "$file"`
            ;;
        *.tar)
            rm -rf `tar ft "$file"`
            ;;
        *.zip)
           FILE_LIST=`zipinfo -1 "$file"`
            IFS=$'\n'
            for FILE in $FILE_LIST; do
		if [ -d "$FILE" ]; then
		    rm -fr "$FILE"
		else
                    rm -f "$FILE"
		fi
            done;
            ;;
        *)
            echo "File format not supported ($file)"
            ;;
    esac
done

È con questa ambizione che Musici.it vuole proporre ai propri utenti una piattaforma in grado di dare visibilità a migliaia di annunci, rivoluzionando il livello d’interazione sito-utente, grazie agli ingenti studi condotti sulla web usability applicati alla progettazione del layout grafico.

La principale novità introdotta da Musici.it, sarà a breve, di permettere di aggiungere ai normali annunci anche immagini, brani audio o filmati. Miglioramenti finalizzati per permettere, in maniera totalmente gratuita ai propri utenti, di personalizzare il proprio annuncio.

Non è esclusa la possibilità dell’ampliamento dell’offerta con l’aggiunta di nuove sezioni, sempre inerenti il mondo della musica, come ad esempio annunci di scuole di musica, sale prove e di registrazione, fino alla compra/vendita di dischi e strumenti musicali. Musici.it è anche aperto alle proposte inoltrate dai propri utenti.

Visita il sito www.musici.it

umano e non un computer. Questi metodi vengono utilizzati per impedire che i bot utilizzino dei servizi come scrivere commenti o riempire form. L'uso dei captcha risulta essere indispensabile per evitare il proliferare dello spam.

Come si giudica un buon captcha

Molti di voi penseranno che un buon captcha sia quello più difficile da risolvere. Così da rendere la vita difficile agli algoritmi. Per quelli di tipo visuale esistono infatti algoritmi in grado di convertire un immagine in un testo chiamati Optical Character Recognition.

Io credo che le caratteristiche che rendano un captcha buono siano altre, come l'accessibilità, la facile comprensione da parte di un umano, la possibilità di essere generati in modo automatico e allo stesso tempo abbastanza complesso da risultare impossibile da risolvere da parte di algoritmi anche basati su intelligenza artificiale.

La sfida che mi sono posto è quella di poter realizzare un unico captcha che ha queste caratteristiche. Perché dico unico, perché sempre più spesso i siti utilizzano più di un metodo di autenticazione in parallelo come un captcha visuale affiancato da uno sonoro. Dopo che si sono accorti che uno di essi o entrambi non risultano efficaci.

L'accessibilità

Per anni i captcha visivi sono stati responsabili di una grave discriminazione ai danni di chiunque avesse problemi di vista. La loro esistenza ha reso inaccessibili milioni di siti che li hanno adottati come difesa dagli spammer, frapponendo una barriera, che ormai tutti consideravano insuperabile, tra l’utente e il servizio in rete.

Nulla sono valse le petizioni on line contro questo tipo di captcha, che continuano indisturbatamente a proliferare nel web. Inoltre le nuove generazioni di captcha, create per resistere ai più sofisticati programmi di riconoscimento di testi, possono essere molto difficili o impossibili per molti utenti, anche nel pieno possesso della propria capacità visiva.

Proprio per questo motivo il captcha perfetto non dovrà essere né visuale né di tipo uditivo.

Generazione automatica

La soluzione è quella di adottare metodi testuali. Ma non sempre è possibile. Domande come: Di che colore era il cavallo bianco di Napoleone? oppure Qual'è il risultato di due per sette? Risultano essere ottime per quanto riguarda l'accessibilità, la comprensione da parte dell'uomo e la difficoltà di essere risolti da parte di programmi.

Il loro unico problema è l'impossibilità di poter generare automaticamente queste domande rendendo questo metodo praticamente inutilizzabile.

Facile da risolvere per gli utenti

Non sempre i metodi utilizzati risultano essere di facile risoluzione per gli utenti, potete vedere in figura un form per la registrazione alquanto difficile.

hard captcha

Un buon captcha

Leggendo queste righe vi sarete resi conto di quanto sia difficile conciliare l'efficacia e la facilità di utilizzo di un buon metodo per proteggere le proprie risorse. Per questo motivo ho deciso di svilupparne io stesso uno, che, non sarà certo il captcha perfetto ma diciamo che le sue caratteristiche sono molto buone.

Si tratta di un captcha testuale, semplice da generare automaticamente, e facile da risolvere per gli utenti. Il lavoro più duro non è stata l'implementazione ma come spesso accade è stata la ricerca dell'idea giusta.

L'idea è quella di prendere una parola abbastanza lunga e scambiare la posizione di due lettere diverse. L'utente dovrà correggere la parola scritta in modo errato.

captcha

L'uso di questo metodo è stato impiegato nel sito musici nella sezione utilizzata per richiedere informazioni.

L'unica carenza di questo metodo è che con un semplice algoritmo è possibile risolverlo. Ma sono anche convinto che non è necessario utilizzare una cassaforte per proteggere pochi spiccioli. Quindi in attesa di trovare un idea migliore e riuscire finalmente a porre fine alla ricerca del captcha perfetto continuerò ad utilizzare e consiglirvi questo metodo.

Ogni numero naturale pari maggiore di 2 puo' esere scritto come la somma di due
numeri primi.

Ad esempio:
4 = 2 + 2
6 = 3 + 3
8 = 3 + 5
10 = 3 + 7 = 5 + 5
12 = 5 + 7
14 = 3 + 11 = 7 + 7
16 = 3 + 13 = 5 + 11

Proviamo a dimostrare la sua inesattezza

Su una congettura possiamo effettuare due tipo di dimostrazioni, possiamo dimostrare la sua correttezza o la sua inesattezza. Ovviamente l'una esclude l'altra. Tenteremo di dimostrare che la congettura è falsa, per fare ciò basta trovare un controesempio tele che l'enunciato risulti falso. Quindi nel nostro caso basta trovare un solo numero pari che non è la somma di due primi. Per trovare questo numero scriveremo un programma.

Alcune considerazioni

Tutti i numeri primi sono dispari ad eccezione di 2. Questo è vero per la definizione di numero dispari. Il numero primo 2 sommato ad un qualsiasi altro numero primo da come risultato un numero dispari. L'unico caso per cui 2 sommato ad un altro numero primo abbia come risultato un numero pari è 2 + 2. Da questo si deduce che il 4 è l'unico numero pari che si può scrivere come somma del numero primo 2 con un altro numero primo. Nel programma si considerano i numeri primi senza il 2 e tutti i numeri pari maggiori di quattro.

Scomponiamo il problema in sotto problemi

Le azioni che compie il programma possono schematizarsi in una succesioni di fasi distinte:

1. Trovare tutti i numeri primi da 3 ad n
2. Prendere tutte le coppie di numeri primi (p1, p2) tali che la loro somma non superi n (cioè p1 + p2 <= n) e se viene considerato (p1, p2) allora verrà scartato (p2, p1).
3. Marcare i pari da 6 ad n se essi sono il risultato di p1 + p2 per ogni coppia (p1, p2) trovata precedentemente.
4. Stampare tutti i numeri pari non marcati come somma di numeri primi.

Crivello di Eratostene

Per torvare tutti i numeri primi da 3 ad n esiste un metodo antichissimo noto come Crivello di Eratostene. Esso consiste nello scrivere tutti i numeri da 2 a n e cancellare successivamente tutti i multipli di 2(escluso), tutti i multipli di 3(escluso), tutti i multipli di 5(escluso) e così via. I numeri "sopravvissuti" saranno tutti e soli i numeri primi compresi tra 2 ed n.

Quindi utilizziamo un vettore di flag v, l'idea e' semplice, dobbiamo marcare tutti i numeri multipli di 2, 3, 5, ecc.. così i rimanenti sono primi. Per economizzare la memoria ho fatto partire il vettore da 3 ed esaminato solo i numeri dispari, esempio:

indice vettore(i): 0 1 2 3 4 5 6
informazione (j): 3 5 7 9 11 13 15
v[i] : T T T F T T F

per passare da i a j utilizzo la funzione j = 2*i + 3
viceversa i = (j - 3)/2
Nota: j - 3 da sempre un numero divisibile per due dato che i j sono tutti dispari.

void riempi_v(long int n) {
  int i, k;
  for (i = 0; i < Size(n); i++) {
    if (v[i] == TRUE)
      for (k = 3; (2*i + 3)*k < n + 2; k = k + 2)
        v[(2*i*k + 3*k - 3)/2] = FALSE;
  }
}

Algoritmo di backtracking

Una volta ottenuto il vettore v sò quali sono i numeri primi fino ad n.
Ora dovrò trovare tutte le coppie (p1, p2). Per fare questo utilizzo un algoritmo che sfrutta il metodo del backtracking. L'algoritmo "pota" l'albero delle ricorsioni in modo da non considerare affatto le coppie di numeri che non interessano. Così da essere il più ottimizzato possibile, ci accorgeremo che l'ottimizzazione di questo programma è fondamentale se vogliamo raggiungere buoni risultati.

/* trova e somma tutte le coppie di numeri primi trovati precedentemente */
void backtraking(long int n, int i, int p1, int p2) {
  int x;
  if (i == 2) {
    pari[(p1+p2)/2] = FALSE;
    /* printf("(%d,%d)\n",p1, p2); */
  }
  else {
    if (i == 0)
      for (x = 3; x != -1; x = primo_successivo(n, x)) {
        backtraking(n, i + 1, x, p2);
      }
    else
      /**
       * Inizializzare x con p1 per verificare la congettura di Goldback.
       * Porre x = primo_successivo(n, p1) per trovare tutti i pari
       * dati da p1 + p2 con p1 != p2
       */
      for (x = p1; x != -1; x = primo_successivo(n, x)) {
        if (p1 + x <= n)
          backtraking(n, i + 1, p1, x);
        else break;
      }
  }
}

Trovata la coppia (p1, p2) fa la somma e aggiorna il vettore pari. Il vettore pari ha dimensione n/2, ogni elemento corrisponde ad un numero pari.

Abbiamo sviluppato i punti 1, 2 e 3 del nostro problema, non ci resta che scorre il vettore dei pari e stampare solo l'indice in presenza di un numero pari che non è la somma di due primi.

  for(i = 0; i < n/2; i++)
    if (pari[i] == TRUE)
      printf("%d:i = %d\n", pari[i], 2*i);

Risultati

Vi accorgerete effettaundo dei tests che all'aumentare di n aumenta anche il tempo di esecuzione. Con un computer ad un processore Intel da 5336.88 bogomips ho impiegato 5 giorni con n uguale a 100'000'000.

La congettura di Goldbach si suppone sia vera dal fatto che la probabilità per un numero pari di essere somma di due primi cresce al crescere del numero. Esiste un progetto di calcolo distribuito che ha finora verificato la congettura fino a 2 * 10¹⁷ (nel momento in cui scrivo.)

Un'altra congettura

Non voglio paragonarmi ad Euler o Goldbach ma forse troverete interessante anche quest'altra congettura che mi è passta per la mente durante la stesura del programma in questione. È un affinamento dell'enunciato di Goldbach.

Tutti i numeri naturali maggiori di 6 e pari possono essere scritti come somma di due primi p1 e p2 tali che p1 è diverso da p2

A voi la dimostrazione. Posso dirvi con certezza che fino a 10⁸ risulta vera.