L’immagine che illustra il crivello di Eratostene che in questi giorni circola su G+ (credo sia di John Baez Skopp (vedi commento, grazie Annarita!)) è l’ideale per implementare un programmino nel Fortran delle origini. Eccolo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

C     ERAHOSTHENES

      DIMENSION NUMERI(20), LPRIMI(10)

C     NUMERI CONTIENE I NUMERI CHE POSSONO ESSERE PRIMI  
      DO 10, I = 1, 20
10    NUMERI(I) = I
      NUMERI(1) = 0  

C     NPRIMI = IL NUMERO DI PRIMI TROVATI
      NPRIMI = 0
      NTROV = 2

C     QUANDO NE TROVO UNO LO AGGIUNGO ALLA LISTA DEI PRIMI
20    NPRIMI = NPRIMI + 1
      LPRIMI(NPRIMI) = NTROV

C     ELIMINO I SUOI MULTIPLI NELLA LISTA DEI NUMERI
      J = 1 
30    J = J + 1
      NT = NTROV * J
      IF(NT .GT. 20) GOTO 40
      NUMERI(NT) = 0
      GOTO 30

C     PASSO ALL ESAME DEL CANDIDATO SUCCESSIVO
40    N = NTROV
41    N = N + 1
      IF(N .GT. 20) GOTO 60
      IF(NUMERI(N) .EQ.0) GOTO 41
50    NTROV = N
      GOTO 20

C     FINE DELL ESAME DELLA LISTA
60    DO 65 I = 1, NPRIMI
65    WRITE(*, 90) I, LPRIMI(I)
90    FORMAT(2I4)

      END

Nello spirito del tempo ho scritto tutto in maiuscolo Però non ce l’ho fatta a non lasciare spazi: allora si sarebbe scritto tutto come J = J + 1. E un’altra cosa ancora: la riga a cui l’esecuzine saltava a seguito di un GOTO era tipicamente del tipo:

50    CONTINUE

essendo quest’istruzione segnaposto fatta proprio apposta per questo. Ma il mio programma sarebbe diventato troppo lungo, inutilmente.
Un’altra cosa: è quasi immediata l’ottimizzazione considerando che 2 è l’unico primo pari, dimezzando il numero di numeri da testare ma il codice si allunga, lasciato come esercizio.

Ecco, allora si programmava così. Non ho più il libro ma nel testo che si usava al Poli c’era scritto: “finito di perforare le schede fai una stampa del listato e controllala attentamente prima di provare l’esecuzione“, vero anche perché a me al primo tentativo è successo questo:

Avevo sbagliato il numero di una label.
Bon! Nostalgia OFF!

La semplice funzione per generare la serie di Fibonacci può essere scritta in Go sfruttando le closure.

Fibonacci

Ne abbiamo parlato nel post precedente, ma la sequenza di Fibonacci ha ancora qualcosa da farci scoprire, almeno dal punto di vista del linguaggio di programmazione Go.

Avevano scritto la funzione che calcola l’ennesimo numero della serie a partire dalla definizione della serie: il numero successivo è la somma dei due numeri precedenti. Il codice è quindi il seguente:

package main

// ennesimo numero della serie di Fibonacci
func fibonacci(n int) int {
    var a, b int = 0, 1
    for i := 0; i < n-1; i++ {
        a, b = b, a+b
    }
    return a
}

func main() {
    for i := 1; i < 10; i++ {
        print(fibonacci(i), " ")
    }
    println()
}

Funzioni di prima classe

