Document Sample
Middleware_Technologies_Two_Marks Powered By Docstoc
					Sub Name: Middleware Technologies
                                       PART - A
                                    2 mark questions

    1. Write about OMG.
             OMG stands for Object Management Group were created in 1989. The
       OMG solicited input from all segments of the industry and eventually defined
       the CORBA standard. The OMG does not create products; it focuses on creating
       specifications that can be implemented and used by all.

    2. What is DOM? And Write about it.
       CORBA is a specification for an emerging technology known as distributed
       object management (DOM) . DOM technology provides a higher-level, object-
       oriented interface on top of the basic distributed computing services. CORBA
       has emerged as the leading standard among DOM solutions, with only one
       significant competitor, Microsoft’s distributed component object model
       (DCOM) .

    3. What is OMA? And write about its elements.
           The higher-level specification is referred to as the object management
           architecture (OMA), which addresses following elements:
        1. CORBA services
        2. CORBA facilities
        3. CORBA domains
        4. ORB (Object Request Broker).

    4. What are the things consists by CORBA object model.
                  Object- An encapsulation entity that provides services to a client.
                  Requests- An action created by a client directed to a target object
                    that includes information on the operation to be performed and
                    zero or more actual parameters.
                  Object Creation and Destruction – Based on the state of requests,
                    objects are created or deleted.
                  Types- An identifiable entity defined over values.
                  Interfaces – The specification of operations that a client can
                    request from a object.
                  Operations- An identifiable entity that defines what a client can
                    request from an object.

    5. How to managing Distributed Systems?
            The Distributed Systems managed by applying following Services.
         2. Naming
         3. Monitoring
       4. Licensing
       5. Persistence
       6. Security
       7. Transaction
       8. Messaging
       9. Distributed garage collection
       10. Resource Management.

6. What are factors considered during the development and the deployment of
software for Distributed Objects?
          * Language choice is no longer a primary consideration.
          * Process and machine boundaries are more easily crossed.
          * Internet and push technologies offer new delivery mechanisms.

7. What are the fundamentals traits of a distributed object system?
        Data Types
        Interfaces
        Marshaling and un marshaling
        Proxies, stubs, and skeletons
        Object handles
        Object creation
        Object invocation
        Object destruction

8. What is BSTR?
    A BSTR also known as a Basic String is a pointer to a length-prefixed wide
character array. Because a BSTR is prefixed with a 4-byte length attribute, a C/C++
BSTR pointer does not point at the beginning of the data structure but instead points
to the first wide character in the array. In a C++ application, a BSTR instance must
be allocated using the SysAllocString() method and deallocated using the
SysFreeString() method.

9. How to implement a remote method invocation in CORBA?
          1. A Client invokes a remote method. The remote method is actually
          invoked in the client stub.
          2. The Client stub creates a message containing information needed for the
          remote invocation.
               3. The Client stub sends he message to the server skeleton using the
               communication bus.
               4. The server skeleton receives the message and unpacks it.
               5. The server skeleton calls the appropriate server method based on the
       information provided in the received message.
               6. The server skeleton creates a message based on the outputs of the call to
       the server method.(i.e., the return value and out parameters).
               7. The server skeleton sends the result message to the client stub using the
       communication bus.
               8. The client stub receives the result message, unpacks the message, and
       returns the results to the client.

   10. What is marshaling and Un-Marshaling?
             In Client-Server communication with CORBA or COM or RMI, The
   message creation or packing process in any side it refers to as Marshaling. The
   message unpacking process is referred to as un-marshaling.

   11. What is CORBA?
              CORBA stands for Common Object Request Broker Architecture which is
   a Middleware between Client and Server in Distributed Architecture. CORBA
   provides language independence by defining object interface in a language-
   independent manner. CORBA is providing to be one of the most important
   innovations in the recent history of information systems. It addresses the two most
   prominent problems faced in he software industry today:
       1. The difficulty of developing client-server applications.
       2. By rapidly integrating legacy systems, off-the-shelf applications, and new

12. What are the key roles of broker in distributed System?
      The broker plays two key roles.
      1. It provides the common services, including basic messaging and
           communication between client and server, directory services, meta-data
           description, security services, and location transparency.
      2. It insulates the applications from the specifics of the system configuration ,
           such as hardware platforms and operating systems, network protocols , and
           implementation languages.

13. What is CORBA Object Model?
      The CORBA Object Model defines key boundaries and meanings to enable
unambiguous interpretation of these concepts. Without a common object model, the
implementation of CORBA – compliant tools by independent software manufactures
might otherwise produce fatal incompatibilities. CORBA’s object model is based on a
complete object approach in which a client sends a message to an object. The message
identifies an object, and one or more parameters are included. The first parameter defines
the operation to be performed, although the specific method used is determined by the
receiving object.

14. What is GIOP?
              GIOP stands for General inter-ORB protocol. The GIOP was specified to
allow interoperability among ORB implementations. It assumes an underlying
connection-oriented transport layer. The GIOP defines transfer syntax, known as
common data representation (CDR), and seven basic message types.

15. What is IIOP?
        IIOP stands for Internet Inter –ORB protocol. The mapping of GIOP to TCP/IP is
