Newsgroup: it.comp.os.linux.development
Titolo: FAQ di it.comp.os.linux.development

			    _________   ____
			   / ____/   | / __ \
			  / /_  / /| |/ / / /
			 / __/ / ___ / /_/ /
			/_/   /_/  |_\___\_\
		newsgroup it.comp.os.linux.development
		      mantainer: Ottavio Campana
Ultimo aggiornamento: 4 gennaio 2006
Sezione 1: Domande generali.
1.1 Quali linguaggi sono disponibili per sviluppare sotto linux?
1.2 Quali sono gli IDE disponibili per i vari linguaggi?
1.3 Ho creato  il mio  primo  programma  in Linux,  ma quando  lo eseguo
    ottengo "command not found".
1.4 Perché   è  sconsigliato   includere  la  directory  corrente  nella
    variabile d'ambiente PATH?
1.5 Ma scrivere "./nomeprogramma" non è equivalente a "nomeprogramma"?
1.6 Esiste Visual Basic per linux?
1.7 E Delphi?
1.8 Come faccio a fare le parentesi { } ?
1.9 Come faccio a creare un cd live?
1.10 Quanto veloce va il mio programma?
Sezione 2: Compilatore e makefiles.
2.1 Come posso compilare un programma C/C++?
2.2 Il  mio programma è suddiviso  su più file, come  posso creare degli
    object e poi linkarli in un unico esegubile?
2.3 Cosa vuol dire "undefined reference to ..."?
2.4 Se volessi imparare ad usare gli autotools?
Sezione 3: Applicazioni grafiche
3.1 Desidero  fare un programma  con finestre e pulsanti,  che strumenti
    devo usare?
3.2 E per fare un programma "multimediale"?
3.3 Programmare con la xlib.
Sezione 4: Programmazione di rete
4.1 Come implemento un timeout nella lettura da socket?
4.2 C'è un piccolo tutorial?
Sezione 5: Dubbi sulle licenze opensource
5.1 Come posso distribuire il mio programma se usa librerie lgpl?
5.2 Voglio vendere il mio software, allora non uso librerie gpl.
Sezione 6: Documentazione on line
6.1 Dove trovo una versione aggiornata di queste faq?
6.2 Documenti generali
6.3 Bash
6.4 Programmazione di rete
6.5 Usare seriali e parallele
Sezione 7: Varie ed eventuali su questa faq
7.1 Come ottenere la versione html aggiornata delle faq
------------------------------------------------------------------------
Sezione 1: Domande generali.
1.1 Quali linguaggi sono disponibili per sviluppare sotto linux?
Praticamente tutti. C/C++, Java, Perl,  Pascal, Ruby, Python, PHP, Kylix
(Delphi) e molti altri ancora. Molti  programmi in Linux sono scritti in
C/C++,  tuttavia in  questi ultimi  anni  si stanno  affermando anche  i
linguaggi interpretati come Ruby o  Python. La scelta ovviamente dipende
molto da cosa si intende sviluppare.
1.2 Quali sono gli IDE disponibili per i vari linguaggi?
Tra  gli IDE  più  "trendy"  del momento  ci  sono  senz'altro Anjuta  e
KDevelop, tuttavia non è da  sottovalutare l'uso di semplici editor come
gvim o emacs che hanno un  ottimo interfacciamento con i compilatori più
diffusi.
1.3 Ho creato  il mio  primo  programma  in Linux,  ma quando  lo eseguo
    ottengo "command not found".
In  Linux, se  non ne  viene  esplicitamente indicato  il percorso,  gli
eseguibili vengono  cercati nelle directory specificate  dalla variabile
d'ambiente PATH. Solitamente il PATH  non include la directory corrente,
quindi devi lanciare il  programma con ./nomeprogramma oppure modificare
il PATH  affinché includa la  directory corrente, ma questo  è altamente
sconsigliato.
1.4 Perché   è  sconsigliato   includere  la  directory  corrente  nella
    variabile d'ambiente PATH?