Quando le funzioni sono tipi di prima classe possono essere trattate come valori, dunque possono essere assegnate a variabili e restituite da una funzione.
Questa prerogativa dei linguaggi funzionali è presente in Lua ed anche in Go (quello che diremo vale indifferentemente per i due linguaggi). Per fare un esempio in Go, assegnamo una funzione ad una variabile per il calcolo della somma degli argomenti interi (ricordo che per provare il codice possiamo utilizzare il comodo servizio web Playground:

package main

func main() {
    add := func(a, b int) int {
        return a + b
    }
    println(add(4,5))
}

Assegnare una funzione ad una variabile significa creare una funzione anonima (senza nome) ma, rispetto alla definizione diretta, cambia solamente la semantica/sintassi del linguaggio ma non il risultato che è esattamente equivalente.

Un esempio con una funzione factory è il seguente dove rispetto ad un simbolo passato come argomento, una funzione restituisce la funzione dell’operazione corrispondente:

package main

func operation(op string) func(int, int) int {
    switch op {
    case "+":
        return func(a, b int) int {
            return a + b
        }
    case "-":
        return func(a, b int) int {
            return a - b
        }
    case "*":
        return func(a, b int) int {
            return a * b
        }
    case "/":
        return func(a, b int) int {
            return a / b
        }
    default:
        return nil
    }
}

func main() {
    add := operation("+")
    println(add(4, 5))
    molt := operation("*")
    println(molt(4, 5))
}

Closure

Quando una funzione di prima classe ha accesso alle variabili locali, le variabili che appartengono allo stesso scopo della funzione, viene chiamata closure.

Tornando a Fibonacci, poiché sono necessari due valori iniziali di innesco della serie, possiamo esprimerli con variabili locali di una closure:

package main

// fibonacci is a function that returns
// a function that returns an int
func fibonacci() func() int {
    a, b := 1, 0
    return func() int {
        a, b = b, a + b
        return a
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        println(f())
    }
}

Le variabili a e b interne alla funzione fibonacci() sono variabili che possono essere lette e scritte dalla funzione anonima, verificando il concetto di funzione closure.
A questo punto possiamo anche creare funzioni di Fibonacci a piacere definendo di volta in volta i primi due numeri della sequenza:

package main

// fibonacci is a function that returns
// a function that returns an int
func fibonacci(n1, n2 int) func() int {
    return func() int {
        n1, n2 = n2, n1 + n2
        return n1
    }
}

func main() {
    f1 := fibonacci(1, 0)
    for i := 0; i < 10; i++ {
        println(f1())
    }
    println()
    f2 := fibonacci(50, 17)
    for i := 0; i < 10; i++ {
        println(f2())
    }
}

Ed in Lua?

-- Lua version : - )
 
-- fibonacci is a function that returns
-- a function that returns an int
function fibonacci(n1, n2)
    return function()
        n1, n2 = n2, n1 + n2
        return n1
        end
end
 
f1 = fibonacci(1, 0)
for i=1,10 do
    print(f1())
end

print()
f2 = fibonacci(50, 17)
for i=1,10 do
    print(f2())
end

Insomma possiamo dire che i progettisti del Go hanno studiato in modo approfondito anche Lua e Python. O no?

Alla prossima…
Un saluto.
R.

L’altro giorno ha twittato questo:

L’URL è relativa a un pezzo del solito E.W. Dijkstra, in particolare Computing Science: Achievements and Challenges  dove ci sono tante idee. Roba che letto alla sera sul Kindle mi ha fornito incubi per tutta la notte.

OK, è vecchio, diciamo sui 15 anni, e racconta di cose ancora più vecchie, più di 60 anni. Parla dei primi linguaggi di programmazione: FORTRAN, LISP e ALGOL 60. E altre cose ancora, leggetelo.

Ora sono pochi i linguaggi attuali che non abbiano tracce di Algol nel loro DNA. Sul Lisp ci sarebbero troppe cose da dire (e di solito scappano tutti quando ne parlo) ma quello che mi ha colpito è il Fortran, io sono|ero un fortrainer.
I giovani danno per scontato che certe cose ci siano sempre state: falso! Anche cose semplici sono state grandi conquiste, per dirne una chi oggi perderebbe tempo per scrivere una funzione per l’ordinamento di un array?
Ma ci sono di mezzo anche le persone, gli umani con le loro convinzioni.

