25 August 2008
 |
Posted by Stone Age at 8/25/2008 9:02:00 PM |
World is becoming so fast now, boisterous cities with all the colors of rainbow, I cannot find myself. If you link my peaceful little stone house, come have a .... cup of water. |
This is the principle that entities which comprise a distributed system should be located close together, ideally on the same server or client. These entities can be files, programs, objects or hardware.
As an example of this principle consider a distributed system whose clients issue a query which results in large amounts of data being retrieved from two tables located on two separate servers connected via a wide area network such as the Internet. An example of this would be a query which involved an SQL join. Let us also assume that a third server carries out the joining process and the construction of the resulting table. If the two tables are large then there will be a considerable delay while data is retrieved from the two servers and sent to the third server. If these two tables were situated on the same server then, theoretically, a considerable performance improvement can be achieved.
This decision looks very straightforward and one which should automatically be taken by the designer of a distributed system. However, trade-offs also have to be considered. For example, as you will see later, an excellent way of improving the performance of a distributed system is to locate data close to the users: usually on the same local area network that they are situated. One of the tables that takes part in the joining process might have been specifically located at a distance from the other table for this very reason.
In order to make a decision about whether to combine the two tables the designer thus has to look at the transactions that are being generated against the tables. For example, if there are a hundred transactions generated against one of the tables to every joining transaction that is generated against both tables, then the degradation of service might be too high to consider bringing the tables together. If the balance was much more even then the designer might consider another strategy: that of bringing both the tables together at the same server but keeping a replicated version of one of the tables which would be updated every time its copy is changed.
There are many more examples of trade-offs which the distributed system designer is faced with: the important two points worth making here are that, first, almost invariably trade-offs will occur apart from when some incompetent design decision needs to be rectified. The second point is that in order to evaluate trade-offs the workload of the system needs to be carefully gauged, for example a good distributed system designer will estimate the number, frequency and originating location of every transaction and then estimate the response time and resource demands that each transaction might make.
Keeping Data together
Probably the best known example of the locality principle is that data that is related to each other should be grouped together. Already in the introduction to this section I have described one example of this where two tables which were related by virtue of the fact that they were often accessed together were moved onto the same server. This whole principle applies to all sorts of groupings of data: rows in a relational table, columns in a relational table, tables themselves and attributes of objects. For example, the analysis of an object-oriented system will produce a series of documents which will describe information such as the functionality of the system, the classes involved in the implementation of the functionality and the relationship between the classes. If analysis has been carried out competently, then there should be little, if any, design information produced, apart from perhaps specification performance constraints.
The role of design is to take the analysis product and turn it into some form which is heavily adorned with physical detail. One application of the principle of keeping data together is to form composite classes which are constructed from two or more classes identified during the analysis phase. The decision as to whether classes should be composited is a serious one. It is based on an appraisal of the workload of a system and the transactions that objects derived from the classes take part in. If the developer used an object-oriented database system to store objects then such a compositing decision would have a significant impact on performance if the objects which were composited were frequently retrieved together.
Keeping Code together
The idea behind this is that if two programs communicate with each other in a distributed system then, ideally, they should be located on the same computer or, at worst, they should be located on the same local area network. The worst case is where programs communicate by passing data over the slow communication media used in wide area networks. There are a number of ways of implementing this design decision, the most obvious being to statically store programs which communicate together on the same server; an alternative would be to dynamically load these programs at run time. However, a word of warning is necessary: many programs that are found on separate servers will be there because they are communicating with some local database. Thus, the decision to bring together two programs will often require data to be moved with an effect on performance ensuing.
Posted at 21:2 0 comments
25 August 2008
|
Posted by Stone Age at 8/25/2008 8:40:00 PM |
World is becoming so fast now, boisterous cities with all the colors of rainbow, I cannot find myself. If you link my peaceful little stone house, come have a .... cup of water. |
In it I look at one particular example of TP monitor technology: Enterprise JavaBeans.
Enterprise JavaBeans and JavaBeans
You will often see the term JavaBeans used within the Java community. It refers to a technology used to develop reusable components using the Java programming language. Fairly soon after the release of the initial Java system Sun Microsystems released an application programmer interface (API) which enabled developers to produce components — usually visual components — which could, for example, be added to an integrated development environment and be treated in a similar way to normal Java widgets using the visual designer part of the environment. Such components are known as JavaBeans. They only have a small similarity to Enterprise JavaBeans: the fact that they are reusable. As you will see in this section Enterprise JavaBeans can be moved easily from one server to another developed by a different company.
Enterprise JavaBeans technology forms one part of a package of middleware software developed by Java and known as the Java 2 Platform Enterprise Edition. You have already seen some of the components of this package including Remote Method Invocation, the Java Database Connection (JDBC) and servlets. Other components of the package include JavaMail which enables a programmer to easily connect to some mailing protocol such as POP3, the Java messaging service which enables developers to produce message-oriented middleware and the Java Transaction Service which provides the programmer with facilities to manage transactions.
Enterprise JavaBeans is a component technology. The model envisaged is that large-scale components which encompass some business logic are developed by a component manufacturer. For example, one component that might be developed for an airline would be one which allocates staff to flights according to a set of criteria such as the fact that pilots need certain times for resting.
These components, known as business components, will often need heavy transactional services in order to support them. These are provided by means of a TP monitor known as an application server. The business components which reside within an application server provide facilities which, for example, ensure that ACID properties are maintained.
When a system is developed the components are purchased and combined together by a systems integrator. During this process the integrator will not worry about transactional issues such as concurrency control but would concentrate on the logic involved in combining the business components.
Once the system has been developed the components and software glue that connects them together are deployed across one or more application servers.
An important point to make about Enterprise JavaBeans is that it recognises no differences between servers: that Enterprise JavaBeans is capable of being deployed to any server that supports the Enterprise JavaBeans technology. This is in contrast to very recent practice where software written for one TP monitor, for example CICS, could not be easily moved to another server.
This model of development recognises six parties to the development process:
l The bean developer. This is a company that has expertise in some domain such as ticket reservation or airline staff scheduling. This company would produce the Enterprise JavaBeans that implemented some application-specific logic.
l The container provider. This is a company that supplies low-level software which im‑
plements a run-time environment in which Enterprise JavaBeans can execute.
l The server provider. A company that sells an Enterprise JavaBeans-compliant server which provides transactional services. At present the container provider and the server provider are the same company.
l The application assembler. This is the company that joins Enterprise JavaBeans together.
l The deployer. This is some organisation which, given the code for the beans and the glue code, will deploy the code across a number of servers. A number of criteria determine how they are deployed; these include performance, security and reliability.
l The system administrator. This is an individual or collection of individuals who are responsible for ensuring the maintenance of the bean, for example they will be responsible for tuning the bean for performance if requirements change such that the original tuning assumptions do not hold.
The architecture of the Enterprise JavaBeans technology is shown in Figure 13.4. An Enterprise JavaBeans-compliant server can contain a number of containers which themselves will contain a number of Enterprise JavaBeans. Clients are allowed to access the Enterprise JavaBeans via a number of method invocations found within the API for the Enterprise JavaBeans package.
The details of each proprietary server that supports the standard vary enormously; however, they should provide the following broad functions without any programming being required from developers who wish to make use of the beans:
l Distributed transaction management. The server should administer transactions and ensure that phenomena such as phantom updates and inconsistent retrievals do not occur.
l Security. The server should provide facilities which prevent unauthorised access to Enterprise JavaBeans.
l Resource management. The server should provide resource management, for example it should oversee the creation and deletion of threads and file connections.
l Persistence. Many Enterprise JavaBeans require to be held in some permanent storage medium. An Enterprise JavaBeans server should manage this process ensuring that all changes to transient data intended for permanent storage are carried out.
l Multiclient support. The server should manage the process of clients connecting to Enterprise JavaBeans and mediate their interaction with the beans.
l Location transparency. The server should operate in such a way that clients
should have no knowledge of the physical location of Enterprise JavaBeans.
Posted at 20:40 0 comments
25 August 2008
|
Posted by Stone Age at 8/25/2008 2:29:00 PM |
World is becoming so fast now, boisterous cities with all the colors of rainbow, I cannot find myself. If you link my peaceful little stone house, come have a .... cup of water. |
Over at javascript series patois are the best funds. They run matching to you know who's so called invention. I bet they were smarter and have it copywrited already.
As I bashed lunch for twenty people, when only seven were probable, an old teach isolated of wealth hissed that what she sought to read. So here is my darling part:
Com i msnbc Components Art SITEWIDE newLogo half. A armistice or a stillness promise. November, Agreement creating the Joint Political Military Group and Joint Security Santiago Program. Samoil Radinski has also kindly asked Itokim onboard for an EP, which will be free later this year. Language reform granting minorities the right to use their languages in some circumstances and settings SV is not the first stride towards federalization. McCain, Obama biographies enduring but Claudia.
I compel myself to accept some of my desired posts, oh, for me it is really stubborn, they are my treasure. Should I segment my "treasure"? Maybe a little bit: Read the rest of this entry »
Posted at 14:29 0 comments
25 August 2008
|
Posted by Stone Age at 8/25/2008 3:21:00 AM |
World is becoming so fast now, boisterous cities with all the colors of rainbow, I cannot find myself. If you link my peaceful little stone house, come have a .... cup of water. |
After you try javascript instruct idiom, think of the scenery. I like how this orbits work. It is almost finalize.
When the available gets very forcible or too painless, those who are pursuing the superior good may feel a stronger compulsion to keep on almost.
It sounds like you're inclined to learn the Web's hottest programming writing: JavaScript. Head First JavaScript is your voucher to leaving outside copying and pasting the cipher from somebody besides's web position, and prose your own interactive ..keep reading.
I thought I would submit you my kindest regards for winning the time to read this. Read the rest of this entry »
Posted at 3:21 0 comments
Blog New Posts Atom Feed