Perché si  rischia di  eseguire accidentalmente un  programma pericoloso
che si  trova nella directory corrente  magari al posto del  suo omonimo
"buono" che si trova in una  directory fidata (come /bin, /usr/bin etc.)
E' opportuno che nel PATH siano inclusi solo programmi "fidati".
1.5 Ma scrivere "./nomeprogramma" non è equivalente a "nomeprogramma"?
Dal punto di vista del filesystem si,  ma poiché la seconda potrebbe far
intendere che "nomeprogramma" sia nel  PATH, esso viene eseguito solo se
si trova effettivamente in una delle directory nel PATH.
Invece   scrivere  "./nomeprogramma"   evita  questa   ambiguità  perché
specifica esplicitamente la  directory in cui si trova il  file e quindi
viene eseguito anche se non si trova nelle directory in PATH.
1.6 Esiste Visual Basic per linux?
Grazie   al   cielo  no.   Tuttavia   dovrebbe   possibile  usare   Mono
(
http://www.go-mono.org
)   per   compilare    il   codice   scritto   in
VisualBasic.Net (il compilatore  CIL e le librerie  grafiche sono ancora
in alfa). E' inoltre disponibile Gambas (
http://gambas.sourceforge.net
),
che è simile ma non uguale al Visual Basic.
1.7 E Delphi?
In passato Borland  ha rilasciato Kyilix, un ambiente  di sviluppo misto
C++/Delphi che  permetteva lo  sviluppo di applicazioni  utilizzando uno
dei due linguaggi supportati. Purtroppo,  a causa di scelte commerciali,
Kyilix e` stato  abbandonato. Nel frattempo, pero`, in  seno al progetto
FreePascal, e` stata creato l'ambiente  di sviluppo Lazarus, che ricalca
il funzionamento dell'ambiente di sviluppo di Delphi per windows.
1.8 Come faccio a fare le parentesi { } ?
In ambiente grafico:
{ -> AltGr+7
} -> AltGr+0
In console:
{ -> AltGr+8
} -> AltGr+9
1.9 Come faccio a creare un cd live?
Non   è   una   cosa   difficile,    soprattutto   se   si   usano   gli
strumenti   giusti.    Se   
freshmeat.net
   si   trova    il   programma
bblcd,   altrimenti   questo    documento   può   essere   interessante:
http://am.xs4all.nl/phpwiki/index.php/MainModuleHowto
 .
1.10 Quanto veloce va il mio programma?
Per misurare  le prestazioni del  proprio programma  ci sono un  paio di
programmi che possono essere utili. Il  primo si chiama gprof e richiede
che i programmi vengano compilati con  i flag -pg e -fprofile-arcs. Dopo
la prima esecuzione  pro programma viene generato un file  gmon.out e se
lanciate quindi gprof  nomefile vedrete il profiling  delle funzioni del
programma.
Il secondo programma disponibile si chiama Oprofile ed è repreribile nel
sito  
http://oprofile.sourceforge.net/news/
 .  Questo programma  è molto
più complesso  del precedente,  richiede anche  che vengan  compilati di
moduli per il kernel e le  possibilità di analisi richiedono una attenta
lettura della documentazione.
Sezione 2: Compilatore e makefiles.
2.1 Come posso compilare un programma C/C++?
Per il C: gcc nomesorgente.c -o nome_dell'eseguibile
Per il C++ g++ nomesorgente.cpp -o nome_dell'eseguibile
2.2 Il  mio programma è suddiviso  su più file, come  posso creare degli
    object e poi linkarli in un unico esegubile?
Per  fare  questo devi  compilare  i  signoli  file con  gcc/g++  usando
l'opzione -c che crea, per l'appunto, un object. Il link viene fatto dal
comando ld,  o più banalmente si  può sempre usare gcc  che provvedere a
richiamare ld. L'automatizzazione del tutto è possibile ricorrendo ad un
Makefile.  Supponendo  di  avere  un programma  organizzato  in due file 
primo.c e secondo.c allora lanciando i comandi:
    gcc -c primo.c -o primo.o
    gcc -c secondo.c -o secondo.o
    gcc primo.o secondo.o -o programma
si otterrà un binario chiamato programma.
2.3 Cosa vuol dire "undefined reference to ..."?
Una  o più  librerie  necessarie per  il tuo  programma  non sono  state
indicate  sulla riga  di comando  di gcc  (o ld).  Per fare  questo devi
utilizzare  lo switch  -l.  Per convenzione  le  librerie sono  chiamate
libnome.so , se sono dinamiche, oppure libnome.a , se sono statiche. Per
linkarle dinamicamente  al tuo eseguibile  devi passare a  gcc l'opzione
-lnome  (senza  il prefisso  "lib" né il  suffisso ".so").  Per linkarle
staticamente devi invece linkare il file libnome.a all'eseguibile. Se le
librerie non si trovavano nel path  di ricerca (man ld.so) gcc non sara`
in grado  di trovarle. Per  aggiungere una  diretory al path  di ricerca
devi usare lo switch -L (es: -L/home/foobar/mylibdir).
2.4 Se volessi imparare ad usare gli autotools?
Un  buon modo  per  cominciare  è leggere  l'autobook,  che  è un  libro
che  spiega  appunto  come  usare  gli  autotools.  Lo  si  può  trovare
all'indirizzo  
http://sources.redhat.com/autobook
 e  in  debian è  stato