Tornando al Fortran questo aveva ambizioni molto limitate: velocizzare calcoli che fatti a mano avrebbero richiesto troppo tempo: un sistema di 3 equazioni in 3 incognite si risolve al volo, con 4 diventa impegnativo e poi se il numero aumenta come certe volte è richiesto molto oneroso. La macchina lo fa al volo (quasi, ma allora sembrava così). Ah! sì, le moltiplicazioni e le divisioni si facevano con il regolo (io so ancora usarlo).
Però con il Fortran non potevi fare tutto. E qui EWD racconta:

During an oral examination I had a student develop a program which we would now recognize as implementing pointer manipulations using a one-dimensional array. The candidate did very well until at the very end he got mysteriously stuck, neither of us understanding why. It turned out that he should have written down “a[a[i]]:= ….” but that mental block prevented him from conceiving that because FORTRAN (to which he had been exposed extensively) did not allow index expressions as complicated as “a[i]“. It was a revealing warning of the devious influence the tools we use may have on our thinking habits.

Ecco, anch’io mi sono bloccato su questo. Tant’è vero che voglio vedere cosa si può fare con 60 anni di ritardo e, purtroppo, senza il compilatore di allora.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

program edw0

implicit none
integer :: i, a(10) = [3, 4, 5, 6, 7, 8, 9, 10, 1, 2]

print *, 'inizio'
print '(10i3/)', a

i = 5
a(a(i)) = 42

print *, 'dopo'
print '(10i3/)', a

end

OK, funziona, come pensavo. C’è stata un’evoluzione anche nei compilatori.
Il problema piuttosto è un altro con questi pseudo-puntatori:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

program edw1

implicit none
integer :: i, j, a(10) = [3, 4, 5, 6, 7, 8, 9, 42, 1, 2]

print *, 'inizio'
print '(10i3/)', a

i = 2
j = 8
a(a(i)) = a(a(j))

print *, 'dopo'
print '(10i3/)', a

end

Notare come il quarto elemento dell’array sia 0, se il programma fosse più complesso probabilmente avremmo un valore casuale. Inoltre questo tipo di errori logici non vengono rilevati dal compilatore. Si sa i pointers sono delle brutte bestie, in Fortran non c’erano ma questo caso era tipico dei COMMON.

I vecchi direbbero subito che questo non è Fortran, non si scriveva così non solo nel IV ma nemmeno nel 77.
Ma intanto oggi quello che si faceva con il Fortran si fa con altre cose, per esempio Python.

OK, posso smettere quando voglio

Creeremo un programma per la generazione dei numeri di Fibonacci per poi entrare nel campo dell’esecuzione concorrente in Go.

Fibonacci

La sequenza di Fibonacci si genera sommando i precendenti due numeri della serie. Questa regola necessita di definire i primi due numeri e questi sono semplicemente assunti pari a 0 ed 1.
In Go il calcolo dell’ennesimo numero della sequenza può essere ottenuto con il codice seguente sfruttando direttamente la definizione della serie e l’assegnazione multipla (linea 8) tra l’altro disponibile anche nei linguaggi Lua e Python:

package main

// trova l'ennesimo numero della serie
// di Fibonacci
func fibonacci(n int) int {
    var a, b int = 0, 1
    for i := 0; i < n-1; i++ {
        a, b = b, a+b
    }
    return a
}

func main() {
    for i := 1; i < 10; i++ {
        print(fibonacci(i), " ")
    }
    println()
}

Calcoli indipendenti

Il supporto alla programmazione concorrente del Go è probabilmente — in un mondo multiprocessore — la principale caratteristica per la sua diffusione, e pensare che nel linguaggio vi sono pochissimi costrutti sintattici per implementarla (caso mai la semplicità fosse un vantaggio).
Li abbiamo visti già tutti all’opera su Ok, panico!, grazie ai post di Juhan .

Come forse avrete intuito, proveremo a calcolare molti numeri di Fibonacci in modo indipendente. Questa parola è importante perché la programmazione concorrente non è altro che un insieme di esecuzioni che si svolgono indipendentemente una dall’altra — come sottolinea Robert Pike. La distinzione è dovuta al fatto che ci si può sbagliare usando per questa modalità di esecuzione il termine parallelismo, che invece indica un insieme di esecuzioni che avvengono contemporamente. Nei moderni pc multicore, l’esecuzione concorrente può avvicinarsi al parallelismo.

