Question 1. Explain The Reason To Implement A Corba Application With Multi-threading?
CORBA server applications may be multi-threaded for serveral reasons.
A particular CORBA item may additionally support an operation whose implementation plays a few blocking habitual. This may be a disk study or database query. Let us anticipate that the server application procedures all CORBA occasions inside a single principal thread. This method that the server will be not able to reply to incoming connection requests or invocation requests while the blocking operation is in progress. Multi-threading may be used to avoid these types of conditions. The server may be greater handy if a couple of threads are allowed to system (an block for the duration of) incoming CORBA occasions.
A unmarried multi-threaded server method assisting many (>25) customers is lots more green that many (>25) single-threaded server processes each helping its very own purchaser. Running a single software with a couple of threads calls for less device resources than strolling a couple of programs. This benefit can be seen although the operation invocations are of brief period and non-blocking off.
Question 2. Explain Does Corba Supports Asynchronous Communication?
Kind of. At the lowest level CORBA helps modes of communication:
A synchronous request/reaction which lets in an utility to make a request to a few CORBA object after which await a response.
A deferred synchronous request/reaction which lets in an application to make a request to some CORBA item. An empty end result may be back at once to the utility. It can then perform other operations and later ballot the ORB to look if the end result has been made available.
At the lowest level, the CORBA deferred synchronous verbal exchange does allow a sure diploma of asynchronous conversation. Polling for responses represents simplest one shape of asynchronous communication. Other more state-of-the-art asynchronous verbal exchange can best be achieved by way of growing an structure on top of the bottom stages of CORBA.
Core Java Interview Questions
Question 3. Explain Can Corba Application Have Call Back?
Yes. The words consumer and server are in reality handiest applicable within the context of a far flung name. In different words, the consumer process can also get hold of calls on CORBA objects that it implements and arms out the references to.
Question four. Explain Some Reason To Avoid The Development Of Multi-threaded Corba Application?
Building multi-threaded applications calls for a further efforts in the region of design, development and testing. Issues like concurrency and synchronization come to be extra critical. Difficult to discover software program bugs are lamentably clean to introduce. A precise set of application necessities can frequently be met with out resorting to the usage of threaded customers or servers. This isn't always real with all programs. Some do require multi-threading to gain their preferred stage of concurrency, performance or scalability.
Core Java Tutorial
Question 5. Explain What Is Corba Good For?
CORBA is beneficial in lots of situations. Because of the clean manner that CORBA integrates machines from such a lot of providers, with sizes starting from mainframes through minis and computer systems at hand-helds and embedded structures, it's miles the middleware of preference for large (and even now not-so-large) businesses. One of its most essential, as properly most frequent, uses is in servers that need to manage huge wide variety of customers, at high hit fees, with high reliability. CORBA works behind the curtain within the computer rooms of a few of the global's largest web sites; ones that you probable use every day. Specializations for scalability and fault-tolerance support these structures. But it is now not used only for massive programs; specialised versions of CORBA run actual-time structures, and small embedded systems.
JSP Interview Questions
Question 6. Explain Can Corba Allow Servers To Cause Client Side Events Or Notifications?
CORBA communication is inherently asymmetric. Request messages originate from customers and responses originate from servers. The essential aspect to comprehend is that a CORBA server is a CORBA item and a CORBA consumer is a CORBA stub. A purchaser software would possibly use object references to request faraway carrier, however the purchaser software might also implement CORBA items and be able to servicing incoming requests. Along the equal lines, a server method that implements CORBA items may have numerous object references that it uses to make requests to other CORBA objects. Those CORBA objects would possibly are living in patron programs. By imposing a CORBA object inside an customer utility, any technique that obtains its item reference can ?Notify? It by way of appearing an operation at the patron-placed item.
Question 7. Give Us High-degree Technical Overview Of Corba?
CORBA packages are composed of gadgets, character units of going for walks software program that integrate capability and information, and that regularly (but not always) constitute some thing in the actual international. Typically, there are numerous instances of an item of a unmarried kind - as an instance, an e-trade website would have many buying cart item instances, all equal in functionality however differing in that every is assigned to a distinctive customer, and consists of information representing the products that its specific purchaser has decided on. For different kinds, there may be only one instance. When a legacy software, such as an accounting system, is wrapped in code with CORBA interfaces and spread out to clients at the network, there's normally handiest one example.
For each object kind, including the buying cart that we simply noted, you define an interface in OMG IDL. The interface is the syntax a part of the settlement that the server object offers to the clients that invoke it. Any client that desires to invoke an operation on the object ought to use this IDL interface to specify the operation it wants to carry out, and to marshal the arguments that it sends. When the invocation reaches the goal item, the same interface definition is used there to unmarshal the arguments so that the object can perform the requested operation with them. The interface definition is then used to marshal the results for his or her experience again, and to unmarshal them when they attain their destination.
The IDL interface definition is impartial of programming language, however maps to all the famous programming languages thru OMG requirements: OMG has standardized mappings from IDL to C, C++, Java, COBOL, Smalltalk, Ada, Lisp, Python, and IDLscript.
For greater on OMG IDL, click on right here.
This separation of interface from implementation, enabled via OMG IDL, is the essence of CORBA - how it enables interoperability, with all of the transparencies we have claimed. The interface to each item is described very strictly. In comparison, the implementation of an object - its jogging code, and its data - is hidden from the rest of the gadget (that is, encapsulated) behind a boundary that the client may not move. Clients get right of entry to objects most effective via their advertised interface, invoking only the ones operations that that the object exposes via its IDL interface, with simplest the ones parameters (enter and output) which are included inside the invocation.
Figure 1 indicates how the whole lot fits collectively, at least within a single manner: You collect your IDL into purchaser stubs and object skeletons, and write your item (shown on the proper) and a patron for it (on the left). Stubs and skeletons serve as proxies for clients and servers, respectively. Because IDL defines interfaces so strictly, the stub on the consumer aspect has no hassle meshing flawlessly with the skeleton at the server aspect, even though the two are compiled into exclusive programming languages, or even jogging on one-of-a-kind ORBs from special providers.
In CORBA, each item instance has its own unique item reference, an figuring out digital token. Clients use the item references to direct their invocations, identifying to the ORB the exact instance they want to invoke (Ensuring, for instance, that the books you select pass into your own buying cart, and not into your neighbor's.) The client acts as though it is invoking an operation on the item example, however it is simply invoking at the IDL stub which acts as a proxy. Passing via the stub on the consumer side, the invocation continues via the ORB (Object Request Broker), and the skeleton at the implementation aspect, to get to the object where it's far performed.
JSP Tutorial Hibernate Interview Questions
Question eight. What Is Corba? What Does It Do?
CORBA is the acronym for Common Object Request Broker Architecture, OMG's open, vendor-independent architecture and infrastructure that computer programs use to work collectively over networks. Using the usual protocol IIOP, a CORBA-primarily based program from any supplier, on almost any computer, operating system, programming language, and network, can interoperate with a CORBA-primarily based software from the same or some other dealer, on nearly another laptop, operating machine, programming language, and network.
Question nine. Tell Me Can Corba Application Be Multi-threaded?
The CORBA specification does not currently deal with multi-threaded architectures. Provided that the CORBA product is thread safe, threaded CORBA programs can be advanced. CORBA clients and servers can each be multi-threaded. Daemon approaches supplied with CORBA products can be applied as multi-threaded servers by way of the CORBA seller. Different multi-threaded models or multi-threaded architectures may be supported with the aid of a selected CORBA product. A specific ORB may additionally offer frameworks to simplify the development of multi-threaded CORBA programs.
SNMP Interview Questions
Question 10. Explain Do Different Corba Implementations Perform At Significantly Different Levels?
Different CORBA implementations can range substantially in overall performance. Good implementations should be fairly similar due to the fact that community overall performance defines the most conceivable performance traits. Network latency does constitute the good sized portion of dispensed invocation latency.
Question 11. Explain What Is The Reason To Implement Corba In Client Application Application?
Client-facet CORBA programs might require multi-threading to allow it to carry out different obligations even as it is awaiting a synchronous remote invocation to go back. It may preference this capability for numerous specific motives.
A client application may want to leverage the static request/reaction fashion of invocation however reap a few diploma of asynchronous conversation. Perhaps the customer desires to perform several synchronous invocations inside their personal application threads. This would allow a patron to gain effects from numerous far flung servers more quick. There are several motives the use of multi-threading might be favored over using DII. DII is probably complicate application supply code. Application polling related to the deferred synchronous invocation would possibly result in a performance bottleneck.
A consumer-side CORBA software may need to respond to occasions together with incoming invocations, join requests, or GUI occasions (mouse clicks, and so forth.) CORBA merchandise that guide most effective blocking style far off invocations could be not able to process any of these occasions. This would suggest that a patron-aspect software would be unable to respond to GUI occasions at some point of any far flung CORBA invocations. This isn't always an issue for short period invocations but becomes a problem for longer invocations or in failure or time-out situations. Performing faraway invocations inside dedicated threads can keep away from this problem.
Veritas Volume Manager (VVM or VxVM) Interview Questions
Question 12. Explain Are There Different Threading Models That Can Be Used Within Corba Servers?
There are numerous special not unusual architectures that may be used within multi-threaded CORBA servers. A server technique desires the capacity to process CORBA messages. These messages are processed via one or greater threads, as decided by using the utility structure. The CORBA specification does now not especially deal with threading talents inside CORBA compliant ORBs. An ORB dealer is loose to assist most effective unmarried-threaded utility or to guide multi-threaded applications. If the ORB does assist the development of multi-threaded packages, the ORB would possibly only guide a subset of the threading models indexed underneath.
Significant threading code might nevertheless need to be developed to reap one of the fashions. For instance, the ORB supplier might help a set of software hooks (i.E., interceptors or filters) and can help you put in force threading code with the local OS thread API. On the opposite hand, the ORB product might provide a integrated characteristic so no custom thread improvement wishes to be done. The CORBA specification does no longer deal with this trouble. When you keep in mind exclusive threading models, it's far critical to consider what form of concurrency is desired. While it can be effective that or extra threads can be concurrent, it is able to also be disadvantageous. Also, the sources ate up with the aid of idle or active threads, and also the assets consumed for thread creation and deletion, need to be considered. Thread-Per-Request: With this structure, the CORBA server ensures that each incoming message is processed in its own thread. This way that multiple requests may be processed concurrently. There are concurrency troubles.
If or more requests (threads) are using the identical object, then some shape of concurrency manage (locking) is needed. Also, if two or extra requests (threads) are from the same customer, then perhaps the requests need to be serialized in place of allowed to execute simultaneously. Thread-Per-Client: With this structure, the CORBA server ensures that each incoming message from a distinct customer is processed in its own thread. This is much like Thread-Per-Request besides multiple requests from the identical client are serialized. Requests from distinct customers are concurrent. The manner that one client is distinguished from another is an interesting hassle. Typically, that is carried out by way of looking a the community connection and figuring out that the clients are the identical or one of a kind. The server wishes the capacity to reveal consumer connections and the inception and termination of this connections (usually at a network degree, now not an utility degree). Thread-Per-Server-Object: With this architecture, the CORBA server ensures that every item in the server receives it own thread of execution.
This manner that a couple of requests might be processed simultaneously provided they're the usage of one-of-a-kind items. Multiple requests the usage of the equal object are serialized. There are concurrency problems, and a few locking strategy is wanted. Also, impasse could be very viable. It can be that threading or locking at each item is just too excellent a grain, and a extra suitable desire is placing the thread/lock boundary round a collection of coordinating objects. For each of the above threading architectures, the specified server threads can be either created on demand or recycled via a thread pool. The gain of creating threads on demand is that an arbitrary number of threads may be supported.
A thread is created, used, and then reaped. The Thread-Per-Request model might create/acquire a thread for every request; the Thread-Per-Client version would create/reap a thread for every patron connection; the Thread-Per-Server-Object model could create/achieve a thread for each CORBA object instantiated within the server. Thread introduction and reaping has some price, which may be huge or small depending at the running system thread help. A thread pool is an opportunity to creating threads on call for. In this approach, a fixed range of threads are created and cycled in flip to fulfill the call for for threads. If the demand for threads exceeds the pool size, then in addition requests for threads are blocked till one of the current threads is recycled. This technique has the gain of capping the server resources.
Core Java Interview Questions
Question thirteen. Explain Does Corba Define High Level Application Architectures?
No, it's miles infrastructure. Which is good due to the fact the history of excessive-level? One length suits all? Architectures hasn't been very good, has it CORBA affords low stage request/response conversation. It also affords wellknown services that are implemented on top of request/reaction conversation. The actual architecture used inside a given utility is not defined by using CORBA. CORBA leaves those decisions up the utility architect.
Object Oriented Analysis and Design Tutorial
Question 14. Explain Does Corba Support Distributed Reference Counting Architectures?
CORBA does now not directly help dispensed reference counting. This changed into a aware choice on the a part of its designers. While CORBA does not immediately guide reference counting, it's miles viable to build reference counting into a selected dispensed item architecture. This may be finished thru an specific session control facility which can be uncovered through factories or different remote interfaces. While it's far viable to design reference counting into an utility, it's far the weight of the software clothier/developer to make sure that such an approach is carried out efficiently.
Question 15. Explain Can Corba Application Be Tuned For Better Performance?
There are some of approaches to tune CORBA programs for better overall performance. Remember that distribution must most effective be used if a reason to achieve this exists. Distribution does no longer make experience for the sake of distribution. If distribution does not serve a cause then it must be prevented. Avoiding excessive distribution can bring about better overall performance. Care should be taken while introducing distribution into an packages object model. IDL interfaces can be tuned to minimize community latency.
Invoking faraway operations calls for transmitting information throughout the community. Network overall performance is typically optimized via ensuring good enough bandwidth. Once the specified bandwidth is achieved uncooked community performance can not be increased. One key to tuning an IDL interface is to reduce the quantity of community transfers that want to occur. Calling an operation that returns 100 bytes would possibly take 5 milliseconds. Calling an operation that returns 200 bytes of information may take round 6 milliseconds. Calling 2 operations that go back one hundred bytes might take a total of 10 milliseconds. One key to tuning IDL operations is to avoid enforcing several get operations and to combine them into a unmarried get operation which returns an appropriate mixture of statistics.
Caching results of remote operations can keep away from community overhead associated with calling the identical far off methods greater than as soon as. Many applications can perform faraway operations upon startup instead of all through normal utilization. Users are often extra inclined to wait at startup time rather than during software utilization. Many performance problems are associated with serialization and blockading situations. For example, Let us count on that clients might be making remote operations to a single server. A unmarried patron?S request reasons the server to dam for a prolonged time frame, the entire client community may must wait. Make positive that multiple dispensed operations are not turning into serialized inside a unmarried server method. Utilize more than one server tactics or threaded servers instead.
Remote Method Invocation Interview Questions
Question sixteen. Explain Are There Important Forms Of Asynchronous Communication That Are Not Supported Directly By Corba?
Yes, however we are able to fake it pretty without difficulty.
While CORBA does assist a deferred synchronous request/reaction, it does not directly support allotted requests with a callback driven reaction. A callback pushed response permits an application to perform an operation on a disbursed object, partner a callback with the reaction, maintain with different processing. When the server responds, the associated callback is routinely finished within the original caller’s software.
Question 17. Explain How Does Corba Support Interoperability?
CORBAs aim is to address interoperability at diverse levels. There is a history to this.
In the early versions of CORBA, interoperability among structures and programming languages was addressed. This protected the standardization of IDL and the mapping of IDL to a programming language. While a purchaser and server evolved with the identical providers ORB may want to talk to each other, a client and server evolved with different providers? ORBs were now not in all likelihood to interoperate.
CORBA 2.0 introduced interoperability among exceptional ORB carriers. This resulted from the advent of a wellknown wire protocol called General Inter-ORB Protocol (GIOP), and the incarnation for GIOP for the internet, known as Internet Inter-ORB Protocol (IIOP). So CORBA 2.0 compliant ORBs will interoperate. This way a consumer using ORB seller A can talk to a server the use of ORB supplier B.
Interoperability is honestly a broader problem than just have ORB vendor A talking to ORB dealer B. Fuller interoperability manner that various services interoperate. For example, even as a CORBA item can speak to a DCOM item through a protocol bridge, can the CORBA Transaction Service speak to the Microsoft Transaction Service to have a unbroken transaction among structures? This broader interoperability at the carrier stage is being addressed now.
Object Oriented Analysis and Design Interview Questions