messo nel pacchetto autobook .
Sezione 3: Applicazioni grafiche
3.1 Desidero  fare un programma  con finestre e pulsanti,  che strumenti
    devo usare?
Esistono molte  librerie che facilitano  questo compito, le più  in voga
sono  senz'altro le  GTK+  (sito  
http://www.gtk.org/
 )  e  le QT  (sito
http://www.trolltech.com/
 )  . Sulle gtk  si basa il framework  di gnome
(sito 
http://developer.gnome.org/
 ) mentre sulle qt si basa kde. Tra gli
altri toolkit disponibili ci sono i wxWidgets.
3.2 E per fare un programma "multimediale"?
Le  librerie  SDL   (
http://www.libsdl.org
),  abbastanza  sofisticate  e
multipiattaforma,  consentono  anche  la  gestione  dell'audio  e  altre
periferiche.
Un'altra     possibilità     è      data     dalle     librerie     SVGA
(
http://www.svgalib.org
), forse più leggere ma più limitate.
3.3 Programmare con la xlib.
Ci sono un po' di  link carini alla documentazione, tuttavia ricordatevi
che  per  fare  programmi  grafici  sotto unix  in  generale  non  serve
programmare direttamente con la xlib. Vi servirebbe piuttosto se voleste
realizzare un vostro toolkit. I link sono:
http://x.holovko.ru/
http://tronche.com/gui/x/xlib/function-index.html
http://users.actcom.co.il/~choo/lupg/tutorials/xlib-programming/
http://www.cs.rit.edu/usr/local/doc/X11R6.4/X11/xlib.PS
Sezione 4: Programmazione di rete
4.1 Come implemento un timeout nella lettura da socket?
Si  deve usare  la funzione  select. Eccone  un esempio  (il che  non vi
esclude dall'obbligo dalla lettura della manpage della select):
#include <stdlib.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int socket;
int server;
struct timeval timeout;
fd_set read_set;
int ret;
/* Suppongo che il socket /server/ sia in ascolto su una data porta */
socket = accept(server, NULL, 0);
if (socket == -1) {
        perror("accept()");
        exit(EXIT_FAILURE);
}
/* Aggiungo /socket/ al set di file descriptors che verra` monitorato
 * dalla select
 */
FD_ZERO(&read_set);
FD_SET(socket, &read_set);
/* Timeout dopo 10.5 secondi */
timeout.tv_sec = 10;
timeout.tv_usec = 500000;
ret = select(socket + 1, &read_set, NULL, NULL, &timeout);
if (ret == -1) {
        perror("select()");
        exit(EXIT_FAILURE);
} else if (ret) {
        /* Ci sono dati disponibili, posso iniziare una lettura */
} else {
        /* Timeout: Nessun dato disponibile entro 10.5 secondi. Il
         * programma agisce di conseguenza (eg. chiude il socket).
         */
}
Nota bene: se il codice viene inserito in un loop la struttura timeout e
il set di  fd *devono* essere re-inizializzati prima di  ogni chiamata a
select.
4.2 C'è un piccolo tutorial?
Di   libri  e   documentazione  internet   è  piena,   basta  avere   la
pazienza  di  cercare.   Comunque  se  uno  è  pigro   e  vuole  leggere
qualcosa  in  italiano  un  punto   di  partenza  può  essere  la  guida
"network  programming"  scritta  da Foobar  e  reperibile  all'indirizzo
http://digilander.libero.it/foobar/papers/index.html
  .   Altrimenti  un
altro sito  interessante è  quello del defunto  W. R.  Stevens, l'autore
di  Unix   Network  Programming  e  TCP/IP   Illustrated,  all'indirizzo
http://www.kohala.com/start/
 , dove si trova molto materiale.
Sezione 5: Dubbi sulle licenze opensource
5.1 Come posso distribuire il mio programma se usa librerie lgpl?
Il punto 6 della licenza lgpl parla dei lavori proprietari che si basano
sull'uso di  librerie lgpl con per  esempio la libc. In  questo caso chi
vende il prodotto deve:
1)  rilasciare  pubblicamente  sotto licenza  lgpl  eventuali  modifiche
apportate alle librerie lgpl usate.
2)  rilasciare  i file  oggetto  ottenuti  durante la  compilazione  del
programma affinché  l'utente possa linkarli con  versioni più aggiornate
della  libreria. La  distribuzione  dei file  .o  deve essere  garantita
all'utente al mero costo del supporto per almeno tre anni.
3) se non  si vogliono rilasciare i  file .o , l'unica  cosa possibile è
l'implementazione  da parte  dell'autore  di un  sistema di  caricamento
dinamico di tutte le informazioni e  di tutte le funzioni della libreria
invece  di  includere direttamente  la  libreria  e  i suoi  header  nel
progetto.  Questo vuol  dire  che non  si possono  includere  i file  di
intestazione delle  librerie gpl  nei programmi  closed source  ma vanno
riscritti  e inoltre  non si  può usare  direttamente il  meccanismo del
linking dinamico del  compilatore ma si devono creare  delle funzioni ad
hoc che implementino il caricamento  dinamico delle librerie. Per questo
scopo c'è la  funzione dlopen, ma quella fornita dalla  libreria c della
gnu è sotto licenza lgpl anch'essa e deve quindi essere reimplementata.
5.2 Voglio vendere il mio software, allora non uso librerie gpl.
Questo  è un  ragionamento  poco  furbo. Per  prima  cosa ricordate  che
comunque se  usate librerie sotto  licenza lgpl siete comunque  tenuti a
rispettare tutti i vincoli elencati nella domanda precedente. Inoltre ci
sono alcune considerazioni da non sottovalutare:
1) se il programma è scritto  in un linguaggio interpretato, per esempio
in python  che è molto  comodo per  scrivere assieme alle  gtk programmi
facilmente portabili  su più sistemi  operativi, non si può  chiudere il
sorgente. Quindi tutti  gli sviluppatori che temono il  furto del codice
devono usare linguaggi di programmazione compilati.
2) è  molto improbabile  che un  vostro cliente si  metta a  rivendere i
programmi  che ha  acquistato da  voi a  meno che  non abbia  acquistato
qualcosa di banale come "il ricettario di nonna amelia".
3)  perché  un  potenziale  cliente  della ditta  al  punto  2  dovrebbe
scegliere di  acquistare il software  da tale ditta piuttosto  che dallo
sviluppatore che  può fornire  un supporto  e una  personalizzazione del
software migliore?
4) nell'ipotesi  che  il cliente al punto 3 decida  di farvi concorrenza
col vostro software  ricordati che anche egli è  vincolato dalla licenza
gpl.
Detto questo  ognuno è  libero di scegliere  la licenza  che preferisce,
sebbene  rinunciare a  tutte le  librerie  può non  sempre rivelarsi  la
scelta più furba.
Sezione 6: Documentazione on line
6.1 Dove trovo una versione aggiornata di queste faq?
Queste faq vengono  postate all'incirca una volta al mese  su usenet, in
base  ad  eventuali  aggiornamenti  delle  stesse  e  mie  dimenticanze.
Sono  pubblicate   sul  web   nel  mio  sito   personale,  all'indirizzo
http://www.campana.vi.it/ottavio/Linux/faq-icold.txt
6.2 Documenti generali
Appunti di Informatica Libera 
http://a2.swlibero.org
Guida alla programmazione in linux 
http://gapil.firenze.linux.it/
6.3 Bash
Bash Advanced Scripting Guide 
http://www.tldp.org/guides.html
  mentre in