Fibonacci independente

Un semplice schema per l’esecuzione concorrente di più funzioni di Fibonacci, è quello di avviarne l’esecuzione in una goroutine ed attenderne in quella principale i risultati provenienti da un canale.

Ecco il codice in cui si deve intendere che la funzione mancante fibonacci() sia quella del listato precedente:

func fibonacci(n int) int64 {
    // as before with int64 return value
}

var num = []int{50, 36, 80, 93, 66}

func main() {
    ans := make(chan int, len(num)) // buffered channel
    for _, f := range num {
        go func(f int) {
            ans <- fibonacci(f)
        }(f)
    }
    
    // stampo i risultati provenienti dal canale
    for i := 0; i < len(num); i++ {
        fib := <-ans
        fmt.Printf("Fibonacci(%d)=%d\n", num[i], fib)
    }
}

Nella funzione main() dopo aver creato un canale, avviamo tante goroutine quanti sono i numeri della serie da calcolare iterando sugli elementi di uno slice (num). Al termine del ciclo avremo nel nostro caso 5 goroutine in esecuzione indipendente da quella principale.
La prima diversità dalla programmazione classica è che l’istruzione go avvia una nuova linea di esecuzione senza attendere che questa termini. Quasi immediatamente raggiungiamo quindi il secondo ciclo for che preleva in sequenza i dati dal canale.

Questo schema è piuttosto semplice. Non conosciamo l’ordine con cui i dati arrivano e dobbiamo ricordarci che l’istruzione

        fib := <-ans

comporta il blocco dell’esecuzione della goroutine principale (quella in cui gira la funzione main()), che attende fino all’arrivo di un dato, assicurandoci che vengano attesi cinque valori dal canale altrimenti la funzione main() terminerà prima che le goroutine di calcolo abbiano portato a termine il lavoro.
La goroutine infatti non sanno niente di quello che stanno facendo le altre eventuali goroutine in esecuzione e se main() termina, termineranno forzatamente tutte.
Dal punto di vista della singola goroutine al termine del calcolo l’invio sul canale del risultato è immediato, essendo questo dotato di capacità pari al numero dei risultati che vi saranno inviati (buffered channel), altrimenti essa avrebbe dovuto attendere che la gorountine main() fosse pronta a ricevere un dato (sincronizzazione del mandante con il ricevente).

Per capire la concorrenza in Go conviene quindi immaginare il funzionamento delle cose in modo dinamico tenendo conto del blocco o meno dell’invio o della ricezione dei dati dai canali.

Prestazioni

Ho fatto alcune prove variando la quantità dei numeri da calcolare. Sulla mia macchina Linux dotata di un processore con un unico core, le prestazioni migliorano solo di alcuni punti percentuali, ed addirittura peggiorano quando crescono i numeri da calcolare in num.
Evidentemente il costo per la creazione delle goroutine — sia pure piccolo — non è compensato su una macchina ad un unico core da vantaggi particolari.
Oltre a capire sperimentando il codice, quello che importa adesso non sono le prestazioni ma che occorre considerare con precisione la natura del problema per poter scegliere o meno una soluzione a calcolo indipentente.

Si tratta di un argomento affascinante!

Difetto

Il codice precedente ha un difetto: è necessario attendere che tutte le goroutine siano state create e lanciate prima di passare a raccogliere i risultati. Per esempio se per creare una goroutine accorresse 1 millisecondo e ciascuna mediamente richiedesse 50ms di esecuzione concorrente, allora i risultati dovrebbero attendere stipati nel canale se le goroutine fossero circa più di 50.

La soluzione è quella di inserire il ciclo di creazione delle goroutine esso stesso all’interno di una goroutine:

func main() {
    // Use all the machine's cores
    runtime.GOMAXPROCS(runtime.NumCPU()) 
    res := make(chan int64)
    
    go func() {
        for _, f := range num {
            go func(f int) {
                res <- fibonacci(f)
            }(f)
        }
    }()
    
    for i := 0; i < len(num); i++ {
        <-res
    }
}

