Newsgroup: it.comp.os.linux.development
Titolo: linguaggio ad alto livello

 ManuaLinux: manuale di base in italiano by Panther

 come lo strutturo?  hai qualche riferimento da leggere a riguardo
Purtroppo no, quel che ho imparato l'ho imparato rifinendo (o
stravolgendo) un design dopo l'altro.  Sicuramente il design di
applicazione e` un tema su cui piacerebbe anche a me trovare del
materiale.
Massimiliano

 hai qualche riferimento da leggere a riguardo
Procurati un testo di Ingegneria del software. Preparati a sfrondare da una
marea di cose di inutilita' palese.
Per iniziare potresti vedere di imparare i DFD e UML.
-- 
  Giuseppe "Cowo" Corbelli \/\ My software: 
http://yoda.ing.unibs.it/~cowo
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
  -<! *Real* programmers use cat > a.out! No way, /real/ ones
        use zcat > a.out 'cause you can type faster that way. !>-
                -- from a Slashdot discussion

 oppure hai fatto qualcosa di diverso?
L'ho scritto senza interfacce utente, quindi neppure la linea di
comando.  
L'oggetto Client (in client.rb) contiene i metodi per comunicare con
l'oggetto Server (che e` remoto, ma non fa differenza nel nostro
discorso).
L'oggetto Controller (in controller.rb) e` il collante del sistema:
- accetta come dati di inizializzazione un nome utente, la uri del
server, e la classe dell'interfaccia utente (GUI, TUI o CLI);
- crea un Client con il nome dato e un'interfaccia con la classe data;
- fa da proxy per il Client, in modo che se chiamo sul controller un
metodo che questo non possiede, la richiesta e` rigirata al Client
(Controller#method_missing);
- avvia l'event loop dell'interfaccia (UI#event_loop in
Controller#run);
Le interfacce ereditano tutte dalla classe astratta UI, i metodi
importanti sono event(), update(), e build_ui().
- UI#event(nome_evento, dati_evento) e` chiamato dal Controller per
comunicare un evento agli elementi di interfaccia:
class GUI < UI
  def event(event_name, *args)
    case event_name
    when SERVER_USER_LOGIN
      @wnd.main.refresh_user_list
    when CLIENT_RECEIVE_MESSAGE
      @wnd_main.append(message)
      @wnd_incoming.show_message(message)
    end
  end
end
(Per chiarezza, l'esempio sopra e` sfrondato di pezzi importanti ma
secondari per cio` di cui stiamo parlando.)
- UI#update(nome_evento, dati_evento) e` chiamato dagli elementi di
interfaccia per comunicare un evento al controller o ad altri elementi
di interfaccia.
class GUI < UI
  def update(event_name, *args)
    case event_name
    when "select_message"  
      @wnd_incoming.show_message(messaggio_selezionato)
    when "send_message"
      @controller.say(testo, destinatari)
    end
  end
end
- UI#build_ui provvede a creare gli elementi di interfaccia.  Questi
*non* sono direttamente i widget di un dato toolkit, ma encapsulazione
degli stessi secondo un'interfaccia uniforme e ad alto livello.
Esempio pratico: diciamo di voler creare una finestra principale,
mostrarla, e impostare il titolo sulla barra principale.  Nel toolkit
A avremo:
window = A::Window.new(WINDOW_TOP)
window.set_title = 'My title'
window.visible = true
Nel toolkit B avremo:
window = B::Window.new(0,0,100,100)
window.title = 'My title'
window.show
Allora creiamo due classi, una per ciascun toolkit, che rappresentino
entrambe la finestra principale.  Quel che avranno in comune sara` la
loro interfaccia nei confronti del codice che le chiama.  Proseguendo
l'esempio:
(file interfaccia_toolkit_a.rb)
require 'a_bindings'
module Window
  class Main < A::Window
    def initialize(some_title)
      super(WINDOW_TOP)
      set_title(some_title)
    end
    def show
      window.visible = true
    end
  end
end
(file interfaccia_toolkit_b.rb)
require 'b_bindings'
module Window
  class Main < B::Window
    def initialize(some_title)
      super(0,0,100,100)
      self.title = 'My title'
    end
    def show
      show
    end
  end
end
In questo modo, puoi usare indistintamente l'uno o l'altro toolkit,
semplicemente caricando interfaccia_toolkit_a.rb o
interfaccia_toolkit_b.rb all'inizio.  Il modo per creare la finestra
sara` in ogni caso questo:
window = Window::Main.new('some title')
window.show
Anche gli eventi generati da questi astratti elementi di interfaccia,
devono essere astratti, ovvero non riceverai l'evento "bottone
premuto" ma l'evento "richiesto il salvataggio del file", perche' uno
stesso evento potra` essere generato da widget diversi in interfacce
diverse (una voce di menu, un bottone, una combinazione di tasti).
Per dirla in altre parole, gli elementi astratti di interfaccia
*interpretano* il significato degli eventi utente (pressione del
bottone, scelta nel menu) e ne comunicano al controller il
*significato*.  Il controller non sa nulla di cio` che ha generato
l'evento: potrebbe anche essere stato uno script.
(Se cominci a intravvedere l'attinenza di tutto questo con NetCAD, sei
sulla strada giusta. ;-) )
Massimiliano


 comando.  