italiano è disponibile il documento 
http://digilander.libero.it/bash/
6.4 Programmazione di rete
Network Programming 
http://digilander.libero.it/foobar/papers/index.html
6.5 Usare seriali e parallele
Per    comunicare    con    la     porta    parallela    puoi    cercare
a   partire    da   qui:    
http://people.redhat.com/twaugh/parport/
   e
http://www.torque.net/linux-pp.html
.
Per  comunicare con  la porta  seriale puoi  cercare a  partire da  qui:
http://www.tldp.org/HOWTO/Serial-Programming-HOWTO/
  e leggere il Serial 
Programming Guide for POSIX Operating Systems, disponibile all'indirizzo
http://www.easysw.com/~mike/serial/
Sezione 7: Varie ed eventuali su questa faq
7.1 Come ottenere la versione html aggiornata delle faq
Probabilmente non è una cosa esistenziale,  ma mi è stato passato questo
bello script  in python da Alessandro  Staltari che da solo  scarica dal
web la  versione txt delle faq  e ci aggiunge  i tag html. E'  una bella
idea,  furba e  utile e  lo riporto,  per tutti  coloro che  vogliono la
versione html aggiornata e per tutti quelli che vogliono vedere un pezzo
di codice python:
######################### inizio file faq.py ###########################
import urllib
import re
 