Altro simpatico esempio elegante

Questa volta spediamo sul canale la serie di Fibonacci da una goroutine separata basata su un ciclo for infinito (a terminare il programma sarà brutalmente il termine della funzione main() nella quale chiederemo la stampa dei primi dieci numeri della serie):

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func(a1, a2 int) {
        for {
            ch <- a1
            a1, a2 = a2, a1 + a2
        }
    }(0, 1)
    
    for i := 0; i<10; i++ {
        fmt.Print(<- ch, " ")
    }
    fmt.Println()
}

Sfida…

Invito i visitatori del blog a presentare nuovi schemi di calcolo concorrente o semplicemente solo i risultati ottenuti con i vostri megacalcolatori.

Quello che serve è una installazione di Go, e magari sapere che esistono comode funzioni nel pacchetto time che misurano con precisione il tempo macchina, come nel seguente esempio:

package main

import (
    "fmt"
    "math"
    "time"
)

func main() {
    multiPi := make([]float64, 10000)
    t := time.Now()
    for i := 0; i < 10000; i++ {
        multiPi[i] = math.Pi * float64(i)
    }
    fmt.Printf("Executin time: %v\n", time.Since(t))
}

Un saluto.
R.

Gli operatori logici (o booleani) consentono di stabilire se una cosa è vera o no. “Uno vale uno” (cit.), verifichiamo:

OK! Notare il doppio segno di uguale; siccome il segno di uguale lo usiamo per l’assegnazione, p.es. a = 5 per valutare l’uguaglianza lo raddoppiamo. Vediamo un altro caso:

vero, cioè falso, cioè 1 è diverso da 2

C’è poi l’operatore != (diverso), verifichiamo:

che, ovviamente restituisce l’opposto di == (uguale).

Adesso l’operatore > (maggiore):

e < (minore):

Ci sono poi >= (maggiore o uguale) e <= (minore o uguale):

Secondo Karthikeyan, I Love Ruby, ci sono altri due operatori logici che di solito non si trovano nei linguaggi di programmazione !< (non minore) e !> (non maggiore):

no! pare di no. Ma se ci pensate !< è un doppione di >=. E se usassimo un linguaggio serio questo operatore mancante, se proprio volessimo, lo potremmo implemtare al volo, prima di subito! (Sì, sto parlando di quello, il Lisp).

Un’ultima cosa: true e false sono costanti logiche (o booleane) predefinite. Per cui capita che:

Chiaro vero? L’ho capito anch’io: “true” e “false” sono stringhe; come lo sarebbero ‘true’ e ‘false’.

Siamo pronti per gli operatori di scelta, if, unless, case e simili, il prossimo post

I vip, gli insulti su Twitter, i troll e la gente comune che non è anonima
mitica Galatea!
::: IL nuovo mondo di Galatea

Twitter: servono nuove regole. No, abbiamo bisogno di cultura digitale
::: Valigia Blu

Samsung is hurting Android
::: Trusted Reviews

Mettiamo il turbo sburlo al nostro androide da 99 euri
::: il nido del Picchio

Android e i cambiamenti apportati al kernel Linux
avevo linkato l’originale poi ho visto il lavoro del Bl@ster
::: Bl@ster’s

Con una semplice modifica la Casa Bianca accelera sugli open data. E in Italia?
::: il Sole 24 Ore

Se SQLite vi sembra lento…
::: Robitex

Chiudere o non chiudere, questo è il problema!
::: My Social Web

Il Piccolo Libro di MongoDB
::: Nicola Iarocci

Archimede Smipper

Plotly automatically makes a beautiful graph
::: plotly

Go 1.1 is released
::: The Go Programming Language

tl;drLegal, le licenze Open Source spiegate semplicemente
::: LinuxBird

Terra
Terra is a new low-level system programming language that is designed to interoperate seamlessly with the Lua programming language
::: Terra ::: Lambda the Ultimate