referred to as the internet Inter-ORB protocol. The interoperable object reference (IOR) is
the mechanism through which objects are accessed through the IIOP and between ORB
vendors. The IOR includes the Orb’s internal object reference, Internet host address, and
port numbers. It is managed by the interoperating Orbs and is not visible to application

16. What is IDL?
        IDL stands for Interface Definition Language. OMG IDL is a declarative for
defining the interface of CORBA objects. It is a language- independent way in which
implementers and users of objects can be assured of type-safe invocation of operations,
even though the only other information that needs to pass between them is an object
reference. IDL is used by ORB-specific IDL compilers to generate stub and/or skeleton
code that converts in-memory data structures in one programming language into
equivalent network streams and then unpacks them on another machine into equivalent
data structures in another language, makes a method call, and then transmits the results in
the opposite direction.

17. What is IDL Interface?
         The IDL interface defines the exposed details of distributed objects. Each IDL
interface defines a new object type. The operation signatures are the essence of the
interface. These are the entry points for service requests. IDL interface is that it specifies
a software boundary between a service implementation and its clients. The IDL declares
what is exposed by this interface, and all other details are hidden. IDL interface can
inherit from other interfaces.

18. What is the purpose of IDL Modules?
              IDL modules create separate name spaces for IDL definitions. This
prevents potential name conflicts among identifiers used in different domains. Modules
do not inherit from other modules. Only IDL interfaces are capable of inheriting
specifications. Modules can be nested. Modules are used at the base definition level to
enclose one or more IDL interface and their associated type definition.

19. What is the purpose of using IDL Forward?
        The IDL forward statement is used to declare an interface name before its
complete definition appears in the file. Forward declarations can also be used to create
recursive definitions. Forward declarations do not establish their enclosed definitions.

20. Write about IDL Constants.
       IDL allows the definition of constant values. There is a restricted set of types,
including integer, character, Boolean, floating point, string, and renamed types. The
constant definitions can include some arithmetic expressions.
               const unsigned long k =4.5;

21. What is IDL sequence?
         Sequences are special data type that is unique to IDL. Sequences are essentially
variable-length arrays. Since every programming language has a binding to IDL that is
natural, sequences are defined as appropriate within the programming language
environment. If the programming language already has a variable-length elements type ,
that is a suitable representation.

22 What is purpose of IDL Type Declaration?
        The purpose of type declarations in IDL is to enable strong type checking of
operation signatures. Type declarations include renaming of the intrinsic types in IDL, as
well as the creation of user-defined types that can be either enumeration, structures,
arrays, sequences , or unions.

23. Write about IDL Attributes?
        IDL definitions expose public attributes and operations. If an attribute or
operation is private, it should not appear in a public IDL definition. By default, all IDL
definitions know by the ORB are public because they are publicly retrievable from the
Interface Repository. Attribute may be read-only or read-write. Each attribute has an
IDL data type and appears within a specific IDL interface definition.
Example: attribute unsigned short age;

24. Write about IDL Exception.
       CORBA makes the important guarantee that the client making an invocation will
always receive a successful return or an exception. This is a significant simplification of
the complexities of distributed computing and can greatly reduce the amount of client
code needed. Exceptions are also an important part of an interface specification.
Exceptions define the values passed by the interface in case something goes wrong. There
are two general kinds of exceptions: user-defined and CORBA defined .

25. What is IDL Operation Signatures?
        The specification of operation signatures is the underlying purpose of IDL. An
operation signature defines the acceptable ways to access an object. No other hidden
interfaces are allowed. All operation definitions are declared within specific IDL
interfaces. By default, IDL operations are synchronous. There is an asynchronous option
denoted by the one-way keyword, which indicates that the operation will be executed at-
most-once, using a best-effort semantics.

26. Compare Static Interface and Dynamic Invocation Interface.

            Static Interface                    Dynamic Invocation Interface
      1     General purpose;                    Used in special purpose code needing
            Used by most code, most of the      extra    flexibility   ;    debuggers,
            time.                               desktops, browsers, etc.
      2     Interfaces must be known at         Interface can be discovered at run
            compile time, binding can be        time using data in Interface
            dynamic /run-time.                  Repository.
      3     Supported by all current            Appeared before static interface in
            CORBA compliant products.           first generation products , 2 3 years
                                                ago- similar to current OLE2
      4     API is natural to the language.     DII is pre- defined, single API for all
            - uses normal function calls        method invocations.
            - uses natural parameter
            - through        compile     time

                             PART –B

   Possible 16 mark questions (Refer XEROX )
1. Discuss in details about CORBA and its purpose.

2.   Briefly explain about Distributed System.

3. Write in details about Client/Server Architectures in Distributed System. (2-
   Tier, 3-Tier and N-Tier Architectures). And Communication between Tiers.

4.   Discuss about Managing Distributed Systems and State of Distributed

5. Draw CORBA architecture and write about its elements and types of

6. Discuss in details about CORBA Object Model.

7. Explain briefly about Object Request Broker and its structure.

8. Discuss in details about CORBA and it’s networking model.

9.   Briefly explain about alternatives of CORBA.

10. Building an application in CORBA.

Shared By: