Supponiamo di aver realizzato un function module in SAP semplicissimo: due parametri in ingresso (un numero e una stringa) e due parametri in uscita (lo stesso numero al quadrato e la stessa stringa).
Di seguito il codice ABAP di tale funzione:

FUNCTION Z_TEST000.
*"----------------------------------------------------------------------
*"*"Interfaccia locale:
*" IMPORTING
*" VALUE(NUM) LIKE BAPISDHD1-DUN_COUNT DEFAULT 4
*" VALUE(TEXTTEST) LIKE MARA-MATNR
*" EXPORTING
*" VALUE(RETURNNUM) LIKE BAPISDHD1-DUN_COUNT
*" VALUE(RETURNCHAR) LIKE MARA-MATNR
*"----------------------------------------------------------------------
returnnum = num * num.
returnchar = texttest.
ENDFUNCTION.

Supponiamo anche di averla pubblicata come web service, in modo da avere l’indirizzo del WSDL per poter aggiungere il riferimento al servizio nella nostra soluzione di Visual Studio. Le indicazioni che trovate qui, per aggiungere il servizio in modo da poterlo utilizzare nel codice restano valide, in estrema sintesi: tasto destro sul nome della soluzione (il nodo root del nostro sito web) poi aggiungi.. -> riferimento al servizio..

Nella maschera che appare basta mettere l’url del documento WSDL e dare un nome al servizio, che nel nostro caso è ztestoneee.

Questo il codice del front-end, una pagina in cui c’è solamente un pulsante che lancia un metodo per chiamare il web service e una label in cui visualizzeremo i risultati di questa chiamata.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="Button1" runat="server" Text="Vai bello!" OnClick="button_click" />
<asp:Label ID="Label1" runat="server" Text="incrocia le dita"></asp:Label>
</div>
</form>
</body>
</html>

A questo punto non resta che vedere il codice C# per consumare effettivamente il web service. Ci servono di fatto 3 oggetti:

• input: contiene i parametri da inviare al web service
• client: è l’oggetto che esegue la chiamata
• response: è l’oggetto che raccoglie la risposta dal web service

Leggendo il codice sotto e i relativi commenti si può capire al volo il concetto.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Globalization;
using ztestoneee;
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
//al caricamento della pagina non succede nulla
}
protected void button_click(object sender, EventArgs e)
{
//inizializzo oggetti: input, client e response
ztestoneee.Z_TEST000 input = new ztestoneee.Z_TEST000();
ztestoneee.ztestoneClient client = new ztestoneee.ztestoneClient();
ztestoneee.Z_TEST000Response response = new ztestoneee.Z_TEST000Response();
//inserisco valori da passare alla chiamata
input.NUM = 3;
input.NUMSpecified = true;
input.TEXTTEST = "Nice!";
//chiamata a web service
response = client.Z_TEST000(input);
//elaboro e pubblico la risposta
decimal returnnum = response.RETURNNUM;
string returnchar = response.RETURNCHAR;
Label1.Text = "Hey dude: " + returnnum + returnchar;
}
}

Il gioco è fatto.

La demo? Eccola! Provare è sempre più rapido che leggere.. ;) Attenzione che la cosa funziona bene la prima volta, poi la pagina viene messa nella cache e l’immagine di caricamento sparirà in fretta. Per chi vuole scaricare l’esempio completo e guardarlo in santa pace, basta fare il download.

DEMO DOWNLOAD

Per fare ciò, la prima cosa necessaria è l’immagine di caricamento, una gif animata è l’ideale. Si possono generare con le proprie preferenze  tramite tools on line come ad esempio Preloaders o Animizer, col primo si ha a disposizione una nutrita serie di immagini eleganti e predefinite, col secondo si possono creare gif animate a partire da proprie immagini.

Ora veniamo all’HTML, al CSS e al caro jquery. Il riferimento principale è la documentazione del $(document).ready().

Per fare le cose fatte bene, ho utilizzato l’HTML5 Boilerplate, un blasonato framework di frontend che agevola la scrittura del codice ma soprattutto ci da una solida guida per scriverlo bene. Nel template responsivo generato su Initializr ho inserito flexslider, il famoso slider di woothemes. Ho scelto di impostare l’ambiente di demo in questo modo per avere a disposizione uno slider con alcune immagini ad alta risoluzione che impieghino un po’ di tempo per caricarsi, ma ovviamente la parte di javascript e html che riguarda il caricamento può essere utilizzata su qualsiasi sito web.

Vediamo nel dettaglio la tecnica utilizzata, partendo dall’HTML. Basta inserire questo div subito dopo il tag <body>:

<div class="loader">LOADING...</div>

Visualizziamo la scritta loading, a tutto il resto penserà il foglio di stile.

Questo il CSS:

.loader {
display: none;
position: fixed;
left: 0px;
top: 0px;
width: 100%;
height: 100%;
z-index: 9999;
background: #fafafa url(../img/page-loader.gif) no-repeat center center;
text-align: center;
color: #999;
}

Mettiamo a tutta pagina il div, per coprire tutto il contenuto, con una immagine di caricamento come sfondo. Questo blocco verrà rimosso tramite javascript una volta che il caricamento è avvenuto.

Ecco appunto la parte javascript (utilizzando jquery):

$( document ).ready(function() {
//una volta caricato il DOM esegui questo codice
//console.log( "DOM ready!" );
$(window).load(function() {
//una volta caricata l'intera pagina (immagini e i frames..) esegui questo codice
//console.log( "Page ready!" );
//faccio scomparire l'immagine di caricamento
$(".loader").fadeOut("slow");
});
});