Add Clippy or his friends to any website for instant nostalgia
::: Smore

Windows Kernel Developer Vents Out Against Microsoft; Says It Shuns Innovation
::: EFYTimes

How Mighty Mint became one of the most popular Linux distros
::: TechRadar

Why Go?
::: Nathan Youngman ::: Ars Technica

9 mesi di carcere per una pagina Facebook: abbiate paura
fondamentale il .mau.
::: tom’s ::: Il Fatto Quotidiano ::: voices

OpenGL 101: Drawing primitives – points, lines and triangles
::: Solarian Programmer

With Lucky Sort creators on board, Twitter is officially a data company
::: GigaOM

The $12 Gongkai Phone
::: bunnie:studios

Has Supercomputing Hit a Brick Wall?
::: Slashdot

Il futuro di Android e di Chrome OS
::: LinuxBird

Wikeleaks e il decreto Romani
::: Nicola D’Angelo

UNESCO to make its publications available free of charge as part of a new Open Access policy
::: UNESCO

Enseignement de l’informatique – rapport de l’académie des sciences
::: Le slow blog de Serge

So Long, Cinnamon: Cinnarch Linux is reborn as Antergos
::: PCWorld

Larry Page’s Vocal Cords Are Partially Paralyzed
::: Slashdot

Netactview: tenere sotto controllo la nostra connessioni di rete in Ubuntu Linux
::: lffl

Interpol filter scope creep: ASIC ordering unilateral website blocks
::: Delimiter

Georgia Tech and Udacity Partner for Online M.S. in Computer Science
dubbi: funziona?
::: Slashdot

Canadian Anti-Piracy Outfit Pirates Photos for its Website
::: TorrentFreak

Apple’s new Objective-C to Javascript Bridge
::: steamclock

8 Reasons Why Ubuntu Users Should Try Out Linux Mint
::: TechSource

Collusion, un add-on per scoprire chi ti traccia online
::: LinuxBird

Mappa del Made in Italy digitale
::: LinuxBird

[OS X] Creare USB live di qualsiasi distribuzione linux
::: ReefBits

Extreme syntax
leggere anche i commenti; tentato di farci un post noioso
::: The Endeavour

thread profiling in Python
::: idle thoughts

Patenting Open Source Software
::: Slashdot

Comunicazione e condivisione in tempo reale attraverso il web
::: LinuxBird

CommaFeed il nuovo aggregatore di feed open source
io adesso uso TheOldReader ma chissà…
::: lffl

Sorry, Larry Page: Tech-Industry Viciousness Is Here To Stay
::: Slashdot

Australian Government Backdoor Internet Filter Shuts Down 1,000 Websites
::: Slashdot

unixkcd
::: xkcd

How to Learn Emacs: A Hand-drawn One-pager for Beginners
::: Sacha Chua

[Editoriale] Skype è il nostro “Grande Fratello”?
::: lffl

perl 5.18.0 is now available!
::: perl.org

A Guide to Python’s Magic Methods
::: rafekettler

Electronics-Loving ‘Crazy Ants’ Invading Southern US
::: Slashdot

Using Definite Clause Grammars in SWI-Prolog
in un modo diverso?
::: Pathways

Arduino Branches Out, With a Plug-and-Program Robot
::: Slashdot

The Evolution Of Hacker News
::: TechCrunch

Il codice è commentato e semplicissimo (non cambia granché dalla puntata precedente) per cui eccolo, senza preamboli:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#!/usr/bin/newlisp

;; get state of CapsLock
(set 'clON (% (int (slice (string 
        (exec "xset q | grep LED")) -4 2)) 2))

