Newsgroup: it.comp.programmare.win32
Titolo: meglio CORBA

Io credo che sia meglio usare CORBA, per il semplice fatto che COM e' un
prodotto Microsoft (un nome che e' tutto un programma), quindi sotto altre
piattaforme non troverai COM! o mi sbaglio ...!

 piattaforme non troverai COM! o mi sbaglio ...!
Solo che di CORBA se ne parla tanto, in teoria è tutto bello ma poi in
pratica è un casino...
Invece (D)COM(+) è una tecnologia abbastanza collaudata e diffusa ed anche
se teoricamente è inferiore a CORBA, praticamente lo disintegra...
Alex Martelli diversi mesi fa aveva spiegato bene i motivi per cui COM può
ritenersi superiore a CORBA, io non li ricordo tutti...
COMunque tieni presente che COM funziona e su tutte le macchine Win32 in
funzione ci sono già tantissimi componenti COM installati, mentre CORBA in
genere non c'e'!
Ciao, Davide.

genere non c'e'!
Non bisogna confrontare COM con CORBA, ma *DCOM*.
COM non ha una stretta attinenza con la programmazione distribuita.
Io, comunque, ho visto fallire miseramente un progetto basatosi su
DCOM, per cui ho timore che non sia poi cosi' collaudato come sembra,
anche perche' le fonti Microsoft nei convegni confermano i bug che ci
sono. CORBA non credo che venga *disintegrato* dalla tecnologia
Microsoft, tenendo presente che e' supportato da molte altre aziende e
che tende ad essere maggiormente portabile. Credo che tuttora ci sia,
comunque, un tentativo di costruire un ponte di collegamento tra i due
protocolli.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------
Dovro' prendere lezioni di Internet, 
se non sai di Internet non ti considera nessuno 
(Carmen di Pietro) 
-----------------------------------------------

 disintegra...
Onestamente mi sembrano delle affermazioni un po' affrettate. A parte
gli ovvii vantaggi apportati dal fatto che CORBA e` uno standard aperto,
ormai esistono "librerie" CORBA assai leggere e performanti, che vengono
usate persino nei sistemi embedded (DCOM mi sembra che non sia portato
nemmeno su WinCE, mentre dovrebbe essere la piattaforma principe).
Anche nella pratica, si vede come CORBA abbia (sia storicamente che a
tutt'oggi) un'utilita` molto piu` pratica di COM/DCOM. L'interfaccia di
OS/2 (che paradossalmente era "piu` a oggetti" nei primi anni 90 di
quanto lo sia tutt'ora quella di Windows) usava CORBA e SOM in modo
pesante, e anche oggi ci sono degli egregi esempi di infrastrutture
*totalmente* basate su CORBA come Gnome. Non c'e` niente di tutto questo
fatto in COM.
Diciamocelo: COM e OLE se li sono praticamente "inventati" gli
sviluppatori di Office per motivi di loro praticita`, non avevano
nessuna intenzione di definire uno standard generico utile per chiunque.
Poi la M$, come suo solito, ha iniziato a metterci delle pezze per
adattarlo ad altri scopi, e grazie alle solite astute mosse commerciali
e "di propaganda" ora tutti sono convinti che sia il non plus ultra. Ma
nella pratica non c'e` nessun motivo per considerarlo tale.
---
Bye! Lorenzo Lutti
http://www.geocities.com/SiliconValley/Peaks/6258/

grossomodo sono daccordo con te, io nel paragonare COM a CORBA ho
dimenticato qualcosa di importante che aveva detto Alex Martelli tempo fa...
Una domanda: ma CORBA eseguito in locale offre prestazioni superiori a COM?
Se cosě non č, allora forse un vantaggio di COM č quello di poter funzionare
in remoto (DCOM) con minime modifiche, mentre CORBA no so se ha la
controparte locale...
Ciao, Davide.

controparte locale...
Ti faccio solo un esempio, in cui mamma MS, al solito, si rivela
un'enorme pasticciona :
Lo stesso progetto giocattolo sviluppato in DCOM e CORBA :
Sorgente in IDL DCOM :
// definition of IGrid1
    [  object, 
       uuid(3CFDB283-CCC5-11D0-BA0B-00A0C90DF8BC),
       helpstring("IGrid1 Interface"),
       pointer_default(unique)
    ]
    interface IGrid1 : IUnknown      {
       import "unknwn.idl";
       HRESULT get([in] SHORT n, [in] SHORT m, [out] LONG *value);
       HRESULT set([in] SHORT n, [in] SHORT m, [in] LONG value);
    };
// definition of IGrid2
    [ 	object, 
	uuid(3CFDB284-CCC5-11D0-BA0B-00A0C90DF8BC),
        helpstring("IGrid2 Interface"),
        pointer_default(unique) 
    ]
    interface IGrid2 : IUnknown      {
        import "unknwn.idl";
        HRESULT reset([in] LONG value);
    };
[   uuid(3CFDB281-CCC5-11D0-BA0B-00A0C90DF8BC),
    version(1.0),
    helpstring("grid 1.0 Type Library)
]
library GRIDLib
{
    importlib("stdole32.tlb");
// definition of the component
    [ 	uuid(3CFDB287-CCC5-11D0-BA0B-00A0C90DF8BC),
        helpstring("Grid Class")
    ]
    coclass CGrid
    { 	[default] interface IGrid1;
        interface IGrid2;
    };
};
// definition of IGrid1
    [  object, 
       uuid(3CFDB283-CCC5-11D0-BA0B-00A0C90DF8BC),
       helpstring("IGrid1 Interface"),
       pointer_default(unique)
    ]
    interface IGrid1 : IUnknown      {
       import "unknwn.idl";
       HRESULT get([in] SHORT n, [in] SHORT m, [out] LONG *value);
       HRESULT set([in] SHORT n, [in] SHORT m, [in] LONG value);
    };
// definition of IGrid2
    [ 	object, 
	uuid(3CFDB284-CCC5-11D0-BA0B-00A0C90DF8BC),
        helpstring("IGrid2 Interface"),
        pointer_default(unique) 
    ]
    interface IGrid2 : IUnknown      {
        import "unknwn.idl";
        HRESULT reset([in] LONG value);
    };
[   uuid(3CFDB281-CCC5-11D0-BA0B-00A0C90DF8BC),
    version(1.0),
    helpstring("grid 1.0 Type Library)
]
library GRIDLib
{
    importlib("stdole32.tlb");
// definition of the component
    [ 	uuid(3CFDB287-CCC5-11D0-BA0B-00A0C90DF8BC),
        helpstring("Grid Class")
    ]
    coclass CGrid
    { 	[default] interface IGrid1;
        interface IGrid2;
    };
};
Lo stesso IDL scritto usando le specifiche di CORBA :
interface grid1 
{
        long get(in short n, in short m);
        void set(in short n, in short m, in long value);
};
interface grid2 
{
        void reset(in long value);
};
interface grid: grid1, grid2 
{
};
Quale dei due useresti ? :)


> Quale dei due useresti ? :)
se non fossi condizionato o obbligato a scegliere COM, userei CORBA.
Non sono un esperto, nè di COM, nè di CORBA, però il discorso mi interessa.
Le prestazioni tra COM e CORBA eseguito il locale sono analoghe?
Ciao.

Le prestazioni tra COM e CORBA eseguito il locale sono analoghe?
Il confronto piu' corretto, come ti ho gia' suggerito, non e' tra COM
e CORBA, ma tra DCOM e CORBA. In ogni caso non saprei proprio su che
base valutare le "prestazioni" dell'uno rispetto all'altro.


 sbaglio ?)...
Sě. 
Primo bisogna lasciare in LISTENING le porte da 1024 a 65535.
Poi il Service Control Manager di Win che assegna dinamicamente le porte 
del DCOM ha bisogno che la porta 135 sia aperta (anche sui router
interni dietro 
al server DCOM azzo!). Anche se č difficile da attaccare si possono fare
TROPPO
semplicemente portscan.
Infine un server DCOM non si puň (almeno a quello che so io!) mettere
dietro ad un firewall
NAT perchč questo eseguirebbe la trascrizione degli indirizzi e mentre i
client DCOM 
devono collegarsi all'IP originario.