...dopodiche' ho scritto l'interfaccia utente.  Meglio precisare. :-)
Massimiliano

sulla strada giusta. ;-) )
Beh in effetti più ci pensi e più mi pare figo. ;)
-- 
  _  _ >>Now on Linux<<  _     || ICQ number.................Non lo uso
 | \| |___ _____ ___ ___|_|___ || Home-Page ................Non ce l'ho
 | .` | -_|     | -_|_ -| |_ -||| E-Mail................Non l'avrai mai
 |_|\_|___|_|_|_|___|___|_|___||| Un Nemesis che ha pochi e-contatti ;)

Massimiliano Mirra ha scritto : 

Vabbuò in qualche modo si doveva pur utilizzare ;)


Massimiliano Mirra ha scritto : 

Visto che ci siamo... stavo leggendo il libro "Programming Ruby" preso
da 
www.rubycentral.com
, tuttavia non mi piace molto, è un pò troppo
confusionario, e a volte va troppo in profondità altre si ferma un pò
troppo sul vago. Vorrei sapere se è possibile trovare on-line un libro
o almeno un tutorial che mi introduca al linguaggio in modo graduale, un
pò come avviene in Thinking in C++ di Bruce Eckel, il quale introduce 
gradualmente tanto la sintassi che le feature del C++.


 gradualmente tanto la sintassi che le feature del C++.
Forse non sono la persona adatta a rispondere a questa domanda.  
Avevo iniziato a leggere Thinking in C++ ma, visto che prima di
combinare qualcosa di concreto mi sarei dovuto sciroppare *tutto* il
materiale sulle stringhe, ho lasciato perdere.  Quindi non lo ricordo
esattamente come ``graduale''. ;-)
Una guida piu` classica di Programming Ruby puoi scaricarla da
www.ruby-lang.org/~slagell/ruby/ruby-uguide-20010216.tar.gz
 (html) o
www.ruby-lang.org/en/pdf-doc/rubyguide_A4.pdf
, o sfogliarla su
www.ruby-lang.org/~slagell
.
Altra introduzione su
www-106.ibm.com/developerworks/linux/library/l-ruby1.html
.
HTH
Massimiliano


www-106.ibm.com/developerworks/linux/library/l-ruby1.html
.
only pdf please, sai come è qua niente flat :)


 only pdf please, sai come č qua niente flat :)
Quello di 
ibm.com
 e` un file unico, te la cavi con un wget.  Invece ho
scoperto che il .tar.gz di cui sopra non va e bisogna dare:
wget -m -np 
www.ruby-lang.org/~slagell/ruby
...se si vuole l'HTML.  (Neanch'io ho la flat, ma l'HTML lo vedo in
console mentre il pdf no. ;-P)
Massimiliano

console mentre il pdf no. ;-P)
Beh ma io X lo lancio sempre ;)


 Beh ma io X lo lancio sempre ;)
 
Nessuno e` perfetto. ;-D
Massimiliano

Nessuno e` perfetto. ;-D
Infatti, ma non preoccuparti puoi sempre migliorare ;P