output="""
<HTML>
<HEAD>
<TITLE>FAQ</TITLE>
</HEAD>
<BODY><PRE>
"""
f=urllib.urlopen("
http://www.campana.vi.it/ottavio/Linux/faq-icold.txt
")
input=f.read()
f.close()
 
i=0
firstid=""
tmp=input.replace(">","&gt")
input=tmp.replace("<","&lt")
questionid=re.compile(r"^([0-9.]+) +[^\n]+\n", re.MULTILINE)
continuation=re.compile(r"^[ \t]+.+\n")
m=questionid.search(input[i:])
while (m != None):
    output=output+input[i:i+m.start()]
    if (firstid!="#"):
        output=output+'<A href="#'+m.group(1)+'" name="'+m.group(1)+'top">'
    else:
        output=output+'<A href="#'+m.group(1)+'top" name="'+m.group(1)+'">'
    if firstid=="":
        firstid=m.group(1)
    else:
        if m.group(1)==firstid:
            firstid="#"
    output=output+m.group(0)
    i=i+m.end()
    m=continuation.search(input[i:])
    while m != None:
        output=output+m.group(0)
        i=i+m.end()
        m=continuation.search(input[i:])
    output=output+'</A>'
    m=questionid.search(input[i:])
output=output+input[i:]
output=output+"</PRE></BODY>"
f=open(r"faq-icold.html", "w")
f.write(output)
f.close()
########################## fine file faq.py ############################
Stesso programma in ruby, contribuito da Gabriele Renzi:
######################## inizio file faq.ruby ##########################
require 'open-uri'
intestazione="<HTML><HEAD><TITLE>FAQ</TITLE></HEAD><BODY><PRE>"
input=open("
http://www.campana.vi.it/ottavio/Linux/faq-icold.txt
").read
# gsub effettua una. il ! indica che fa side effect,
# come in scheme (sostituisce in place)
input.gsub!("<","&lt;")
input.gsub!(">","&gt;")
# La regex della domanda, con questa rgx
# Becchiamo pure le domande spezzate in due linee, se sono indentate
domanda =/^(\d+\.\d+)(.*\n)?(    .*\n)?/
# Usiamo un hash per tener traccia delle domande
Trovata={}
# Ogni elemento che corrisponde alla regexp viene passato al blocco.
# Se non esiste nell'hash creiamo un link verso il basso,
# se ne abbiamo gia' trovato uno lo creiamo verso l'alto.
input.gsub!(domanda) do |str|
  if not Trovata[$1]
   Trovata[$1]=true
   '<a href="#'+$1+'" name="#'+$1+'top" >'+str+'</a>'
  else
   '<a href="#'+$1+'top" name="#'+$1+'" >'+str+'</a>'
  end
end
open('faq-icold.html','w+').print intestazione,input,'<pre>'
########################### fine file faq.ruby #########################

Questo link non è più disponibile



hai ragione. appena ho un buco ti tempo sistemo le faq.

Ottavio Campana ha scritto:

Perchè non ci metti questo documento nelle faq?
http://www.lilik.it/~mirko/gapil/gapil.html
È un'ottima guida, scritta da Simone Piccardi, del Flug.
È disponibile anche in versione PDF o PS qui:
http://gapil.truelite.it/download.html
Non tratta solo programmazione di rete, ma di programmazione su Linux
in generale, è in italiano ed è disponibile sotto licenza gpl
Ciao