Il costrutto $( document ).ready(function() { .. } ci serve per far eseguire “qualcosa” una volta caricato tutto l’albero (DOM), in questo caso scriviamo semplicemente due righe sulla console del browser; mentre il costrutto  $(window).load(function() { .. } ci serve per fare eseguire “qualcosa” una volta caricata l’intera pagina, comprese appunto le immagini o roba contenuta negli iframe. E’ qui, che oltre a scrivere un log sulla console, andiamo a rimuovere il div di caricamento che copriva tutto il contenuto della pagina.

E’ tutto ciò che serve!

NB: ovviamente, se si vuole iniziare a far vedere la pagina e i suoi contenuti durante il caricamento, la stessa tecnica può essere applicata a un div che non copra tutta la pagina, ma ad esempio solo il box dello slider dove si caricheranno le immagini..

Il prerequisito di base è che la function abbia alcune proprietà basilari: “Modulo accessibile in remoto”, vedi figura dalla transazione SE37.

Per pubblicarla come servizio web, basta andare da menu, sempre nella SE37: Utilities -> Altre Utilities -> Generare servizio web -> Dal function module (vedi figura)

Bisognerà poi seguire il wizard come da figure sotto, dando un nome al web service.

Per pubblicare senza richiesta di autenticazione, selezionare come da figura sottostante:

Scegliere il pacchetto e la richiesta di trasporto.

Cliccare su “completare”, si aprirà la maschera di creazione del servizio e resterà solamente da attivare il servizio (con l’icona di attivazione).

Ora bisognerà terminare il lavoro dalla transazione SOAMANAGER (introdotta con l’ECC 6).
Si aprirà una finestra del browser, da qui bisogna andare su “Web service configuration”

Da qui è possibile ricercare il web service appena creato, selezionarlo, premere “apply selection” e andare sulla tab “configuration”

Qui bisogna creare un nuovo servizio.

Bisogna inserire un nome per il servizio e per il binding, poi premere “Apply Settings”

Sotto si aprire una maschera con le impostazioni del servizio, bisognerà configurarle. Se ad esempio si vuole impostare un utenza fissa, in modo tale che le applicazioni esterne chiamino il servizio senza autenticarsi ogni volta, si può configurare come in figura sotto. Alla fine premere “Save”.

A questo punto è tutto pronto.

Bisognerà premere su “Open WSDL document for selected binding or service” per ottenere l’url della definizione del web service, da utilizzare ad esempio su SOAP UI per poter consumare il web service e testarlo.

E se un giorno volessimo ripubblicare il servizio dopo aver cambiato la function?

Magari viene aggiunto un parametro di input/output, il web service non recepirà queste modifiche finchè non lo torniamo a pubblicare. Per fare ciò, da SAP, dobbiamo accedere alla transazione SE80. Selezionare il pacchetto in cui è stata salvata la function e poi selezionare il proprio servizio web sotto “Enterprise Service -> Service Provider”. Andare in modifica e da menù come da immagine sottostante.

Salvare e attivare.

Ora il web service avrà ereditato le modifiche.

Il primo passo per poter far funzionare il meccanismo è la definizione di una Secure Store Target Application, ovvero di un elemento che memorizza le credenziali di accesso al sistema esterno, al quale Sharepoint farà riferimento per evitare che vengano chieste all’utente che in quel momento visualizza i dati. E’ tuttavia possibile evitare questo passo, se si desidera che per l’accesso al database esterno vengano utilizzate le credenziali dell’utente connesso anzichè credenziali comuni.
La Secure Store Target Application si crea dalla Central Administration. Navigando nella sezione Application Management, e cliccando su Manage Service Applications sotto a Service Applications. Apparirà una schermata con la lista delle service applications, clicchiamo su Secure Store Service. A questo punto clicchiamo su Generate New Key nel ribbon, si apre una finestra che chiede di impostare una pass phrase, servirà per poter modificare la target application, va quindi appuntata da qualche parte (ma questo appunto è superfluo, no?).

A questo punto si può creare una nuova target application e compilare tutti i campi necessari, come da figura sotto. Come email mettiamo quella di un amministratore di sistema, mentre come Target Application Type in genere si mette Group, perchè in questo modo è possibile associare la target application a un gruppo di utenti.

Nel passaggio successivo è possibile quali campi associare alla target application, in genere sono sufficienti username e password: saranno poi valorizzati con le credenziali che dovranno impersonificare l’utente che si collega al database.

Ora bisogna specificare per quali utenti sarà disponibile questa target application, e quali sono gli utenti amministratori.

Ora che la target application è creata, non resta che settare le credenziali che utilizzerà per gli accessi al database esterno. Selezioniamo la target application dalla lista e premiamo il tasto set credential nel ribbon.

Si aprirà una finestra dove inserire username e password, questo utente deve ovviamente avere accesso ai dati sul database esterno al quale vorremo collegare le liste di Sharepoint.

Ora l’attività si sposta su Sharepoint Designer 2010, per impostare i contenuti esterni e creare le liste che puntano ad essi. La prima cosa da fare è definire un External Content Type: ovvero un contenuto esterno dal quale attingere. Dopo aver aperto un sito, bisogna andare sul menù External Content Type e tramite il comando ribbon crearne uno nuovo.

Diamo un nome al contenuto esterno e clicchiamo sul link per impostare la connessione verso il sistema esterno.

Ora bisogna cliccare sul tasto Add Connection per aggiungere una connessione.

Apparirà una serie di schermate dove compilare i dati per l’accesso al database esterno.

Selezionare come opzione di connessione Connect with Impersonated Custom Identity e mettere il nome della secure store application definita prima sulla Central Administration.

Premendo OK il sistema chiederà le credenziali, inserire quelle dell’utente definito come amministratore della secure store application ai passi precedenti. Una volta validata la connessione, nell’Operation Designer apparirà tra le connessioni disponibili anche quella appena impostata: si espande l’albero per trovare la tabella o la vista contenente i dati che dovranno popolare la lista esterna di Sharepoint.

Una volta individuata, cliccando col tasto destro sulla tabella o sulla lista, è possibile generare le operazioni che servono (lettura, modifica, cancellazione, ecc..). E’ possibile crearle tutte assieme, cliccando su Create All Operation. Nelle finestre successive dovremo dare un nome alle operazioni, si potranno settare filtri e sarà necessario marcare almeno un campo come identifier (ID di lista).

I filtri sono necessari per limitare il numero di record restituiti: di default è 2000 e a volte questo valore potrebbe non essere sufficiente, causando errore nella visualizzazione della lista tramite il browser sul sito Sharepoint.

Per l’operazione Read List, conviene settare qualche campo per la visualizzazione nel picker, altrimenti di default saranno visualizzati tutti e lato utente questa cosa risulta scomoda.

andando su List and Libraries, nei ribbon appare il comando Elenco Esterno.

Per chi volesse approfondire:

http://blog.concurrency.com/sharepoint/accessing-external-data-using-business-connectivity-services-in-sharepoint-2010/

Lato SAP, dopo aver scritto il nostro function module in ABAP (che in questo esempio estrae una tabella di dati tramite alcuni parametri in input e averlo reso disponibile pubblicandolo come web service), per evitare che sia necessario passare le credenziali di accesso durante la chiamata al web service, possiamo pubblicarlo con un utente di default. Per fare ciò: dalla transazione SICF, individuare il web service nel ramo sap/bc/srt/rfc/sap/, entrare in modifica e settare l’utente nella sezione “Dati di logon anonimi”.

Avevo già appuntato qualche nota su come consumare un web service da una pagina ASPX, tutto quello che sta scritto in quell’articolo è ovviamente valido, ma questa volta aggiungeremo il servizio al nostro progetto in un modo leggermente diverso. Da Visual Studio 2010, cliccando col tasto destro sul nome del progetto e selezionando la voce di menù “Aggiungi riferimento al servizio..”

Nella popup che appare inseriremo l’url del servizio web di SAP e sceglieremo un nome: in questo caso d’esempio lo chiameremo “Ws_Factory”.

A questo punto siamo pronti per sfruttare il web service su una pagina aspx. La pagina avrà un DataGrid che servirà per pubblicare la tabella restituita dal web service, in questo datagrid vengono esplicitate solo le colonne da visualizzare, i nomi sono esattamente gli stessi nomi dei campi della tabella su SAP (se avessimo voluto far visualizzare tutta la tabella, bastava non riportare alcuna colonna). Ecco il codice aspx:


<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Esempio Webservice</title>
<link href="StyleSheet.css" rel="stylesheet" type="text/css" />
</head>
<body>
<form id="form1" runat="server">
<div id="container">
<div id="main-container">
<asp:GridView ID="GridVisual" AutoGenerateColumns="false" runat="server" CellPadding="0" CellSpacing="0">
<Columns>
<asp:BoundField HeaderText="CdL" DataField="ARBPL"></asp:BoundField>
<asp:BoundField HeaderText="Materiale" DataField="MATNR"></asp:BoundField>
<asp:BoundField HeaderText="Squadra" DataField="TEAMTXT" ItemStyle-CssClass="team"></asp:BoundField>
<asp:BoundField HeaderText="T Setup" DataField="SETUP_TIME"></asp:BoundField>
<asp:BoundField HeaderText="T Lavorato" DataField="WORKED_TIME"></asp:BoundField>
<asp:BoundField HeaderText="T Sospensione" DataField="TIMEOUT"></asp:BoundField>
<asp:BoundField HeaderText="Pz Teorici" DataField="QTY_THEORETICAL"></asp:BoundField>
<asp:BoundField HeaderText="Pz Reali" DataField="LMNGA"></asp:BoundField>
<asp:BoundField HeaderText="Pz Scarto" DataField="XMNGA"></asp:BoundField>
<asp:BoundField HeaderText="Efficienza Prod" DataField="EFFICIENCY"></asp:BoundField>
<asp:BoundField HeaderText="Pz da Produrre" DataField="QTY_TO_PROD"></asp:BoundField>
<asp:BoundField HeaderText="T al Setup Succ" DataField="NEXT_SETUP"></asp:BoundField>
<asp:BoundField HeaderText="Stato" DataField="VM_STATUS"></asp:BoundField>
</Columns>
</asp:GridView>
</div>
</div>
</form>
</body>
</html>

Il codice C# necessario è riportato sotto, con relativi commenti che spiegano tutti i passaggi:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Ws_factory; //riferimento al Web Service di SAP
public partial class _Default : System.Web.UI.Page
{
// Inizializzazione oggetti
Ws_factory.YSVISUAL_MNGT MyVisual = new Ws_factory.YSVISUAL_MNGT();
Ws_factory.ys_ws_factory_vmClient MyClient = new Ws_factory.ys_ws_factory_vmClient();
Ws_factory.YS_FACTORY_VMRequest MyRequest = new Ws_factory.YS_FACTORY_VMRequest();
Ws_factory.YS_FACTORY_VMResponse MyResponse = new Ws_factory.YS_FACTORY_VMResponse();
protected void Page_Load(object sender, EventArgs e)
{
/* YSVISUAL_MNGT[] è la tabella dove vengono restituiti i dati dal web service di SAP
* Inizializzo come vuota */
YSVISUAL_MNGT[] MyVisual = new YSVISUAL_MNGT[] { };
/* Compilo i parametri della richiesta mettendo i filtri che mi interessano */
//MyRequest.CT_YSVISUAL_MNGT = MyVisual;
MyRequest.IV_ARBPL = "";
MyRequest.IV_DTOEE = "";
MyRequest.IV_NEW_RUN = "";
MyRequest.IV_WERKS = "P100";
/* Lancio il metodo via web passando i parametri appena impostati sopra,
* il riferimento della tab da popolare coi risultati è la tabella MyVisual */
MyClient.YS_FACTORY_VM(ref MyVisual, MyRequest.IV_ARBPL, MyRequest.IV_DTOEE, MyRequest.IV_NEW_RUN, MyRequest.IV_WERKS);
MyResponse.CT_YSVISUAL_MNGT = MyVisual;
/* Ora elaboro i dati restituiti per farli visualizzare sulla pagina */
GridVisual.DataSource = MyResponse.CT_YSVISUAL_MNGT;
GridVisual.DataBind();
}
}

Questo è semplicemente il punto di partenza, da qui è ovviamente possibile spingersi oltre e perdere tempo a volontà.. ;)

SAP è un mondo, ma ogni tanto questo mondo deve poter essere “visto” e “manipolato” dall’esterno. Senza infinte elucubrazioni sulla SOA (Service Oriented Architecture), venendo subito al sodo: l’obiettivo di questo articolo è fissare i passaggi per pubblicare come web service un function module di SAP scritto in ABAP.

Dopo aver creato il function module (transazione SE37), dovremo avviare il wizard per la pubblicazione (il wizard funziona correttamente con il logon in inglese):

• Su ECC5.0:  Menu Utilities > Altre utility > Generare servizio web > Dal function module
• Su ECC6.0:  Tasto destro > Creare Web Service

In seguito attivare i servizi sulla transazione SICF:

• /default_host/sap/bc/soap
• /default_host/sap/bc/srt
• Ogni web service è rappresentato come servizio ICF nel ramo /default_host/sap/bc/srt/rfc/sap/

Bisognerà poi recuperare l’url del web service pubblicato. Le transazioni disponibili dipendono dalla versione del Service Pack:

• WSADMIN
• WSCONFIG
• SOAMANAGER

I passaggi sono i seguenti:

• Cercare e selezionare il web service nel nodo SOAP Application for RFC-Compliant FMs
• Menu Web Service > WSDL
• Nella popup selezionare Document Style
• Si apre il browser con il link e  la definizione del WSDL
  • Non serve la configurazione del J2EE. Nel caso sia attivata, configurarla da Menu: Passaggio a > Parametrizzazione Amministrazione (esempio http://dominio.it:50000)
  • Se non è attivata la parte J2EE, il WSDL lavora sulla porta dell’ITS (esempio http://dominio.it:8000/sap/bc/srt/rfc/sap/Z_WS_TEST_CUSTOMER_DETAIL?sap-client=600&wsdl=1.1 )
• Il link per le BAPI standard è: http://dominio.it:8000/sap/bc/soap/wsdl11?services=BAPI_CUSTOMER_GETDETAIL2&sap-client=600

Per testare il web service si può utilizzare un programma come SOAP UI. Dopo averlo installato, i passaggi da fare sono i seguenti:

• Creare nuovo progetto
• Nel progetto aggiungere un WSDL
• Indicare il link recuperato dalla transazione WSADMIN
• Inserire username e password dell’account SAP nel riquadro in basso a sinistra

Nella zona di sinistra vanno inseriti i parametri di input, rimuovendo i punti interrogativi. Poi premere il tasto con la freccia verde e nella parte di destra comparirà il risultato restituito dal web service.

Non vado oltre anche se il tema meriterebbe molti approfondimenti, riporto queste poche informazioni come promemoria per chiunque si debba cimentare; nel caso qualcuno voglia maggiori informazioni lascio qualche link utile:

• http://help.sap.com/saphelp_nwpi71/helpdata/en/bb/ddb33d2ae46b3be10000000a114084/frameset.htm
• http://help.sap.com/saphelp_nwpi71/helpdata/en/9b/dad1ae3908ee44a5caf57e10918be9/frameset.htm
• http://www.dataxstream.com/2009/09/turn-any-sap-remote-enabled-function-module-into-a-web-service-%E2%80%93-part-1/
• http://www.dataxstream.com/2009/10/turn-any-sap-remote-enabled-function-module-into-a-web-service-%E2%80%93-part-2/

Sono arrivati in vendita i notebook con Chromium OS preinstallato, anche in Italia. Per la cronaca: trattasi del sistema operativo di Google, concepito per vivere completamente on-line. La notizia non è pù fresca fresca, e ti viene voglia di provare questo sistema operativo di cui tutti parlano.

Come fare? E’ un attimo. Abbiamo due possibilità, metterlo su un supporto esterno USB oppure utilizzare VMware Player e avere a disposizione una macchina virtuale sul proprio computer. Ho scelto la seconda strada e metto per iscritto due appunti per chi volesse cimentarsi.

1. Se già non è installato, scaricare e installare VMware Player, il tool di virtualizzazione gratuito di VMware. Per un’utenza domestica è più che sufficiente.
2. Scaricare la Vanilla Nightly Build di Chromium OS. Vanilla che? Si tratta di una versione del sistema operativo di Google che ogni notte viene compilata fresca fresca dalla fabbrica e messa a disposizione per il download, così tutti coloro che non possono permettersi il notebook  riescono comunque a godersela. Ovviamente bisognerà scaricare la versione per VMware.
3. Una volta scaricato lo zip, scompattarlo, ad esempio nella cartella C:\ChromeOS\
4. Rinominare il file ChromeOS-Vanilla-xxxxxxxxxxxxxxxxxxxxx-VMWare.vmdk in ChromeOS-Vanilla-VMWare.vmdk
5. Aprire VMware player e cliccare su Open a Virtual Machine
6. Selezionare la macchina virtuale dalla cartella C:\ChromeOS\ ed il gioco è fatto.

Al primo avvio il sistema chiede di fare il logon con le proprie credenziali Google, ovviamente è necessario un account. La prima impressione è che si tratti di un sistema ancora un po’ acerbo, ma prima di sbilanciarmi serve un minimo di esplorazione in più.

Come ti sembra questo grafico? Prova a cliccare sugli elementi della legenda e vedrai che è interattivo, potresti utilizzarlo per simulare il rispetto degli obiettivi in assenza di fatturato ottenuto su alcune zone.. Prova a selezionare col mouse una zona del grafico e vedrai puoi fare lo zoom sui dati che ti interessano.. Queste e tante altre funzionalità si possono ottenere grazie ad Highcharts, un validissimo javascript open source che lavora con jQuery per renderizzare grafici più o meno complessi e molto accattivanti.

Il tutto senza flash, cosa a cui difficilmente si poteva rinunciare in era pre-jQuery se si volevano ottenere i medesimi risultati. Le tipologie di grafici sono molteplici: si va dalla immancabile torta alla più ricercata rappresentazione demografica, dal grafico a barre al potente grafico zoomabile sull’andamento delle quotazioni in borsa. E’ inoltre possibile caricare i dati direttamente da una tabella definita in HTML all’interno della pagina, con poche righe di codice javascript.

Sotto è riportato il codice, opportunamente commentato, dell’esempio mostrato in questo articolo.
//Carico il javascript di highcharts, dopo aver caricato jQuery
<script src="js/highcharts.js" type="text/javascript"></script>
<script type="text/javascript">// <![CDATA[

Data la sua natura di puro css e javascript, questo grafico è agilmente fruibile anche da dispositivi mobili come iPhone o Android, inoltre è ben renderizzato dai principali browser. Si tratta di un prodotto davvero interessante che potrebbe tornare utile in diverse applicazioni stand-alone, a costo zero. Ben diverso dal classico Google Charts, servizio comodissimo che però pecca in quanto ad interattività: all’utente viene infatti restituita in quel caso una immagine statica.

Cosa Manca? Mancano i “geo-grafici“, ovvero la possibilità di visualizzare i dati su una cartina; mancano i tachimetri, per visualizzare in un colpo d’occhio l’andamento più o meno positivo di un indicatore. Sono comunque cose a cui si può sopperire spulciando bene l’elenco dei plugin jQuery..
E voi? Che cosa utilizzate in questi casi?

• Web Service su Wikipedia
• Guida Web Service

L’obiettivo di questo articolo è fissare un esempio pratico per interrogare un web service e sfruttare i risultati che restituisce utilizzando C# e Visual Studio.

Supponiamo di dover accedere al webservice di esempio su W3C, descritto a questa pagina: http://www.w3schools.com/webservices/tempconvert.asmx
La descrizione del servizio è fornita a questo URL:  http://www.w3schools.com/webservices/tempconvert.asmx

Il servizio ha 2 metodi  - FahrenheitToCelsius() e CelsiusToFahrenheit() - che accettano entrambi un solo parametro di input e convertono la temperatura da gradi fahrenhait a Celsius e viceversa.

La risposta del server è un XML di questo tipo:
<?xml version="1.0" encoding="utf-8" ?><string xmlns="http://tempuri.org/">38</string>

Su Visual Studio, cliccando sul nome del progetto web col tasto destro, si apre un menu dove è possibile aggiungere una Web Reference.

Qui si inserisce l’indirizzo della descrizione WSDL del web service.

Il software identifica l’interfaccia del servizio web, con i metodi che mette a disposizione.
Per aggiungerlo al progetto si clicca sul tasto Add Reference. Fatto questo ci troveremo l’oggetto nel Solution Explorer.

Ora nel codice della pagina aspx su cui vogliamo consumare il web service è necessario aggiungere il riferimento con questo codice:
using com.w3schools.www;

Ora dichiariamo un oggetto per la web reference, che sarà possibile utilizzare con tutti i sui metodi come qualsiasi altro oggetto:

com.w3schools.www.TempConvert MyProxy = new com.w3schools.www.TempConvert();

L’esempio finale completo potrebbe essere una pagine con una textbox che nella quale l’utente scrive la temperatura, un bottone di invio invoca il webservice e il risultato appare in una label. In questo caso il codice della classe sarebbe il seguente:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using com.w3schools.www;
public partial class _Default : System.Web.UI.Page{
com.w3schools.www.TempConvert MyProxy = new com.w3schools.www.TempConvert();
protected void Page_Load(object sender, EventArgs e)    { }
protected void Button1_Click(object sender, EventArgs e)    {
Label1.Text = MyProxy.CelsiusToFahrenheit(TextBox1.Text);
}
}


Mentre il codice della pagina il seguente:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>&nbsp;<asp:Button ID="Button1" runat="server" onclick="Button1_Click" Text="Button" /><br />
<asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
</div>
</form>
</body>
</html>


E ora non resta che sbizzarrirsi, una volta imparato il mestiere va affinato.

Lascio qualche link per chi i web service li vuole anche costruire:

• How to create and invoke Java web service
• Your first C# Web Service

Volete stupire con componenti dinamici pronti all’uso? Creare applicazioni web avanzate non è poi così laborioso, oggi si trovano un sacco di risorse in rete. Una di queste è il DHTMLX UI Toolkit, una serie di librerie javascript corredate da tantissimi esempi. La documentazione è ciò che fa la differenza: gli script non documentati e con pochi esempi sono quasi inutilizzabili, se non perdendo un sacco di ore per studiarseli. UI Toolkit viene distribuito in uno zip con diverse pagine di pratiche demo.

Per chi lavora in ambiente .NET molto interessante è questo Ajax Control Toolkit, un insieme di controlli utilizzabili direttamente in Visual Studio con il drag and drop, per costruire form e applicazioni accattivanti. Da Codeplex si possono scaricare anche i sorgenti, corredati da diversi esempi. In questa pagina si può avere una panoramica di tutte le funzionalità disponibili, sono davvero parecchie:

• Accordion
• AlwaysVisibleControl
• Animation
• AsyncFileUpload
• AutoComplete
• Calendar
• CascadingDropDown
• CollapsiblePanel
• ColorPicker
• ComboBox
• ConfirmButton
• DragPanel
• DropDown
• DropShadow
• DynamicPopulate
• FilteredTextBox
• HoverMenu
• HTMLEditor
• ListSearch
• MaskedEdit
• ModalPopup
• MultiHandleSlider
• MutuallyExclusiveCheckBox
• NoBot
• NumericUpDown
• PagingBulletedList
• PasswordStrength
• PopupControl
• Rating
• ReorderList
• ResizableControl
• RoundedCorners
• Seadragon
• Slider
• SlideShow
• Tabs
• TextBoxWatermark
• ToggleButton
• UpdatePanelAnimation
• ValidatorCallout

Per chi vuole essere indipendente da javascript e piattaforma tecnologica, esiste questo Vaadin, tutto basato su Java. Quest’ultimo molto più simile ai più noti framewok come Mootools o JQuery: dispone di diversi componenti elementari che opportunamente combinati tra loro danno vita ad applicazioni web avanzate.

Da segnalare infine questo iWebKit, utile per chi vuole cimentarsi nella realizzazione di siti e applicazioni concepite specificatamente per iPhone.

Risorse di questo tipo ne esistono davvero a bizzeffe, ma non è facile distinguere quelle che sono effettivamente utilizzabili out of the box da quelle che invece necessitano di altro e magari nascondono limiti tali da sconsigliarne l’utilizzo. Personalmente ho utilizzato in un ambiente di produzione l’UI Toolkit di DHTMLX e posso confermare che si tratta di librerie pronte all’uso, davvero comode e funzionali. Ho intenzione di provare a breve l’Ajax Control Toolkit per .NET e vi farò sapere le mie considerazioni. Mi piacerebbe ovviamente sentire le vostre e capire se esistono altri strumenti oltre a quelli citati, che magari avete utilizzato direttamente.

Leggere i dati di un documento XML è un’operazione semplice e veloce, farli visualizzare su una pagina web è altrettanto rapido, ma è bene sapere alcune nozioni per potersi muovere con tranquillità e sicurezza.

Andiamo con ordine e vediamo subito un esempio di un file XML che vogliamo trattare:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<DataSet>
<data>
<period>2010-06-06</period>
<logunit id="myID">Milano</logunit>
<entered matcode="ABC001">100</entered>
<produced matcode="ABC002">101</produced>
<delivered matcode="ABC002">100</delivered>
<description>Caramelline alla fragola</description>
<updated>2010-06-06T13:05:21+01:00</updated>
<note>tante belle cose..</note>
</data>
<data>
[..]
</data>
</DataSet>

Questo file potrebbe rappresentare dei dati produttivi, riguardanti ad esempio i materiali entrati in magazzino, i materiali prodotti e il venduto.

Il modo più rapido e banale per leggere questo file e farlo visualizzare su una pagina ASPX è tramite il seguente codice:

DataSet ds = new DataSet();
ds.ReadXml(@"C:\test.xml", XmlReadMode.Auto);
DataView MyDataView = new DataView(ds.Tables[0]);
MyDataGrid.DataSource = MyDataView;
MyDataGrid.DataBind();

Il codice non fa altro che creare un nuovo DataSet per contenere i dati che andremo a leggere, leggere il file tramite il metodo ReadXml(), creare una DataView con la tabella creata nel dataset e assegnare quest’ultima come DataSource per la DataGrid.

All’interno della pagina .aspx ci sarà quindi una DataSource così fatta:

<asp:DataGrid id="MyDataGrid" runat="server" >
    <HeaderStyle CssClass="th">
    </HeaderStyle>
</asp:DataGrid>

Tralasciamo lo stile attribuito alla testata della datagrid, ciò che è importante in questo caso è solo l’ID. 

Così facendo però ottengo una tabella di questo tipo:

E tutti gli altri dati che fine hanno fatto? Sono stati salvati in altre tabelle del DataSet, assieme a tutti gli attributi dell’xml; queste tabelle avranno come riferimento il data_Id e potrò utilizzarle come meglio credo.

Se infatti cambiamo il primo codice, mettendo una tabella diversa, in questo modo:

DataView MyDataView = new DataView(ds.Tables[1]);

Verrà visualizzata una pagina con la seguente tabella:

Se cambio e metto la terza tabella:

DataView MyDataView = new DataView(ds.Tables[2]);

Il risultato sarà:

Mentre per le tabelle successive, avrò questi risultati visualizzati:

Incrociando queste tabelle attraverso il campo data_Id potrei ricavare tutti i dati contenuti nell’XML, attributi e testi all’interno dei tag.
Il mio obiettivo era però quello di far visualizzare questi dati senza gli attributi riportati nell’XML. Ciò che mi interessa sono solo i dati riportati all’interno dei tag. Vorrei avere un risultato di questo tipo:

In questo caso potrebbe fare al caso nostro l’ XML Schema. Si tratta di un file con estensione XSD, che descrive i dati contenuti in un file XML. Ogni file XML può avere uno schema associato che lo descrive. Esistono diversi tool che possono creare un file XSD a partire da un XML, uno di questi, che trovo molto pratico è quello di Flame-Ware completamente on-line. 

Il nostro file XML iniziale potrebbe essere descritto da questo XSD, supponendo che tutti i campi siano stringe.

<?xml version="1.0"?>
<!-- Generated using Flame-Ware Solutions XML-2-XSD v2.0 at http://www.flame-ware.com/Products/XML-2-XSD/ -->
<xs:schema id="DataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  <xs:element name="DataSet" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="data">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="period" type="xs:string" minOccurs="0" />
              <xs:element name="description" type="xs:string" minOccurs="0" />
              <xs:element name="updated" type="xs:string" minOccurs="0" />
              <xs:element name="note" type="xs:string" minOccurs="0" />
              <xs:element name="logunit" nillable="true" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                  <xs:simpleContent msdata:ColumnName="logunit_Text" msdata:Ordinal="1">
                    <xs:extension base="xs:string">
                      <xs:attribute name="id" type="xs:string" />
                    </xs:extension>
                  </xs:simpleContent>
                </xs:complexType>
              </xs:element>
              <xs:element name="entered" nillable="true" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                  <xs:simpleContent msdata:ColumnName="entered_Text" msdata:Ordinal="1">
                    <xs:extension base="xs:string">
                      <xs:attribute name="matcode" type="xs:string" />
                    </xs:extension>
                  </xs:simpleContent>
                </xs:complexType>
              </xs:element>
              <xs:element name="produced" nillable="true" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                  <xs:simpleContent msdata:ColumnName="produced_Text" msdata:Ordinal="1">
                    <xs:extension base="xs:string">
                      <xs:attribute name="matcode" type="xs:string" />
                    </xs:extension>
                  </xs:simpleContent>
                </xs:complexType>
              </xs:element>
              <xs:element name="delivered" nillable="true" minOccurs="0" maxOccurs="unbounded">
                <xs:complexType>
                  <xs:simpleContent msdata:ColumnName="delivered_Text" msdata:Ordinal="1">
                    <xs:extension base="xs:string">
                      <xs:attribute name="matcode" type="xs:string" />
                    </xs:extension>
                  </xs:simpleContent>
                </xs:complexType>
              </xs:element>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:choice>
    </xs:complexType>
  </xs:element>
</xs:schema>

Per associare questo schema al file XML, è necessario dichiararlo nell’intestazione, in questo modo:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<DataSet xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="schema.xsd">
<data>
<period>2010-06-06</period>
<logunit id="myID">Milano</logunit>
<entered matcode="ABC001">100</entered>
<produced matcode="ABC002">101</produced>
<delivered matcode="ABC002">100</delivered>
<description>Caramelline alla fragola</description>
<updated>2010-06-06T13:05:21+01:00</updated>
<note>tante belle cose..</note>
</data>
</DataSet>

Così facendo però, se rilanciamo la pagina costruita in precedenza, il risultato sarà identico: un unico dataset con diverse tabelle collegate tra loro dal campo data_Id.

Quindi? La soluzione c’è. Dobbiamo solo definire uno schema XSD semplificato all’interno dell’XML stesso. In questo modo:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<DataSet>
<xs:schema id="NewDataset" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  <xs:element name="NewDataset" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
    <xs:complexType>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="data">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="period" type="xs:string" minOccurs="0" />
              <xs:element name="description" type="xs:string" minOccurs="0" />
              <xs:element name="updated" type="xs:string" minOccurs="0" />
              <xs:element name="note" type="xs:string" minOccurs="0" />
              <xs:element name="logunit" type="xs:string" minOccurs="0" />
              <xs:element name="entered" type="xs:string" minOccurs="0" />
              <xs:element name="produced" type="xs:string" minOccurs="0" />
              <xs:element name="delivered" type="xs:string" minOccurs="0" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:choice>
    </xs:complexType>
  </xs:element>
</xs:schema>
<data>
<period>2010-06-06</period>
<logunit id="myID">Milano</logunit>
<entered matcode="ABC001">100</entered>
<produced matcode="ABC002">101</produced>
<delivered matcode="ABC002">100</delivered>
<description>Caramelline alla fragola</description>
<updated>2010-06-06T13:05:21+01:00</updated>
<note>tante belle cose..</note>
</data>
<data>
<period>2010-06-06</period>
<logunit id="myID">Milano</logunit>
<entered matcode="ABC001">100</entered>
<produced matcode="ABC002">101</produced>
<delivered matcode="ABC002">100</delivered>
<description>Caramelline alla fragola</description>
<updated>2010-06-06T13:05:21+01:00</updated>
<note>tante belle cose..</note>
</data>
</DataSet>

Il risultato finale sarà quindi una DataGrid che può essere visualizzata come sotto, utilizzando pari pari il codice C# definito all’inizio di questo articolo.

Buon divertimento con l’XML..

Davide: Che cosa dovrebbe avere una buona intranet?
Jane: Una buona intranet deve avere 3 cose:

1. essere incentrata sull’utente,
2. avere una strategia allineata al business
3. Avere una governance e politiche di gestione integrate al modo con cui viene gestita l’impresa

Davide: Quali sono le best practices per adottare l’enterprise 2.0? Esiste una roadmap comune?
Jane: Ma dispiace ma non esistono roadmap comuni e collaudate. Alcune aziende definiscono prima la strategia, poi la implementano. Altre iniziano con sperimentazioni dal basso, poi ufficializzano ciò che funziona. Altri mettono in campo un minimo di strategia e un po’ di sperimentazione dal basso, per poi farne una sintesi!

La chiave del successo è iniziare da ciò che è necessario al business, non dalla tecnologia. Fate progetti pilota dove c’è allo stesso tempo un bisogno e una sfida.

Davide: Wiki e blog dovrebbero essere utilizzati in una intranet? Se si, esiste un approccio da consigliare per spiegare agli utenti qual è il tool migliore da utilizzare , in base ai contenuti da pubblicare e al feedback che si desidera ricevere?
Jane: I Wiki servono per la co-creazione: fare cose assieme, fornendo uno strumenti per  “la voce del popolo”. Sono di proprietà del popolo o del singolo gruppo. Sono multi-dimensionali: i contenuti si creano spontaneamente. Potrebbero emergere talvolta anche cose inattese.
I blog servono per fare esprimere una voce individuale, il punto di vista di un team, per condividere l’esperienza. Si fanno portatori del punto di vista di un singolo o di un gruppo di persone. Sono bi-dimensionali: viene riportato un certo punto di vista o una notizia, mentre tutte le altre persone possono commentare o fare domande.
E’ interessante notare che le mie ricerche degli ultimi anni, condotte per la Global Intranet Strategies survey, evidenziano che solo nell’ultimo anno i blog hanno assunto rilevanza al pari dei wiki nelle aziende. Entrambi hanno raggiunto il 45 % dell’utilizzo nell’inchiesta del 2009, su un campione di circa 300 organizzazioni in tutto il mondo.
Fino all’anno scorso, i wiki la facevano da padrone. Credo che le società stiano famigliarizzando coi blog. I blog ottengono spesso più visibilità: persone che esprimono punti di vista. Richiedono probabilmente maggior tempo per la gestione rispetto ai wiki, basati sulla collaborazione, cosa che le imprese fanno da diverso tempo.

Davide: Connessioni col sistema ERP: è utile averle all’interno della intranet?
Jane: Assolutamente. Più che utile, è essenziale. E’ la chiave di volta per far sì che la intranet diventi il luogo di lavoro all’interno dell’impresa.

Davide: Credi che esista una killing application? Si parla spesso di Sharepoint.. Lavoro su Sharepoint da quasi due anni, credo che sia una buona piattaforma per realizzare applicazioni web, molto malleabile per poter mappare i processi di business
Jane: Sharepoint è solo una delle tante soluzioni. Non penso che una soluzione da sola si possa considerare una killer app.

Davide: Accesso dall’esterno e tramite dispositivi mobili: credi che sia un obiettivo primario?
Jane: Non è primario ma è molto importante. E’ uno dei 5 key trends che ho individuato per il 2010.

Davide: Qual è il miglior progetto che hai realizzato? Perchè?
Jane: Ce ne sono parecchi! I migliori sono quelli in cui la intranet ha cambiato il modo di lavorare dell’azienda, e il modo di fare business. La intranet esiste, in estrema sintesi, per servire i clienti. Per clienti, intendo i clienti esterni.
Le intranet aiutano le organizzazioni a lavorare meglio: le aziende lavorano per servire i loro clienti.

Davide: Grazie mille per questa intervista Jane, spero di sentire qualche utile consiglio all’E2.0 Forum!

• Verso l’interno: Intranet 2.0, Community Management, Human Resources 2.0, Social Learning, Organizational Network Analysis, IT Governance
• Verso l’esterno: Social CRM, Sales Community, Social Media Marketing, Social Media Monitoring
• Innovazione: Idea e Innovation Management, Crowdsourcing e Idea generation, Prediction market
• Definire la strategia e costruire il business case
• Nuovi schemi organizzativi e modelli di leadership
• Sostenere l’adozione ed il cambiamento culturale
• Driver di business, metriche e ritorno dell’investimento
• Framework per coltivare le community ed ingaggiare i clienti e gli utenti
• L’impatto dei social media sui processi di business: BPM 2.0, CRM 2.0, PLM 2.0
• Best practice e lezioni attraverso casi di successo nazionali ed internazionali
• Il passaggio dal marketing al social CRM
• Software sociali e piattaforme collaborative

Sono temi che mi stanno particolarmente a cuore e coi quali mi sto scornando in prima persona; potrebbe essere una due giorni per approfondire qualche argomento. Gli speaker sono parecchi, coi quali mi piacerebbe scambiare due chiacchiere. L’occasione è piuttosto ghiotta per poter discutere e analizzare casi concreti: tra i relatori leggo nomi come IBM, Oracle, Intel. Ovviamente si tratta di una conferenza a pagamento: per gli studenti senza portafoglio esiste però l’opportunità di partecipare gratuitamente inventandosi promoter dell’evento, per chi desidera maggiori informazioni ecco il post dal blog ufficiale.

Le date sono un po’ proibitive per il sottoscritto, ma confido di farcela.. Qualcuno ha già fissato la data?

Enterprise 2.0 per chi è sul pezzo, nuovi strumenti lavorativi per chi semplicemente li usa. Fatto sta che sono sempre più diffusi, all’interno delle organizzazioni, strumenti come i blog e i wiki; utilissimi ai team di lavoro per la gestione quotidiana delle attività, altrettanto utili all’azienda per conservare traccia del lavoro svolto e rendere questa conoscenza riutilizzabile in futuro. Sono arrivati già da tempo anche i software di instant messaging, un altro noioso compagno d’ufficio dopo il telefono. In fondo si tratta di tools per comunicare, ma non solo.

E’ sempre difficile la scelta su quale strumento utilizzare, soprattutto per chi ne è a digiuno; vi sono strumenti più o meno adatti in base alle informazioni da condividere e ai feedback necessari. La tipologia della relazione spesso fa la differenza sul raggiungimento dei risultati.
Per scrivere le riflessioni seguenti ho preso spunto da una discussione sul tema che ho letto via LinkedIn, dove veniva citato questo interessante contributo.

Veniamo al dunque, quando è meglio usare uno strumento piuttosto che un altro?

• Blog: è uno strumento informativo più che collaborativo. E’ particolarmente indicato per team di lavoro distribuiti, dove il project manager deve tenere informati i vari attori, talvolta pure il cliente. Dagli articoli possono scaturire discussioni, ma generalmente si tratta di discussioni operative, destinate a perdersi col tempo poichè non sono strutturate. La discussione è asincrona. Le informazioni possono essere catalogate con tag e categorie, ma la componente cronologica è sempre prevalente e prima o poi le notizie finiscono nel dimenticatoio.
• Wiki: è un contenitore di conoscenza. Un repository all’interno del quale memorizzare la conoscenza, sia quella esplicita che tacita. L’informazione può essere strutturata attraverso menù di navigazione, link tra pagine ed eventualmente con una tassonomia. Il contenuto è vivo, viene continuamente modificato dagli utenti ma si conserva la traccia dell’evoluzione. Non è certamente adatto per sviluppare discussioni sulle faccende più operative e non si presta nemmeno come luogo di scambio col cliente, a meno di particolari situazioni. E’ un luogo dove archiviare cose che possono tornare necessarie in futuro, come le best practices per lo sviluppo di un prodotto o per l’archiviazione di istruzioni operative.
• Instant Messaging: è perfetto per chiedere informazioni al volo senza disturbare troppo i colleghi o chi per loro. E’ certamente meno invadente del telefono pur svolgendo la medesima funzione. La comunicazione è rallentata ma efficace: sincrona. Va usato con moderazione, ma è forse uno degli strumenti più rivoluzionari. Con i software di IM è inoltre possibile condividere file o la propria sessione del desktop, si tratta di funzionalità spesso poco utilizzate.
• Email: la rogna più grossa dei nostri tempi. Serve solo ed esclusivamente per comunicazioni ufficiali, come ad esempio la notifica di un appuntamento o l’assegnazione di un task. Sviluppare discussioni dove si chiede il parere di più persone così come collaborare su un file tramite mail è la cosa più sbagliata che si possa fare. Quando serve un feedback “evoluto”, mai usare la mail.
• Telefono: serve per chiedere “Dove sei?” ed eventualmente comunicare al volo alcune cose, come il classico “Arrivo più tardi!”. A volte, se servono molte informazioni immediatamente è meglio parlarsi, perchè l’instant messaging potrebbe rubare tempo ad entrambi. Si tratta di comunicazione sincrona; in fondo a volte è anche piacevole scambiarsi informazioni in modo naturale.

A questi strumenti, inoltre, dobbiamo aggiungere i cosidetti workspace. Tipicamente siti web che raccolgono una o più funzionalità citate sopra e ne estendono le potenzialità con calendari o cartelle condivisi, dove archiviare file sui quali è richiesto l’intervento di più persone.

L’ultima frontiera della collaborazione è sicuramente il buon Google Wave, che ancora in pochi utilizzano (me compreso) ma che alla lunga credo andrà a sostituire la mail, o perlomeno quel modo errato di usarla, che tutti prima o poi sperimentano. In sostanza unifica l’IM, l’editing collaborativo e la mail, aprendosi verso quel mondo infinito di applicazioni web: mappe, video, ecc..

E voi, cosa ne pensate? Avete mai provato a spiegare a qualcuno che sia a digiuno di tutti quando è il momento di usare una cosa piuttosto che un’altra?
Nell’ottica della gestione delle informazioni, credo che sia importante istruire gli utenti circa gli strumenti che hanno a disposizione. Ma come farlo? Attraverso lunghe pagine descrittive del servizio? Può essere utile moderare i contributi e spostarli da un blog a un wiki e viceversa? Io sono ancora in fase di studio dei comportamenti..

Avete mai definito una strategia per diffondere le logiche di web 2.0 in azienda? Ovvero, per arrivare alla tanto decantata enterprise 2.0.. Se si, sono il primo a volerlo sapere.! E dopo un commento a questo articolo, potreste andare a pubblicare la vostra roadmap sul sito di AIIM entro il 2 aprile 2009: è in corso un contest che potrebbe farvi vincere 2000 dollari.

Diffondere la cultura 2.0 in una azienda è una sfida notevole, sia dal punto di vista tecnico che dal punto di vista organizzativo. Se da un lato vi sono sempre più strumenti “all-in-one”, che permettono un veloce deploy delle applicazioni sociali e collaborative web based, dall’altra è sempre vivo il timore della perdita del controllo sui dati, ma anche e soprattutto sui processi o sulle prassi aziendali. Ecco perchè il coinvolgimento del top management divenda un punto fermo, senza questa sponsorship non riusciremo a raggiungere gli obiettivi. Così come è fondamentale definire i passi assieme al dipartimento HR, per tutti quegli aspetti legali dovuti alla privacy; infine sarà indispensabile individuare i key users, persone che possono dare grande valore aggiunto.

Vi sono, a mio avviso, due tipologie di key user da scovare:

• Gli Esperti: coloro che sanno come funziona l’azienda, il knowledge, come girano le informazioni, come le persone ottengono le cose. Sono tipicamente i “nonni”, lavorano in azienda da tempo e magari non hanno molta confidenza con gli strumenti informatici.
• I Visionari: coloro che sanno (nella loro testa) come dovrebbero apparire le informazioni, come dovrebbero essere taggate, come dovrebbero essere archiviate e presentate. Sono persone che sentono l’esigenza di comunicare e lavorare meglio, hanno la casella di posta elettronica intasata da discussioni con maree di allegati ma si sentono impotenti davanti a tutto ciò.

Il fattore critico è sempre il tempo che questi utenti possono mettere a disposizione, dal top management ai key users, tipicamente nessuno ha mai tempo da dedicare all’IT per migliorare la propria condizione lavorativa. E’ difficile far comprendere che si sta cercando di dare risposte a loro e forse proprio in questo senso la definizione della roadmap dovrebbe essere un punto di partenza ineluttabile.

Per chi volesse approfondire ecco l’articolo di presentazione del contest dal blog di AIIM. Ovviamente, finito il contest sarà interessante vedere i contributi pervenuti! I risultati sono attesi per l’11 Maggio 2010.

Si torna sempre un po’ più pieni dalla Sharepoint Conference, così è stato anche quest’anno. Dal 9 all’11 marzo, in una Milano timidamente innevata, purtroppo sono rimasto solo i primi due giorni. C’è una convinzione su tutte che mi porto a casa: è giunta l’era degli ERP delle informazioni.

Negli anni ’90 si vendevano gli applicativi di processo, c’era il software per la fatturazione, il software per la gestione del magazzino, il software per la gestione degli ordini di acquisto, e via dicendo. Poi arrivò il gestionale integrato, quello che metteva sotto controllo l’intero processo; e dopo qualche anno di titubanze siamo arrivati nel 2000 e tutti abbiamo capito l’importanza del software che accentra i dati e monitorizza l’intero processo.
Oggi, nel 2010, abbiamo il software per la gestione documentale, il CRM (Customer Relationship Management), il CMS (Content Management System), il software per la gestione delle trasferte, il social network dove i dipendenti si scambiano notizie, l’enterprise wiki per i tecnici della ricerca e sviluppo, il software per la business intelligence che rileva i dati dal gestionale, il software per l’archiviazione dei curriculum e per il recruiting, e via dicendo.. Ebbene, nell’era dell’information worker è diventato fondamentale avere una visione complessiva delle informazioni da gestire. E’ diventato fondamentale avere una piattaforma, sulla quale coinvogliare le informazioni, attingendole da fonti dati esterne, da strumenti di office, o direttamente dagli utenti. L’hanno capito dalle parti di Redmon, stavolta forse sono arrivati per primi. Certo, è un evento: tipicamente copiavano altri. Io non ho ancora visto nulla dalle potenzialità di Sharepoint 2010: c’è veramente un sacco di roba da studiare.

• Social Networking: che sia davvero maturi i tempi per il facebook aziendale? Tagging ovunque, profilo personale, ecc..
• Gestione documentale (ECM, per gli angofoni): tante possibilità di gestione dei metadata, di tutto ciò che da valore aggiunto al semplice documento
• Enterprise Wiki: un wiki integrato alla intranet, esistevano già col vecchio Sharepoint, ma ora sono molto più evoluti.
• Web analytics
• Blogs
• Connectors verso fonti dati esterne

Nella breve e intensa panoramica di questa due giorni mi sono davvero impressionato. Avevo visto Alfresco, Socialtext, MovableType e tanti altri: ma si tratta appunto di piattaforme settoriali, perfette per fare una singola cosa, gestione documentale, wiki, blogging.. Quello che manca a tutte queste applicazioni è una visione d’insieme e integrata, cosa che appunto fa la differenza in SharePoint.

Quello che manca? Una visione web del mondo office. Manca appunto un “Enterprise Google Apps“, se ci fosse anche questo saremmo davvero al completo. Per la versione 2010 hanno lavorato parecchio sulle feature web, sono arrivati i ribbon e tanto ajax, che rendono il tutto molto RIA.. In un’ottica veramente mobile e veramente collaborativa, dove magari è richiesta l’interazione del fornitore o del cliente (che potrebbe non avere installata l’ultima versione del software Microsoft), è bene prevedere l’editing dei documenti direttamente via web, laddove questi non siano particolarmente pesanti: ecco allora le Office Web Applications, che portano online il famigliare ambiente Office.

Su questo campo, Google ha aperto la strada e Microsoft ha capito. Basti pensare che nonastante tutti i miglioramenti fatti su Outlook 2010, Gmail rimane ancora un miraggio.

NB: per chi fosse curioso, sul sito di Microsoft si trovano le macchine virtuali con Sharepoint già bello pronto. I download sono piuttosto corposi, ma ne vale la pena. Mentre qui si trova il download delle Office Web Apps. Aspettando le sofferenze dell’upgrade..

In realtà la laurea è avvenuta a Marzo, i festeggiamenti pure.. in un poetico irish pub addobbato a festa per San Patrizio.

Durante lo stage e nei mesi a seguire mi sono occupato di PDM (Product Data Management) e di intranet (sorprendendomi di un versatilissimo Sharepoint) in un gran bel gruppo industriale. Avevo già pubblicato qualche idea, ora è il momento del pdf. Pubblico solo in parte, per ovvi motivi di riservatezza, il capitolo 7 relativo alla intranet sviluppata in azienda.

L’intero lavoro è rilasciato con licenza Creative Commons.
Scarica il PDF: Tecnologie ICT per l’Enterprise 2.0: tra Project Management e Collaborazione

Tecnologie ICT per l’enterprise 2.0: tra project management e collaborazione by Davide Del Monte is licensed under a Creative Commons Attribuzione-Non commerciale-Non opere derivate 2.5 Italia License.
Permissions beyond the scope of this license may be available at www.diplod.it.

Di cosa parla questo lavoro? Il sommario vale più di mille parole:

1.Introduzione……………………………………………………………………………….. 11

2.Lo scenario…………………………………………………………………………………. 13
(a)Project Management in R&D………………………………………………. 14
(b)La struttura organizzativa…………………………………………………… 18
(c)Importanza della gestione progetti e Open Innovation………….. 21
(d)Intranet: condivisione e architetture Service Oriented…………… 25
(e)Gestione documentale abbinata ai progetti…………………………. 27

3.Gli strumenti per l’innovazione…………………………………………………….. 31
(a)Ai confini del Knowledge Management……………………………….. 32
(b)Crowdsourcing…………………………………………………………………. 35
i.caso Goldcorp………………………………………………………… 37
ii.caso Colgate-Palmolive…………………………………………… 38
(c)Triz Innovation…………………………………………………………………. 38

4.Social Network e analisi delle reti di persone…………………………………. 45
(a)Enterprise 2.0 e reti sociali………………………………………………….. 44
(b)I bisogni emergenti: Social Network e Appartenenza aperta……. 47
(c)Social Network Analysis e Value Network Analysis…………………. 53
(d)Gli strumenti per l’analisi delle reti sociali…………………………….. 59
Approfondimento tecnico: il software Ucinet……………… 64
(e)Small world network e i 6 Degrees su Facebook…………………….. 68
(f)Le reti a invarianza di scala e la dinamica dei sistemi complessi.. 70
(g)Elementi teorici per la costruzione di un Social Network…………. 74

5.Governance ICT: integrazione e architetture service oriented…………… 83
(a)complessità crescente e bisogno di integrazione……………………. 84
(b)Service Oriented Architecture (SOA) e Software as a Service
(SaaS), Business Process Management (BPM) e Rich Internet Applications (RIA) nei modelli organizzativi rizomatici…………… 85
(c)Dalle prime forme di scambio informazioni alla Enterprise
Application Integration (EAI)………………………………………………. 93
(d)Accoppiamento del software: bene o male?…………………………. 97
(e)Il ruolo dell’ICT: Perché i progetti falliscono………………………….. 99

6.Gli strumenti della Social Era…………………………………………………………. 103
(a)Virtual workspaces: tra wiki, blog e team di lavoro…………………. 104
i.caso Lago………………………………………………………………… 109
ii.caso Serena……………………………………………………………. 111
(b)Sharepoint e Project Web Access: la collaborazione sui progetti
secondo Microsoft…………………………………………………………….. 112
(c)Qualche cenno sui vendor internazionali e i player italiani……… 119
(d)Qualche cenno sul mondo Open Source………………………………. 124

7.Il caso LandiRenzo SpA: intranet per il reparto R&D……………………….. 129
(a)L’azienda e l’unità R&D………………………………………………………. 130
(b)L’analisi di partenza…………………………………………………………… 133
i.Persone e progetti………………………………………………….. 133
ii.Metodologie e prassi lavorative……………………………….. 134
iii.La collaborazione e gli strumenti……………………………… 136
iv.I network relazionali………………………………………………. 138
v.I rapporti con le sedi estere…………………………………….. 141
(c)Il re-design della intranet R&D: metodologie e problematiche.. 142
(d)Sharepoint e PWA: personalizzazioni della piattaforma e Web Parts……………………………………………………………………………….. 145
i.Utenti, sincronizzazione Active Directory e
ristrutturazione RBS……………………………………………….. 149
ii.Calendari condivisi per i banchi e la strumentazione
tecnica………………………………………………………………….. 152
iii.Template Landi………………………………………………………. 155
Approfondimento tecnico: Creazione tema Sharepoint…………………………………………………… 156
iv.Realizzazione prototipo di project workspace: uno spazio collaborativo con wiki e blog……………………………………. 159
(e)Product Data Management con il software CoCreate Model
Manager: workflow e integrazione SAP……………………………….. 166
i.Creazione di una nuova classe documentale………………. 174
ii.Creazione di nuovi materiali…………………………………….. 176
iii.Definizione workflow di approvazione disegni……………. 178
(f)Punti di forza e debolezza dei sistemi e ipotesi di sviluppo……… 180
i.PWA: i Key Users…………………………………………………….. 181
ii.PDM: integrazione SAP…………………………………………….. 183
iii.Scarso utilizzo e mancanza di incentivi………………………. 184
iv.Web Services con PDM……………………………………………. 185
v.Integrazione tra Sharepoint e SAP Portal……………………. 186

8.Conclusioni: una nuova intranet di Gruppo…………………………………….. 191

Riferimenti Bibliografici………………………………………………………………… 199
Appendice A: Una Web Part con le news da Google, XML e XSL all’opera 202
Appendice B: procedura per il deploy di un Application Template Sharepoint…………………………………………………………………………………… 206
Ringraziamenti…………………………………………………………………………….. 209

Mi piacerebbe se da questo lavoro nascessero spunti di riflessione, se qualcuno si facesse avanti per indicarmi esperienze simili, per scambiare pareri e conoscenze. Buona lettura ;)

Foto Flickr

Come mai oggi sempre più giovani coltivano il mito dell’espatrio? Siamo davvero messi così male? Molte statistiche confermano: l’Italia non è Paese per giovani laureati. Ogni tanto mi sovviene il dubbio.. Io, nel mio quarto di secolo, sono soddisfatto del mio primo lavoro post laurea, e vedo intorno a me diversi giovani che “fanno”. A volte mi chiedo se non sia  colpa del sistema mediatico, che promuove modelli “ignoranti” come riferimento.
Proprio ieri è arrivato wired di Dicembre, evidentemente ci sono diversi lettori che la pensano più o meno come me. Nelle lettere indirizzate al magazine si parlava di Lorenzo Thione, un ragazzo che ha fondato Powerset per poi venderla a Microsoft e farsi un bel gruzzoletto (100 milioni). La tecnologia di ricerca sviluppata da Thione è ora utilizzata per Bing, il motore di ricerca di Microsoft. Ora il fulcro non sta nel determinare se Bing è meglio di Google (su questo non c’è dubbio, il secondo è nettamente superiore), ma nel cercare di capire come mai in Italia nessuno ha mai sentito parlare di questo tizio.

Se uno vincesse 100 milioni al SuperEnalotto diventerebbe una star. I tiggì strillerebbero l’allegra notizia, e i quotidiani manderebbero un inviato nel paese natio per parlare con amici e parenti. Già mi vedo le dieci domande. Come ha fatto ad azzeccare la mitica sestina? Come spenderà questa somma pazzesca? E via così. I settimanali di gossip andrebbero a caccia delle foto di famiglia cercando di allestire flirt con veline o calciatori, mentre i politici proverebbero a tradurre la popolarità in una candidatura: “Fai come lui/lei, vinci al SuperEnalotto”. Per sua fortuna, invece, Lorenzo Thione, per fare 100 milioni, ha dovuto studiare, andare negli Stati Uniti, avere una buona idea e lavorare duro. Così ha fatto Bing, e lo hanno bellamente ignorato. Fosse mai che poi uno come lui diventa un modello. O una speranza.

Sempre su wired, Marco rispondeva a un’altra ragazza che dichiarava le sue intenzioni di trasferirsi a Stoccolma. Anche in questo caso, riporto le sue parole poichè rispecchiano in toto il mio pensiero:

Ho letto con attenzione e commozione la lettera della ragazza che sta emigrando a Stoccolma. Cara amica, ti auguro il miglior bene, complimentandomi per il coraggio e la determinazione. Se permetti, io resto qua in Italia. Il Paese che mi ha dato i natali, del quale parlo la lingua e del quale mi sento cittadino. Non vuole essere una patetica dimostrazione di cieco patriottismo, ma una dichiarazione d’intenti. Se ci sono posti al mondo ai quali aspiriamo e che guardiamo con invidia e ammirazione, perchè non provare anche noi a diventare come loro? Il livello di civiltà di una nazione non dipende dal fato, ma da come i suoi cittadini la vogliono far diventare. Io credo che noi, giovani e meno giovani di oggi, che siamo consapevoli che il cambiamento è nelle nostre mani, abbiamo la capacità, la forza e la voglia di far diventare il nostro Paese un bel posto. Il senso civico, la consapevolezza che il benessere collettivo si riflette in benessere personale, il rifiuto dell’egoismo sociale, sono piantine che vanno coltivate e io non mi voglio tirare indietro, anche se i frutti dovessero coglierli i miei figli o i miei nipoti. Perciò, cara amica, a te e a tutti quelli che scelgono un’altra strada, i miei migliori auguri di tutto cuore.
Io, qua, ho da fare.

Su questo tema c’è pure chi ha scritto un libro. Io credo che l’Italia abbia un immenso problema: quello dei media. Se è vero che ormai buona parte dei giovani passa più tempo su internet che sulla tv, è altrettanto vero che i modelli di riferimento spesso escono da quest’ultima. Avete mai visto un servizio nel tg della sera su un qualche ricercatore/scienziato/studioso/lavoratore emergente? E quanti servizi abbiamo dovuto sopportare sul piccolo borgo di Bagnone? Se vinci il superenalotto con una schedina da 2 euro diventi un dio, se passi 5 anni all’università sei un pirla.

Ci sono tante, troppe, notizie poco incoraggianti. Se dovessi basarmi solo sui numeri partirei domani, ma se penso a come mi sentirei davvero realizzato, mi vedo in Italia. Con questo non dico che sono contrario a qualsiasi esperienza all’estero, magari ne farò tante e ben volentieri. Ma il mio obiettivo è mettere le radici qui, tra qualche anno. Ho seguito, durante gli studi, i passi di Camu, e in qualche modo lui fa parte di quei modelli positivi, che si trovano solo spulciando la rete. Perdendo tempo..

Ho cercato PBwiki e Google mi propone PBWorks. A volte le cose si scoprono anche così, cercandole. Magari sono pure arrivato lungo, perchè il cambio del marchio è avvenuto ad Aprile 2009. In ogni caso ciò che ho visto oggi è un tool di tutto rispetto, che ha messo da parte il suo taglio prettamente wiki e si propone come strumento di collaborazione per piccoli team di lavoro.

Una delle maggiori esigenze nelle aziende di oggi è la possibilità di avere uno spazio di condivisione facilmente estendibile verso l’esterno, per comunicare con clienti o fornitori, per fare co-design, per scambiare files e conoscenza. Cosa serve quindi? Un’area FTP (magari Tortoise per tracciare le versioni dei files), un wiki, e tanta (troppa) amministrazione. Cosa potrebbe sostituire queste cose? PBWorks: un wiki con un’area di gestione file dotata del versioning. Ma soprattutto uno strumento facile da utilizzare, che può benissimo essere aperto in autonomia da qualsiasi utente senza il supporto IT e che è in grado di gestire diversi profili di accesso: amministratore, editore, lettore, ecc..

Non mancano RSS, backup, personalizzazione dei colori e del logo. Sono tutte funzionalità che devono esserci e sono considerate commodity. Tipicamente ciò che fa la differenza in questi strumenti è la facilità di gestione.

Nell’ottica di intranet management, dare la possibilità ai propri utenti di aprirsi e configurarsi uno spazio di lavoro in autonomia è cosa buona e giusta. Può però diventare problematico quando vi è la necessità di aprire l’accesso verso l’esterno: clienti e fornitori non avranno mai un utente di dominio. Ecco allora che si passa nel campo della extranet.

Perchè non utilizzare servizi esterni? Gli utenti prima o poi lo farebbero da soli, a mio avviso meglio prevedere certi comportamenti e convogliare la domanda verso un unico strumento. PBWorks mi ha colpito per la sua estrema facilità di utilizzo e per la sua velocità di configurazione.
In PBWorks ho notato tante di quelle funzionalità che il buon Giacomo Mason ha elencato per il corporate wiki ideale. Ciò che non va sono le politiche di prezzo, se è vero che comunque viene data la possibilità di creare workspaces gratuitamente con utenti infiniti, è altrettanto vero che le licenze annuali per i servizi professionali sono piuttosto alte (nell’ordine dei 20 dollari per utente, Google ne chiede 40 per offrire la posta elettronica più tutta la suite di Google Apps).

Cosa mi servirebbe? Un servizio simile, se poi qualcuno conoscesse qualcosa di utilizzabile pure in locale e non come servizio, sarebbe il top. Wikispaces è la concorrenza, ma pecca nella gestione dei files: manca infatti un ambiente di gestione dei documenti e relative revisioni.

Entrambi hanno però una cosa fondamentale: le API. Purtroppo ancora non ho avuto tempo per studiarmele a fondo, ma è proprio attraverso le API che si potrebbero gestire all’interno della propria intranet i workspaces aperti verso l’esterno dagli utenti, per tenere sempre la situazione sotto controllo. Questo, a mio avviso, è uno degli elementi fondamentali per scegliere il prodotto. Mi riserbo quindi la decisione finale dopo aver giochicchiato con le API. Semmai qualcuno lo avesse già fatto, è obbligato a commentare!

Ebbene, da poco più di un mese Google ha lanciato la preview di Wave: un nuovo modo di comunicare e lavorare. Era da tempo che non riuscivo a stupirmi utilizzando una applicazione web.. I vari Facebook, SlideShare, LinkedIn, Flickr e tutte le loro spassosissime integrazioni mi avevano abituato a standard elevati. Anche se poi, diciamocelo, sono cosette. Che sul lavoro possono servire, certo, ma non sono fondamentali.

Skype, ad esempio, è una di quelle cose che in ambito lavorativo ti possono cambiare la vita: in bene o in peggio, questione di carattere. Ma restano i limiti di una messaggistica legata al testo.. dove un file arriva come qualcosa da scaricare e per cui è necessario individuare un posticino nel proprio disco fisso. Per non parlare dei limiti della messaggistica istantanea, se ti distrai un attimo è la fine.

La mail, beh.. Quando ho iniziato a utilizzare Gmail ho capito la differenza. E’ un amore che matura col tempo, se poi ti ritrovi dopo qualche anno a lottare con l’archiviazione automatica di Outlook (per non parlare delle funzionalità di ricerca), capisci d’un botto quanto sia diverso il concetto di mail tra Google e Microsoft. Eppure, dopo un po’, anche la mail ti sta stretta.. Se ne devono essere accorti dalle parti di Mountain View, perchè hanno iniziato a riempirla di applicazioni che ne estendono gli utilizzi: sono nate le Labs Features per Gmail. Ecco allora le foto di Flickr, i video di youtube, calendar, i task.. tutti assieme integrati in Gmail.

Poi il botto: Google Wave. Arriva proprio come un’onda, e ti accorgi subito dopo due o tre salti che questa è una rottura. Il concetto di mail si evolve e si fonde con quello della messaggistica istantanea. La comunicazione diventa al tempo stesso sincrona e asincrona. Non c’è più solo il testo, ci sono i video, i file, le mappe, tutto assieme in un unico flusso comunicativo. Così rifletti: non ci metti molto per capire che se i tuoi colleghi utilizzassero sta roba assieme a te sarebbe davvero diverso.

E’ ancora tutto in preview, si accede su invito, io l’ho ricevuto ma ancora non ho la possibilità di offrirne a mia volta. Appena potrò lo farò più che volentieri: si accettano candidature. :)
Per ora, l’unico modo è segnalare la propria curiosità in questa pagina. Per chi vuole informarsi, queste sono le pagine di riferimento.

Communication and Collaboration Tool: modifiche in tempo reale, più utenti assieme che editano documenti e commentano i commenti di altri. Un’onda è un flusso comunicativo vivo che si aggiorna ed evolve, non servirà più ricercare le mail. Le useremo solo per le comunicazioni formali.
Chissà che un giorno non diventi il fulcro della piattaforma enterprise di Google.