;; get clipboard content
(set 'txt (join (exec "xsel -ob") "\n"))
;;  case translate
(if (= clON 1) 
    (set 'txt (upper-case txt))
    (set 'txt (lower-case txt)))

;; park in a temp file
(set 'tmpf "/tmp/Mm")
(write-file tmpf txt)

;; put the temp file it in the clipboard
(set 'cmd (join (list "cat " tmpf " | xsel -ib")))
(exec cmd)
(delete-file tmpf)

(exit)

Si potrebbe ancora modificarlo rendendolo più lispico ma poi si perderebbe la possibilità di confronto con la versione del passo successivo, questo che segue immediatamente.

Se a questo punto qualcuno ponesse la domanda “ma si deve fare con newLISP?” risponderei “certo che no! ecco la versione con Python”.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import subprocess, os

# stato di capslock
cmd = "xset q | grep LED"
ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
                      stderr=subprocess.STDOUT)
output = (ps.communicate()[0]).strip()
clON = int(output[-2:]) % 2

# contenuto della clipboard
cmd = "xsel -ob"
ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
txt = (ps.communicate()[0])

# converto
if clON:
    txt = txt.upper()
else:
    txt = txt.lower()

# lo parcheggio in un file temporaneo
tmpf = "/tmp/Mm"
f = open(tmpf, 'w')
f.write(txt)
f.close()

# copio il file nella clipboard
#cmd = "cat"
cmd = "cat {0} | xsel -ib".format(tmpf)
os.system(cmd) #, "", shell = True)
os.remove(tmpf)

Sono quasi equivalenti. Ecco un dump del test effettuato.

Sì newLISP converte anche le lettere non ASCII
Ma siccome è un’inutility il discorso, per me, si chiude qua

#!/usr/bin/ruby
puts "Ciao sono il 'puter"
print "come ti chiami:"
name = gets()
puts "Ciao #{name}Buona giornata!"

gets fa l’opposto di puts: invece di scrivere la stringa sul terminale legge quella che scriviamo.

Naturalmente la quinta riga potevamo scriverla anche come: puts "Hello " + name + " Buona giornata!"

Due cose:

• notare l’a-capo anomalo prima di "Buona giornata", sarà da indagare in futuro;
• solo per chi usa Linux la prima riga è speciale, permette di rendere lo script eseguibile in questo modo:

In Windows non esiste l’equivalente e la riga viene considerata come un commento, come in realtà è.

Già, i commenti. Tranne dentro le stringhe “” come nel caso precedente Ruby considera il carattere # e tutto quello che segue fino alla fine della riga come un commento, serve a noi ed è ignorato dall’interprete, come in questo caso:

#!/usr/bin/ruby

# esempio (scemo) di commenti
v1 = 5 # primo dato
v2 = 7 # secondo
res = v1 + v2 # somma
print "la somma di #{v1} + #{v2} vale #{res} #sapevatelo\n"

Qui vediamo diversi tipi di commenti:

• la prima riga, speciale di cui abbiamo già detto (è talmente speciale che ha un nome, shebang);
• la terza riga, tutta di commento;
• le righe 4, 5 e 6 con un’istruzione e poi un commento;

Notare che il carattere # nell’ultima riga non è un commento. Anche le righe vuote, come la seconda vengono ignorate dall’interprete, proprio come i commenti.

Alle volte il commento che vogliamo scrivere è troppo lungo per una riga sola. In questo caso possiamo fare così:

#!/usr/bin/ruby

=begin
    esempio (scemo) di commento multilinea
    è tutto un commento fino a quando lo
    chiudiamo con la keyword che segue
=end
v1 = 5 # primo dato
v2 = 7 # secondo
res = v1 * v2 # prodotto
print "il prodotto di #{v1} * #{v2} vale #{res} #sapevatelo\n"

Quando la lunghezza dello script supera poche righe questo tipo di commenti diventano molto utili, non immaginate quanto. Notare che le keyword =begin e =end devono cominciare in prima colonna, niente spazi.

Compito a casa: cosa succede se metto un commento multilinea dentro a un commento multilinea?

Programmez votre Raspberry Pi depuis le confort de votre navigateur Web – et en JavaScript!
::: FinuxFr

Bruce Schneier: Why Collecting More Data Doesn’t Increase Safety
::: Slashdot

Know Thy Complexities!
::: Big-O

La nuova sfida: educare chi va sul web
::: la Stampa ::: OLMR ::: Luca De Biase ::: Nicola D’Angelo ::: manteblog ::: manteblog

Terms of Service; Didn’t Read
::: Term of Service

Making UEFI Secure Boot Work With Open Platforms
::: The Linux Foundation

BitTorrent Sync, prova su strada
::: ReefBits

Ramanujan approximation for circumference of an ellipse
::: The Endeavour

Casa domotica controllata da Android, anche con i comandi vocali di Google Now
::: Tutto Android

Big Data: la mia rubrica su Europa – L’illusione del potere della rete
::: Vincos

Signs that you’re a bad programmer
::: Software Engineering Tips

elementary OS Luna Beta 2 Rilasciata, le novità e download
::: lffl

Iniziative per domani. Da conoscere oggi. Innovazione, impresa, startup, informazione, diritti
::: Luca De Biase

How to be effective at open source: by programmers, for programmers
::: Daniel Lemire

Prenda hammered: Judge sends porn-trolling lawyers to criminal investigators
::: Ars Technica

U.S. Directly Blames China’s Military for Cyberattacks
::: The New York Times ::: Slashdot

Full Circle Magazine: script per scaricare facilmente tutti i numeri della rivista
::: lffl

Microsoft prepares U-turn on Windows 8
::: Financial Times

LibreCAD lavora ad un proprio DWG importer
::: LinuxBird

La Nasa fait migrer les ordinateurs de la Station spatiale internationale vers Linux
::: ZDNet ::: ZDNet ::: tom’s

How the Syrian Electronic Army Hacked The Onion
::: The Onion

Minesweeper in Matplotlib
::: Pythonic Perambulations

Debian Will Serve As The Default OS For Google Compute Engine
::: TechCrunch

New Zealand Set To Prohibit Software Patents
::: Slashdot

Israeli Singer Publishes a Song In Hebrew — and Perl
::: Slashdot

Obama Announces Open Data Policy With Executive Order
::: Slashdot

World of Warcraft Loses 1.3 Million Players in First Quarter of 2013
::: Slashdot

Una pagina web per ogni libro pubblicato
::: LinuxBird

La più grande biblioteca del mondo
::: Nicola D’Angelo

Turista fai-da-te? Niente paura c’è openMarkers
::: LinuxBird

Mentana e le autostrade percepite
::: manteblog

What’s New in Scratch 2.0?
::: Scratch

Primers
se ho capito bene un corso di matematica con Python dentro
::: Math ∩ Programming

Facebook Home, quando 1mln di dowload è poco
::: LinuxBird

Boston Replacing Microsoft Exchange With Google Apps
::: Slashdot

Return of the Borg: How Twitter Rebuilt Google’s Secret Weapon
::: wired

Facebook Is Getting Serious About Original Programming With “Facebook Live”
adesso la TV!
::: TechCrunch

How Should the Law Think About Robots?
::: Slashdot

Nicolargo. Livraison de socca. Pizza hut n’a inventé rien

Appeals court ruling could be ‘death’ of software patents
::: Network World

Elon Musk quits Zuckerberg’s immigration advocacy group
::: Reuters

sito di gedit

Io lo uso solo quando devo, ma capita più spesso di quanto vorrei
No non sto parlando di gedit, si tratta di Windows.

OK, tutto ciò premesso c’è una bella novità. Una cosa che magari tutti conoscono già (tutti tranne me e i miei amici). E poi forse si tratta di una notizia che non interessa, chi è che usa ancora documenti di testo, i .txt; o crea script con Python, Ruby o roba simile?
Comunque qualcuno c’è, un paio li conosco personalmente. E allora la bella notizia è che gedit c’è anche per Windows, qui: gedit win32 binary.

Trovate il solito setup.exe che s’installa in un attimo, senza problemi.

Resta solo da configurare, aprire Preferenze dal menu Modifica. Ci sono diversi tab, tutti da controllare.
E non dimenticate quello dei Plugin come ho fatto io recentemente

Tra i vantaggi c’è anche la syntax hilighting per millemila tipi di documenti (stavo per scrivere file).