Data on the outside vs. data on the inside (translation)

Data on the outside vs. data on the inside

Microsoft MSDN above the article

An Examination of the Impact of Service Oriented Architectures on Data

By Pat HellandMicrosoft Corporation

Summary: Pat Helland explores Service Oriented Architecture, and the differences between data inside and data outside the service boundary Additionally, he examines the strengths and weaknesses of objects, SQL, and XML as different representations of data, and compares and contrasts these models.. (26 Printed Pages)

Summary: Pat Helland Experuous SOA and internal and external data. He also investigated different forms of objects, SQL, XML, comparing these models as different forms of data performance.

Contents

IntroductionThe Shift Towards ServicesAssumptions About Service Oriented ArchitectureOutside Data: Sending MessagesOutside Data: Reference DataData on the Inside Data: Then and NowRepresentations of Data: Inside and OutsideConclusion

Introduction

Up until now, most of the discussions on Service Oriented Architecture (SOA) revolved around topics about integration of disparate systems, leveraging companies existing assets, or creating a robust architecture. All of these issues are relevant to SOA. Yet, there are other significant and engaging issues involving SOA that are worth close attention. In its goal to connect heterogeneous and autonomous systems, SOA adheres to several core design principles. One of the principles maintains that independent services involve pieces of code and data interconnected through messaging.

So far, most of the TOPICs discussed in SOA are integrated with heterogeneous systems, and use the company's first-deposit assets [translator: levitation system utilization] and create Robust architecture. All of this is related to SOA. However, there are other significant differences on SOA, very attractive, is worthy of attention. In the goal of SOA connection heterogeneous autonomous systems, SOA adheres to several core design principles. One of the principles is to maintain independent services, including code and interacting data through messaging.

Indeed, services are inextricably tied to messaging in that the only way into and out of a service are through messages. However, services still operate independently of each other. Because of the unique relationship between services and messages, architects, developers, and programmers alike began asking critical questions. Some of the questions deliberated on were how does data flow between services, how are messages defined, what data is shared, how is data inside of a service different from data outside a service, and how is data represented inside and Outside Services. In fact, the service is inevitable and message transfer binding, because the only way to pass the delivery service is through the message. However, the service is still operated independently of each other. Because the unique contact between service and messages, architects, developers, programmers are similar to the key issue. Some questions are how to flow between service data, how messages are defined, those data are shared, the data inside the service, and the external data of the service, how to represent the data inside and outside the service.

Findings to these questions exposed seminal differences between data on the inside of a service and data that existed outside of the service boundary. Data outside a service is sent between services as messages and must be defined in a way understandable to both the sending service and the receiving service. Data inside a service is deeply rooted in its environment. Unlike data outside services, data on the inside is private to the service. in fact, it is only loosely correlated to the data on the outside.

Through these problems, it is possible to find that the data inside the data and the nature of data existing outside the service external boundary are not. The external data of the service is transmitted as a message in service, and must be defined by a sender service and acceptor service. The data inside the service is closely related to his environment. Not like the external data, the service internal data is the private data of the service. In fact, it is just loose contact with external data.

In response to the above findings, this paper leads readers into an in depth discussion on data inside services and data outside services. Readers are introduced to different kinds of data outside services including immutable, versioned, and reference data. The discussion then turns to data inside services involving messages (operators and responses), reference data, and service-private data. Next, the temporal interpretation of data inside services and outside services is explored. Once the different kinds of data are identified, attention is given to the representation of Data THROUGH AN EXAMINATION OF Three Critical Models: XML, SQL, And Objects. For the above discovery, this article boots the discussion of author data. To the reader introduce different types of service external data, including non-variable data, added version data [translator: add timestamp to the data], and reference data. The internal data introduced by readers then includes messages (operators and responses), reference data, and service private data. The next step is a short study on the service inside and outside data. After different types of data is determined, you will start paying attention to data representation, by testing three critical models: XML, SQL, objects.

Although SOA promises to continue stimulating conversation across enterprises and in the IT industry, the buzz accompanying it may now be about data inside services and data outside services. There is now a strong momentum for enterprises to not only bring SOA into their environments, but also To Achieve a Deeper Undering of Their Services and the Behavior Between Services and Data.

Although SOA guarantees STIMULATING cross-enterprise communication, the main problem now discussed is about data within the service inside and outside. Now that the company has strong motivation not only to bring SOA to their environment, but also further understand their service and service and data behavior.

The Shift Towards Services

Migrate to service

One issue in SOA is on independent services involving pieces of code and data, and message interconnecting services. Each service is a unique collection of code and data that stands alone and is independent of other services. However, each service is also interconnected with other services One thing in THROUGH Messaging. The Services from The Silos Existing In Many Environments is about independent services, including code / data dishes, and connection services. Each service is the only independent code and data collection, and other services are not dependent. However, each service is interconnected with other services by transmitting messages. .

Messaging carries enormous importance in SOA. Messages are sent between services and float between them. The schema definition for each message and the contract defining the flow of the messages specify the "black box" behavior of the service. Services are inextricably tied to messaging in That The Only Way Into and Out of a Service Are Through Messages. A Partner Service Is Only Aware of The Sequencing of The Messages Flowing Back and Forth.

In SOA, the message transfer assumes a huge role. The message is transmitted between services and flows between them. The Schema defines and defines the Contract for the "black box" behavior of the contract. The service box message is binding, because the message is the only way to pass the outgoing service. Partner Service (a partner service) is the only clear message to back and forth in the flow.

http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig1.gif

Figure 1. Services and Messages Are Tied Together

Figure 1 Service and message bind together

Sometimes many related messages are sent between two different services. Related messages can flow between two services over the course of weeks or months. For example, an individual may reserve a train ticket on June 1, 2004 and then change the ticket to a different date on June 5, 2004. The individual may then confirm and pay for the reservation on June 10, 2004 and finally cancel the ticket on June 25, 2004. In this example, the individual sent messages every few days for a number of weeks. This is referred to as long-running work. messages in long-running work are related, with the second message dependant on the first message and the third message dependant on the first two messages. A cookie or something similar is used to correlate the relationship between the messages in a long-running work. We avoid the phrase long-running transaction to eliminate confusion with the atomic database transactions. in addition, the word transaction suggests an activity with a beginning and an end . Most Long Running Work Impacts Other Applications In Ways That Ripple Through Multiple Businesses WITHOUT A CLEAR Boundary of Where STARED. It is also, many related messages are transmitted between two non-moving services, related messages The process that can be transmitted through several weeks or months in two services. For example, a person has a train ticket from June 1, 2004, and then the date is June 10, 2004, and eventually canceled this ticket on June 25, 2004. In this example, this person sends a message every few days. This is a very long time. This long-term thing is involved in the message. The second message relies on the first message, depending on the first message. Cookie or similar things are used to contact time span long messages. We avoid long-term business operations to remove the chaos of the database atomic business operation [Translator: This long time span, you can't use your transaction, who uses the transaction who is FOOL (limited to this situation)]. In addition, the word means that the word is active with start and end. Most long-speaking work affects other applications by the following, it has a relationship with multiple services, no obvious work, or the boundaries starting with another job.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig2.gif

Figure 2. Multiple Related Messages Figure 2 Multiple associated messages

To summarize, messages are an important and a critical part of SOA. As the paper will show, messages must receive special care to ensure correct interpretation and to avoid confusion as they flow between different services.

In short, the message is very important, and it is the main part of SOA. This article will show that the news must accept special attention to ensure that you explain the tricks.

Services vs. components

Service VS

There has been a natural evolution over the years involving functions, objects and components, and services. In the beginning, code was separated into functions that allowed software to be grouped into smaller and better-organized pieces. Later, components and objects evolved allowing for The Encapsulation of Data (Member Variables) within them.

Functions, objects, formation, and services are a natural process that has been developed for many years. At the beginning, the code is divided into functions that allow the software to organize the software to organize. Later, the component box object made up, so that the data can be packaged inside.

Currently, services have taken center stage in the evolution process. Services provide a coarser grained form of separation with more independence between the pieces of code than functions and components. First, services always interact with each other through messages. Second, they are normally durable Allowing The Survive System Fault and Restarts. Finally, Services Have Opaque Implementation Environments Where Only from the outside.

Now, the stage of development has been mounted. The service provides the form of coarse particle size, divided into a comparable code than functions and components. First, the service always communicates with each other through the message. Second, the service makes the system application environment unrestricted, only external messaging.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig3.gif

Figure 3. Services VERSUS Components

Figure 3 Message VS formation

Considering Inside and Outside Data

Research internal and external data

It is important to make a distinction between the data inside services and the data outside services. Data outside a service is sent between services as messages and must be defined in a way understandable to both the sending service and the receiving service. Data inside a service IS Deeply Rooted In Its Environment. The external data inside the service is very important. The external data is transmitted between services in a message, and must be defined in a manner that can make it understandable. Service internal data is rooted in the service internal environment.

The need to interpret the data in at least two different services makes the existence and availability of a common schema imperative. The schema should also have certain characteristics. First, independent schema definition is important. This means the sender or receiver should be able to define message schemas without having to consult each other. Second, the message schema should be extensible. Extensibility allows the sending service to add additional information to the message beyond what is specified in the schema.

As long as you need to explain two different services, make a common's format command must be. This format must have some characteristics. First independent format definition is important. This means that the sending of the recipient should be able to define the message format without consulting each other. Second, the message format should be expanded. The scalability enables service senders to add information that is not defined in the message sent.

Note the sender of the message...............

Note that the service sender may or may not be a definition of this message format.

Unlike data outside services, data on the inside is private to the service. In fact, it is only loosely correlated to the data on the outside. Data on the inside is always encapsulated by service code so the only way of accessing it is through the Business logic of the service.

Unlike service external data, the internal data of service is private. In fact, it is just loose contact with external data. Internal data is always encapsulated in the service code, so that the only way to access them is through the service logic.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig4.gif

Figure 4. Data INSIDE AND DATA OUTSIDE SERVICES

Figure 4 Service Interior Data Mainframes and Monoliths-All About Data

The main frame of the box box - all about data

In the past, it was typical for a mainframe or other server system to support multiple applications. Applications access a shared database and work on either a shared set of tables or different tables within the same database. Since all the tables are in a shared database on a large server, applications can perform a single transaction that accesses data from many different tables. Likewise, operations updating multiple tables can take advantage of transactional atomicity in their changes. Equally important, not only do the applications have access to all the data in the database, but they can also access tables managed by different applications. This has colored how people think about the relationship across applications since applications have immediate access to the latest and usually, most accurate information. While this type of access is contingent on such measures AS Security, Authorization, And Privacy Concerns, MOST Applications AssumeTey Can Simply Look in Order To See The Latest Information.

In the past, hosts or other server systems support multiple applications are typical. Apply access to the shared database and operate on a data sheet in the shared in the same database or a different data table. Since the multi-have in a database of shared large servers, the application can perform a unique transaction operation, which accesses many different data sheets. Similarly, the operation of more than a plurality of data tables can utilize the atomicity of the transaction. It is also important that not only the application of all data in the database, but they can also access the tables that have been administered outside of the application. Since multiple applications can immediately get the latest, most accurate information, which gives people a deep impression on the relationship between multiple applications. However, this type of access depends on security, authorization, private levels to determine, many application amenities, they can view the latest data.

In recent years, various economic and technological trends have resulted in applications steadily moving off to different machines. This has resulted in the fracturing of the monolith. A single giant system no longer runs all the applications in a typical organization. This, however, raises an issue because as applications move to different machines, it becomes more difficult to share the same data since data now resides on different machines. Updating across these machines also becomes difficult since the machines are designed to be independent and, typically, do not trust each In recent years, different economic and technologies have caused the application to distract the dispersion to each different machine. This also results in rupture of the overall structure. In a typical organization, a separate large system is no longer running all applications. This leads to the appearance of the situation, since different applications are on different machines, the same data that is wondering between them in different machines is more difficult. Updates across these machines are more difficult to change, and should be designed for all machines, and generally do not trust each other.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig5.gif

Figure 5. Mainframes and Monoliths

Figure 5. Mainframes and Monoliths

Assumptions About Service Oriented Architecture

About SOA ideas

Major Tenets of Service Oriented Architecture

Main principle of SOA

Up to this point, there has been discussion on code and data, systems, and messages. Like any other subject matter that is under discussion or deserves writing down and sharing with others, there exist beliefs about the subject. Below is an outline of the Four Major Tenets of Service Oriented Architecture That Detail The Existence of Code, Message Format and Content, The Function of a Service, And Service Compatibility.

Here, code, data, system, and messages have been discussed. Just like other in discussion, or worthy to record the subject of others, there are some ideas about this topic (Like Any Other Subject Matter That Iss Under Discussion or Deserves Writing Down and Sharing with Sharing with Others, There Exist Beliefs About The Subject . Below is a framework of the four main principles of SOA, detail the compatibility of code, message format, content, service functions, and services. 1 Boundaries are explicit. This means there is no ambiguity about where each part of the code exists. Specifically, it is clear if the code resides inside or outside of the service. The same belief exists for data. It is known if a database table Lives Inside or Outside the service.

1 The border clearly means that there is no blur of every part of the code. Special, it is necessary to clear the code to stay in the service or outside the service. The same principle applies to data. It must be clear that the database table is residing within the service or outside the service.

2 Services are autonomous. This means each service has its own implementation, deployment, and operational environment. Therefore, a service can be rewritten without its partners being negatively impacted just as long as the correct message continues to be sent at the correct time.

2 Service Authority is that each service has its own implementation, deployment, and operating environment. In this way, a service can be rewritten without having a negative impact on his partnent, as long as you continue to send the correct message at the correct time.

3 Services share schema and contract, but do not share implementation. Schema describes the format and the content of the messages while contract describes message sequences allowed in and out of the service. What is not known is how implementation takes place. Consider the use of an Automated Teller Machine (ATM). Most people know how to interact with these machines. They know what buttons to press and they know the outcome. For example, John enters a pin number and then presses some buttons. Most people suspect a computer is Involved in The Entire Process. However, They Are Typically Unaware of How It is all import.

3

Service sharing Schema and contract, but not shared. Schema describes the format content of the message, but the contract describes the order of the message to enter and export services. I don't know how it is achieved. Consider the use of the ATM machine, most people know how to deal with these machines, they know what results should be made. For example, John inputs a string number and press the key. Most people think that the computer is involved in the entire process. However, they don't know how to implement it. [Translator: In what order are the keys to get money is to contact] 4 Service compatibility is based on a policy Formal criteria exist for getting "service from the service." The criteria are located in an English document that outlines the rules for using. .

4 Service compatibility is based on the presence of a policy to define "Service from The Service". The standard is an English document that specifies the framework of using the service. Currently, WS-Policy is a standardized declaration and programming method that is used to express policies.

THESE ARE The Basic Principles of SOA AND FORM The Basis for The Relationship Between Services.

There is a basic SOA principle and the basis of the relationship between services.

Challenges with SOA

Challenge SOA

No matter what technology is brought on board to deal with the plethora of complex IT systems that makeup today's enterprises, its beliefs and capabilities will be continuously challenged. In this section, attention is given to some of the existing challenges experienced by Service Oriented Architecture.

Regardless of any techniques, it will receive a continuous challenge for its confidence and capabilities when there is a complexity of the IT system to supplement existing enterprises. This section will pay attention to the challenges of some existing SOA experiences.

To date, two of the largest challenges experienced by SOA deal with explicit boundaries and autonomy. Explicit boundaries crisply define what is inside a service and what is outside a service. A service is comprised of code and data. Unlike functions and components, the code and data of different services are disjoint and data from one service is kept private from the data of another service. the disjoint collections of code and data reside within explicit boundaries called services. So far, two of the biggest challenges is to deal with the display of SOA Boundell and autonomy. Clear boundaries define those in the service, which are outside the service. The service consists of code and data. Unlike functions and components, code and data of different services are unlucky, the data of one service, relative to another is private. These mutually-independent code and data set, reside in the boundary of the display, that is, the service.

Autonomy speaks to the independence of services from each other. For example, Service-A is always independent of Service-B. As long as the schema and contract are maintained, no adverse impact is expected. As a result, each service is free to BE Recoded, RedEployed, or Completely Replaced Independent of The Other Service.

Autonomy means that each service is independent of each other. For example, service A is always independent and service B, as long as Schema and Contract maintenance, there will be no adverse effects. Such a result is that each service can be freely re-encoded, redeployed, or completely replaced by other services.

Even with autonomy and explicit boundaries, there are often other complications such as trust issues across boundaries. There needs to be trust between services at all times. To achieve this, a service must first decide on what kind of trust it wants and second, define its own style of trust. It is common for the rules that define trust to be modeled after real interactions across businesses. After all, it is issues such as credit card fraud that made everyone think about trust in the first place.

Even with autism and display, there are still other complexity, such as cross borders, trustedness [translator: should refer to authorization]. Service is always required to trust. In order to achieve this, the service must first decide which trust it needs, and then which type of trust itself. Model trust is general principles before cross-service actual interaction. After all, there is now a credit card fraud that makes everyone first think of trust. The Debate About Transactions

Controversy

Along with the beliefs and challenges that follow a technology, there are also debates. No matter where you turn there always seems to be a debate flourishing around some technology. Where SOA is concerned, one important debate is about transactions. On one side of the Debate, People Propose That Atomic (ACID) Transactions, Perhaps Implement with 2-Phase Commit, Be Used Across Service Boundaries.

Along with the trust and challenge of a technology, there is always a debate, no matter what technology you see, there seems to always have a lot of debate. SOA is related, an important argument makes it a business. Part of the debate, it is recommended that the ACID transaction is submitted in two sections and is used across service.

Note WS-Transaction IS Currently Involved with Defining Transactions That SPAN Service Boundaries.

Note that WS-Transaction is now in handing transactions across service boundaries.

On the other side of the debate, people believe a service should never hold locks for other services because this involves a great deal of trust that the transaction's completion and, hence, record unlock will occur within a reasonable amount of time.

The other part of the debate believes that the service should never be locked for another service, because the island involving a lot of trust on the completion of the business, and the record should be unlocked in a reasonable time.

Upon closer analysis, this debate is really about the definition of the word service. If two pieces of code share atomic transactions, are they independent services or is their relationship so intimate that they comprise one service. There will always be bodies of code connected by 2-Phase Commital; However, The Question IS About WHETHER or NOT TheY Are In The Same Service.

Further analysis, this debate is the definition of the word Service. Join two code to share an atomic transaction, they are independent transactions or their relationships so close to them make up a service. There will always have two submitted code, however, the problem is that they are in the same service. This paper explicitly focuses on some of the challenges that arise when two services do not share atomic transactions. Just as there are pieces of code that share atomic transaction through 2-phase commit, other cases do not. This paper will examine some of the implications .

This article shows the challenges of two services do not share a atomic transaction. Just like the code that exists, the code submitted to the shared service operation, there is also this unshared case. This article checks some independent code without sharing the application. Thus, for this article, serving this word is independent, autonomous, and separated by the scope of the transaction.

Operators and Operands

Operators and operands

In a Service Oriented Architecture, The Intertion Across The Services Reperest Business Functions. The Following Area Some Examples of Of Operators:

Please place-order. Please update-customer-address. Please transfeer-payment.

In SOA, cross-service interaction represents business functions. This mentioned the operation. There are several operators below.

Please place-order. Please update-customer-address. Please transfeer-payment.

Operators are part of the contract between two services and are always about the business semantics of the stated service Operators can also be a form of acknowledgement indicating the acceptance of an operator Consider the following examples..:

Acknowledge Receipt of Place-Order. Acknowledge completion of transfeer-payment.

The operator is part of the contract between two services and is always a service semantic representation. Operators can also represent an acceptance acceptance in a confirmation. As follows

Acknowledge Receipt of Place-Order. Acknowledge completion of transfeer-payment.

An acknowledgment has business-defined depths. As a result, there is a difference between acknowledging the request receipt to TRANSFER-PAYMENT and acknowledging the completion of the transfer. This all comes down to clearly defining the business semantics in the contract. A confirmation has The depth of the business definition, the result is that there is a difference between the request receipts and confirmation of the transfer completion of the transfer-payment. This is attributed to the clear business logic in the contract.

Operator messages may also contain many operands. An operand is defined as a piece of information needed to conduct an operation. It must be placed in the message by the sending service. In simplest form, operands are responsible for the parameters in messages. Some examples ORANDS include The Identification of a Customer Placing An ORDER or The Sku Number for a line it..

The operator message can also include a number of operands, one operand defines the information required for an operation. It must be sent in the message. In the simplest form, the operands are parameters in the message. Examples of some operands include consumers placing a order or for a SKU number.

http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig6.gif

Figure 6. Operator Messages with Operands

Let's consider how and where a service gets the Operands it Uses to prepare an operator message. Operands come from Reference Data, Which is Typically Published by The Target Service for the Operator.

Let us consider, how is a service to get an operand that it is used to prepare an operator message. The number of operats comes from the reference data, which is typically released by the target service.

Reference data is somewhat of a new kind of data in SOA. The word somewhat is used since versions of SOA have been in existence for decades with MQ, EDI, and other messaging systems. Similarly, before it was all computerized, humans were manually completing SOA-style operations. When customers wanted to order products from a department store, they filled out an order form and sent it in by mail. The department store catalog is reference data and the department store order is an SOA operation. reference data is SOA New data. This word has been used in different versions of SOA, including MQ, EDI, and other messaging systems. Similarly, before computerization, people have manually completed the SOA type operation. When consumers want to set their products from department stores, they fill in the order form and then send it via email. The storage directory of department store is to reference data, and the order of department stores is the operation of SOA.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig7.gif

Figure 7. Publication of Reference Data And Use of Operands

Figure 7 Reference data release and operand use

Outside Data: Sending Messages

External data: Send a message

Immutable and / or versioned data

Non-variable / add the version number

.. Data exists in many forms One type of data is immutable data Essentially, immutable data is unchangeable once it is written You can find immutable data almost anywhere in the real world The following are a few examples..:

The New York Times Edition of June 3rd, 1975 Is Unchangeable The First Edition of a Published Book Is Unchangeable The Words Spoken by The United States President On Television Arene Unechangeable

Data exists in many forms. One type of data is non-variable data. Essentially, non-variable data is once written, she can no longer change. You can show anywhere in the world to discover non-variable data. Here is some examples.

New York Times Weekly **** Book 1 Publishing date is the constant US president's callback, can not change

All immutable data have identifiers. An identifier ensures the same data is yielded each time it is requested no matter when it is requested or where it is requested. Therefore, if the same identifier is used then the same bit pattern is retrieved. For example, a Person Will Get The Same Pricelist Today If It is Retrieved from Joe's Internet Bazaar For Thursday, July 3, 2003. All cannot be changed. It is the same data to get the same data each time, no matter where the request is from. Therefore, if the same identifier is used, the same bit pattern will be obtained [Translator: Meaning should be the same DATA]. For example, everyone will get the same price list if It ques Joe's Internet Store July 3, 2003.

Another type of data is versioned data. Versioning is a technique for creating immutable sets with unique identifiers. Through the availability of versioning, a person can ask about the latest service pack (SP) for Windows NT4, or a recent edition of the New York ..................

Another type of data is version data. The version is a technology that uses unique identifiers to generate unambiguous collections. Through the version you can get, people can know the latest WINNT patch, or the latest version of the Times Weekly. The version is also an identifier: version-dependent identifier, version independent identifier.

Version-dependent identifiers include the desired version as part of the identifier. This identifier always retrieves the same immutable bit pattern. In contrast, version-independent identifiers do not include the desired version in the identifier. As a result, the process for resolving version -independent Identifiers To Its underlying Data Involves Two Steps:

Map from the Version-Independent Identifier To The Version-Dependent Identifier Retrieve The Immutable Bit Pattern of The Version

The version-dependent identifier includes the desired version as part of the identifier, such identifiers always get the same immerse bit mode [translator: refers to data]. Instead, the version independent identifier does not include the desired version. As a result, the data of the assistant version independent identifier identification contains two steps: version of the independent identifier to the version-dependent identifier mapping querying the version of Bit mode

The following is an example of the above steps from a real world perspective. A person visits the newsstand to buy a recent edition of the New York Times. This behavior involves deciding if today's paper or yesterday's paper is needed. Given the version-dependent identifier , today's paper, the person buys today's paper dated July 20, 2004. Ultimately, with version-independent identifiers the answer given will not be the same for each request. for example, if the exact event happens the following day, the person will receive A NewSpaper Dated July 21, 2004 and NOT JULY 20, 2004.

Here is an example of the above steps in the real world. One person comes to the newsstand, to buy a nearest New York Journal. This behavior includes deciding whether it is still today's newspaper. If it is a version-dependent identifier, today's newspapers, this person bought today's newspaper, July 20, 2004. Finally, if it is a version independent identifier, the answer will vary depending on the request. For example, a precise thing to have in the next day [Translator: It is definitely what you want to happen], this person wants newspapers on July 21, 2004, not July 20 newspaper.

Immutability of Messages

Message invariance

Evey Message Traveling Through a network maybe retransmitted in: message sult is guard:

NetWorks Retrying Messages. Those Pesky Retries Actually Being Delivered.

Each message from the network may have to be resended when the message is lost. Each message is sent to send zero or more times. Consider the following situation

Network Lost Message Network Retry Message (NetWorks Retrying Messages) Those Pesky Retries Actually Being Delivered.

IT IS IMPORTANT For Retransmitted Messages To Remain Unealtered No Matter How Many Times They Are Sent Or Else A Great Deal of Confusion and Unhappiness Would Ensue. Therefore, All Messages Should Be Immutable.

It is very important to keep the news that the message retained has not changed, no matter how many times they sent, otherwise, a lot of confusion and unhappy things will come. Accordingly, all messages to be immutable [Translator: even] message is retransmitted. Additional consideration needs to be given to messages traveling through the network In the absence of a reliable messaging framework using serial number and retries, the end application may see duplicate messages. Additionally, careful thought must be given to the life of the messaging framework and the life of the endpoint. Consider a case when long-running work may take weeks or months to complete. TCP / IP can not be counted on to eliminate duplicates in this situation. If the system crashes and is restarted, a different TCP connection is obtained and may result in duplicate messages being sent. Because confusion may arise from messages being resent, it is advantageous to have immutable messages so the same bits are Always returned.

There should be additional attention to the news that is transmitted to the network. A messaging framework that lacks a reliable use serial number and retry mechanism, interrupt application may receive a repetitive message. In addition, you must carefully consider the declaration period of the message transfer framework and the declaration cycle of the terminal. Consider a situation, long working wells is completed across data or even months. In this case, TCP / IP cannot be used as eliminating duplicate data. If the system crashes, restart, get a new TCP connection, and cause a repetition message. Since the message repeats will result in confusion, the advantage of using unality messages is that each time you get the same BIT stream.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig8.gif

Figure 8. ImmutAbility of Messages

Figure 8 Message is invalidable

To cache or not to cache

Cache or not cache

Most conversations on caching usually end with a warning against the practice. This is not one of those cases. Caching immutable data is acceptable and, indeed, recommended because each time the data is requested the same answer is guaranteed. There is no possibility of error In this Situation. As a result, the cache never has to be shot down. Caching Data That Is Not Immutable is Risky Because It Can Lead to Anomalies.

Each discussion about the cache will give a warning for practical as an end. This is not one of the things (this is not one of those caves.). The cache invariable data is acceptable, and it is actually recommended because the data is the same as each request. In this case, there is no possibility of error. As a result, the cache should not be disabled. The cache is not non-variable data is dangerous because it may cause an exception. It is also acceptable to cache versioned data since each version is immutable. There is never confusion over what data is returned from a cache involving a version-dependent identifier. The version-dependent identifier yields the same bits each time.

Since each version of the data is not variable, then the amount of the amount is acceptable. Returning data from a cache that includes version dependent identifiers is not confusing. The version-dependent identifier is always the same data each time.

Note It is not rebommended That Anything Be Cached if it is referred by a Version-Independent Identifier. The Results Yielded in this Situation Arene Unpredictable.

Note Not recommended cache points to any versions of independent identifiers. If it is not necessary, the result will be unpredictable.

Normalization and Immutable Data

Specifications and non-variable data

[Translator: What makes normalized normalized and non-standard DE-NORMALIZED ah]

Normalization is an essential design consideration for database schemas. Because normalization ensures each data item lives in one place, it is easier to ensure updates do not cause anomalies. This is illustrated in a classic example involving an employee-manager database. The manager's phone number IS Commonly Listed in Each Row for Each Employee In The Database. A Problem is Encountered When Trying to Update The Manager's Phone Number Because IT Lives In Numer Support.

Specifications are an important design consideration for database format design. Because of the normalization, each data item is only resided in one place, it is easy to confirm the update without causing an exception. This is validated in an example of an employee management. The manager's phone number is often a data in each employee database. The problem occurs when the phone number is to be managed because it resides in countless places.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig9.gif

Figure 9. Problems with de-normalization

Figure 9 Non-specific problems

If the data is immutable, it may be practical to allow it to be de-normalized. For instance, it is acceptable for email messages to be de-normalized since the messages can not change once they are sent out of a service. Likewise, if a message is sent between services and will be interpreted by the business logic of the services, it may be challenging to perform joins. Because of this, immutable messages frequently contain de-normalized information. If the data is immutable, then allowing it not Specifications are very practical. For example, you can make an email message make it unregistered because the message cannot be changed after sending. Similarly, the joining message will be sent by the message and will be parsed by the service logic of the message, then it may challenge the execution connection. Therefore, non-variable messages generally include non-standardization information.

Immutable Schema

Invariant format

Messages can be sent and resent, but at the end of the day if both the sender and the receiver do not understand the messages then nothing has been accomplished. As a result, every message needs a common schema. The schema used is typically referred to AS Meta-Data. in The Event The Meta-Data IS Ever Changed, Confusion Will Result. Accordingly, The Schema Used Must Always Be Known or Should Be Able To Be Located If The message is going to be processed.

The message can be sent and resend, but if it is finally transmitted and the recipient does not understand the message, it is equal to anything. As a result, each message requires an ordinary Schema. This schema is used as the original data. Once the original data changes, the problem will appear. Correspondingly, if the message is to be processed, the Schema must be alive or can be positioned.

Stability of Data

Stability of data

Ensuring the immutability of data across service boundaries eliminates many problems, but it does not ensure the message is understood. For example, a reference to President Bush made in 2003 means something different than a reference to President Bush made in 1990. People may fail to Notice The Reference Is To Two Different People and The '', misunderstand the message.

Make sure the invariance of data across service lines has eliminated a lot of problems, but it cannot guarantee that the message is understandable. For example, a reference to President Bush Made in 2003 Means Something Different Than A Reference To President Bush Made in 1990. People may not notice that this is two different people, so it may be wrong to understand this message. The notion of stable data is introduced as having an unambiguous interpretation across space and time. This leads to the creation of values ​​that do not change. For example, most enterprises never recycle customer identifications or SKU numbers. It is problematic to ensure the old interpretation no longer exists so these values ​​are permanently assigned. Consider a banking situation. If a single piece of customer information comes out of the bank's archive years later and the bank tries to look up the customer's identification, it had better not refer to some other customer . By NOT Reusing a Customer's ID, IT Remains Stable.

The concept of stable messages is introduced in the interpretation of interpretation of time space. This causes the creation of the non-changing value. For example, most companies never repeatedly use the user's proof or SKU number. If it is sure to explain no longer existence, because these values ​​should have a permanent assignment will have problems. Considering the situation of the bank, if the information of a bank user after a number of years, the bank is looking for prove to find this user, it is best not to point to other users. Stability is maintained by not reuse the user's ID. [Translator: Here is that every account of the bank has a unique user ID, so looks for]

Note It is also worth mentioning that anything that is current is also not stable. A reference to the current activity on a credit card is not stable because it does not clearly communicate when the snapshot of the activity was accurate.

Note that the following things are also worth mentioning, that is, when your card, anything is not stable. A reference to a current activity that points to a credit card is not stable, because it doesn't have a clear communication when the snapshot is exactly.

In summary, data that is distributed must be both immutable and stable. Versioning is an excellent technique to create immutable data. Finally, the data must refer to immutable schema. The combination of these, results in interpretations of the message that is invariant across space And Time.

In short, distributed data must be unstrenomed and stable. Version is a very good technology that produces non-variable data. Finally, the data must point to a non-variable Schama. These merges will result in the correct parsing of non-variable messages across time space. A Few Thoughts on Stable Data

Thoughts on stabilizing data

Everything sent outside must be stable data so the interpretation of each message continues to be consistent across valid places and times to ensure the information is understood. Even data inside is sometimes stable. Cases like these occur when the data sent outside is also kept on the inside. Take for example a shopping basket and the product SKUs inside the basket. SKUs sit in a shopping basket service until they are sent to the order fulfillment service. When the SKUs are in the shopping basket service, they must be stable because they are Living across multiple interactions with the inside.

Each of the transmitted data must be stable. Interpretation of each data is consistent, even if it is span time space, ensuring that each information is understandable. It is also very stable in the data inside. When the data is sent to the outside, he also saved internally. For example, a shopping basket and product SKU code in a shopping basket. The SKU code is unanimously saved in the shopping basket until they are sent to the order completion service. When the SKU code is in the shopping basket service, they must be stable, and they exist in a plurality of interactions.

Validity of Data in Bounded Space and Time

Validity of data within a specific time space

By bounding data in space and time, it is known where and when the data is valid. Placing an expiration date on data such as, "Offer is good until next Tuesday" is one example of the validity of the data in bounded time. There May Also Be Information On Where Data Is Valid. Examples Follow:

By defining the time and space of the data, it is when it is effective. Add a valid date to the data. For example, this price has been valid until next Thursday is an example of a data time effectiveness and some data validity. There are several examples below:

The Offer Is Only Good To Washington State Residents Data Is Valid Only on these Two Servers The Information Is Valid Only for the Acme & Sons Company Accounting Application

This price is only for Washington's resident data only on both servers. It is only valid for the Account application system with the ACME & SONS Company.

It is imperative that all valid data also be immutable and stable. Moreover, if valid data is retrieved then the same data should be produced and its interpretation should be unchanged. All valid data must be immutable and stable. Furthermore, if the valid data should be found, the same data should be generated, and its explanation should not change.

Before deciding data is valid everywhere and at all times, consider if ranges in validity are beneficial. If they are then document the constraints in the message. Ultimately, it is wise to define the validity of any data sent outside of a service.

It is reasonable to consider whether this effectiveness is reasonable before deciding whether the data is valid before any time space. If they are data in the message. Finally, the validity of the data that is not sent to the service is wise.

Rules for sending data in Messages

Send message Rule

The Following Table Offers Some Distilled Rules for sending Messages Outside of Service Boundaries:

The following table gives a carefully prepared Rule for sending messages.

Table 1. Rules for Sending Data

Identify The Messages

Identification message

Always Put A Unique ID in Every Message Increases a unique ID Part of The Unique ID May Be a Version in each message can be a version of this unique ID

Immutable data

Do not change the message

The Data IN A Message Must Be Immutable message must be an uncommitted Never Change The Contents of a Message on Retransmission never change the content of the resend message Always Return The Same Bits always returns the same data.

OK

TO

Cache

Cache

Since the id of the message returns the same amount, it is ok to cache a message Since the same data is obtained by the message ID, the cache message is OK's The Cache Will Never Cause IncorRectness cache never cause errors.

Define

Valid

Ranges

Define a valid boundary

Define The Valid Ranges of Space and Time Defines Effective Time and Space Boundary Ok To ALWAYS BE VALID Always define validity

Must

Bo

STABLE

Be sure to stabilize

EnSure the meaning of the message is unambiguous within the valid space and time ensures that the message is unambiguous within valid time and space

Outside Data: Reference Data

External data: reference data

What is reasoning data?

What is reference data

. Reference data is information published across service boundaries For each collection of reference data there is one service that creates it, publishes it, and periodically sends it to other services There are three broad uses for reference data:. Operands, historic artifacts, and shared Collections of data. Sometimes, The Distinction Between Their Uses is not rigid and may overlap. Application data is information that is released across the message boundary. For a collection of each reference data, there is always a service to create it, publish it, periodically send non-other services. There are three main applications for reference data: operands, historical data, and shared data collection. It is also the distinction between them is not obvious and can overlap.

Operands and Operators

Operations and operators

Operands Add Crucial Information Such as Parameters or Options to create the operator requests Sent Out for processing. The Following Aree Examples of Operands:

Operand adds critical information, such as parameters, or option to create operators for the processing process. Here are an example of an operand.

THE CUSTOMER-ID for the Customer Placing The Order Ordered To for the Order Date And The Price Agreed To for ToRDER

Set the user ID of the order user ID is expected to be loaded with the number of loading dates and agreed prices for each part of the ORDER

The Data for Operands Is Published As Reference Data. Reference Data I Typically Sent Out on Different Schedules As Required. Consider The Following:

The data of the operand is published as a reference data. The reference data requires the following examples to see the example below.

THE CUSTOMER DATABASE IS SENT DAILY As a Snapshot The Parts Catalog is Updated Weekly The Price-List Is Updated Daily

User database Send a snapshot part database daily update price list daily update

Versioned reference data is published by the authoritative service so its partners have the timely operands needed to ensure information accuracy. It is essential that the operator requests are processed understanding that the operands are derived from versioned reference data. This is just like specifying that an order TO a Department Store Catalog is based on the fall and winter Edition of the catalog. The version is released by the Authoritative service, so its partner has even an operand to ensure accuracy of the information. Operation request processing To understand the operand is from versioning reference data, this is critical. This is like a request to send to the store directory is based on the autumn directory or the winter directory.

Historic artifacts

historical data

Historic artifacts are another type of reference data Its purpose is documenting past information within the transmitting service Related services receive and use historic artifacts to perform other business operations Examples of historic data include...:

Historical data is another type of reference data. Its purpose is to record historical data created by service. Related service acceptance of the 10th corner to perform other business operations, examples of historical data include:

Quarterly Sales Results Monthly Bank Statements Monthly Bills

Every quarter sales result Each month's Bank Statements Every month's bill

The reference to monthly bills needs further discussion. Not only do monthly bills include historic artifacts about activity during the past month, but monthly bills also request customers make a payment. This request defines a business function. Therefore, monthly bills also behave as operators.

Further discussion is required for the reference of each month's bill. The monthly bill includes not only historical data from the previous month, and the monthly bill is required to make a checkout. This requires defining a business function. So every month's checkout is used as an operation.

The use of historic artifacts raises many privacy concerns. However, in almost all cases, historic artifacts are only shared between closely related services that are trusted, or the receiving partner is sent specific pieces of the service's data appropriate for the partner's viewing. An example of tightly related and trusted services involves quarterly sales results. These results are published by the sales supporting services and sent to the accounting department's services. Inventory status rollup is then passed to accounting. Alternatively, a bank statement or a phone bill sent to a customer Illustrate Historic Artifacts That Are Tranitted to a Single Partner. The use of historical data has led to many privacy. In most cases, in most cases, historical data is just a service sharing that is trusted by each other, or the receiving partner is SPECific PIECES of the service's data appropriate for the partner's viewing. An example of a close-related mutual trust service includes quarterly sales result. These results are released by the sales support service and sent to the account service. The directory status is also transmitted to the account. It can be replaced that a bank statement or telephone bill is sent to the user to prove the situation of historical data to a single user.

Http://msdn.microsoft.com/library/en-us/dnbda/html/dataoutsideinside_fig10.gif

Figure 10. Publication of Historic Artifacts

Publishing of historical data

Shared Collectes

Sharing collection

Reference data sometimes shares the same collection of data across an enterprise or different enterprises. Even after this collection of data is accessed across an enterprise, it continues to evolve and change. Typically, there is one special service that owns this information and is responsible for Updating and distributing new version of the data across systems. Examples of Shared Collections of Data Include:

Quote data Sometimes a business or different enterprise data collection is shared. Even if this data set across companies, it also continues to change. Typically, there is a special service that owns information is also responsible for upgrading and posting new versions. Data examples of shared collection include:

Customer database - It contains all the relevant information about the customers of the enterprise Employee database -. It contains information about every employee in the enterprise Parts database and pricelist -.. It contains descriptions of the parts, SKUs, and their characteristics Also included are THE PRICES for the Various Skus and The Discount Policies for Customers. Customer Database - It includes information employee database for all corporate user data - it includes information on all employees within the company

Parts database and price list - it includes part description, SKU, and their feature. Also include different SKU prices and discount strategies for users.

It is worth noting that the version distributed across an enterprise is never the latest version of the data. It is generally impossible to have universal knowledge of the latest information in a loosely coupled distributed system. As a result, those interested in the data must settle for a recent version because only the authoritative service knows the latest state of the information. Even if the authoritative service tries to meet a request for a more recent view of the information, the data can change by the time the partner system receives it. by the time the partner service sees it, the authoritative service can not guarantee that it is the most recent copy. nothing, across the enterprise releases never latest version of the data (It is worth noting that the version distributed across an enterprise is never the latest Version of the data.). In a distributed loosely coupled system, it is basically impossible to obtain the latest information. As a result, Those INTERESTED IN THE DATA MUSESE INTER A Recent Version, because only Authoritative service knows the latest information status. Although the Authoritative service is trying to meet the request for the latest information, when Partnet accepts data, it may have changed. When Partner saw, the Authoritative Service could not guarantee that this is the latest copy.

Although shared collections of data have proven their place in the world, they represent a huge challenge for most enterprises. Many different applications have their own opinions of the correct value of the data for a customer. For instance, differences about what constitutes a customer exist . there is also a difference of opinion on the data needed to describe a customer. lastly, the representations of certain data items describing a customer are not semantically aligned across different applications. However, there is currently a trend to consolidate these disparate opinions. This IS, UNFORTUNATELY, MUCH LIKE HERDING CATS! Despite sharing collection data has proven their role, they have made tremendous challenges for most companies. Many applications have their own views about the correctness of data. For example, what determines the difference between the existence of the user. There is also a difference between what kind of data describing the user. Finally, the representation of the specific data item of the user is not consistent between the various applications. However, there is now a trend of strengthening this different perspective. This is very unfortunate, it is like Herding Cats. The general course of action is to create an authoritative source to manage the state of each shared collection of data and distribute a recent version to those requesting it. Disparate applications, for instance, are evolving to receive descriptions of the shared data from the customer manager service. In an attempt to align this data, the schema for each customer includes enterprise wide standard fields and includes extensions used by special applications. However, nothing can align perfectly across an enterprise. Also, some of the interested parties have their own extensions, Which Should Be Managed By The Authoritative Source. This Presents Yet Another Challenge. The usual approach is to create an Authoritative source to manage the status of shared data and publish the latest versions of these data to those partner. For example, different applications should accept shared data from the customer management service. To unify this data, each user's Schema includes a wide range of corporate standards, including extensions of special applications. However, there is nothing to do across enterprises.

Moreover, some interested organizations have their own extensions, which should be managed through the Authoritative resources. This is another challenge. Requesting Changes to Shared Data request to change the shared data Sometimes a service other than the authoritative service wants to see changes made to the contents of the shared collection of data. Because this service can not directly update the contents itself, a request is sent to the owner of the data. This allows the authoritative service to manage the data. These requests must be business operations that are represented as service operators across services. Only the supported business functionality that is desired to export from the authoritative service will be implemented as operators. If the authoritative owner of the data agrees to make a change, the change is subject to the business logic enforcement of the authoritative owner of the shared collection. There are also situations when a new version of the entire shared collection of data is transmitted to the partner services INSTEAD OF A FEW CHANGES. Sending a Copy of the Entire Customer Database to the Partner Systems IS One Example. Sometimes, in addition to Authori TATIVE service, other services want to know changes in shared data collection. Because this service cannot directly update the data content, it is necessary to send a request to the data owner. This is the Authoritative Service Area Management Data. These requests must be a business operation, expressed by the service operator. Only supported business features that you want from the Authoritative service can be used as an operator. If authoritatice data owner agreed to change, Note: No matter how minor or major, any changes made must be considered carefully since changes to shared collections of data have business side effects that must be implemented by the authoritative service.

Note: No matter how much changes, you must be careful because changes in the shared data set will have an impact on the business. So you must pass through the Authoritative service.

What about Optimistic Concurrency Control? About the most optimistic concurrency control Optimistic concurrent control refers to when a reader makes changes to data and then proposes these changes to the authoritative service. The reader sends the original view of the data back to the authoritative service. If the ORIGINAL DATA is Still Intact, The Authoritative Service Makes The proposed Changes. It is to mean that when a Reader changes the data, then submits the change of the AuThoritative service. This Reader returns to the Authotitative service. Joining this original data is still not changed, then the Authoritative service performs submitted changes. Sometimes, IT IS proposed That Services Use Optaries. This Makes Several Assumptions: Sometimes the proposed service uses the optimized concurrent control of cross-service boundaries. The important makes the following ideas:

The outside service is allowed to read the data. However, privacy issues and encapsulation issues may make this situation problematic. The owner of the data trusts the business logic of the outside service. After all, some logic must have executed on the outside to create the image of the data that is being proposed for write. Updates across service boundaries have little to do with optimistic concurrency control. Instead, they have a lot to do with the logic surrounding it. It is all about trust and who can make changes to the data. Services by nature are distrusting so they will not allow foreign business logic to create data to be stored in the local database. Only the local business logic can create data to be stored in the local database. Therefore, it is important for partner Services to be aware the data sey to be, but shop, ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, mes, people offer a counter example to the discussion above wherein they propose that the management of a customer record should be done using optimistic concurrency control. Let's consider why this is problematic across service boundaries. Figure 11. Versions of a shared collection and a request For Update One May Initially Believe That It Is Appropriate To Allow The SalesPerson To Update Some Fields of The Customer Record Directly and Submit To The Authoritative Service As a "Write"

assuming there is no optimistic concurrency collision. This is problematic for a couple of related reasons. First, the authoritative owner of the data does not want to yield control of the ability to change the data to some other service's business logic. It wants to be responsible for the integrity of the data and, hence, want its own business logic to be responsible for the change. Second, the change to the field may have business implications that need enforcement. for example, changing the address may result in tax implications for the customer, changing the responsible salesperson, and ensuring that any in-flight shipments are redirected. Therefore, it is not enough just to change the field in the customer record. in summary, it is essential that interactions with the authoritative service be oriented around Business Functions Such AS "please update Customer Address." Publishing Versioned Reference Data TO Ency Reference Data IS Not Mixed Up, The Publisher First Defines a name . For the data Version numbers are then added to each data update Examples of versioned reference data involving operands, historic artifacts and shared collections follow:. Operands: A price list dated Monday, July 19, 2004 Historic artifacts: A request is made for Joe '

s February bank statement from two years ago Shared collections: A customer database dated Thursday with a 10am timestamp Updated information is always versioned to distinguish between copies of data When the information is ready to be sent, many transmission techniques are available like messaging or file. copy. Currently, FTP is the most common transmission technique in use. Ultimately, it is not very important what technique is used to transmit information. What is important is the way operands, historic artifacts, and shared collections work with cross-service computing. Data on The Inside Until Now, Discussion Has Focused on Data on The Outside?

the transmission of messages across networks, the importance of immutable and stable data, and data publication across services. The next section focuses on data on the inside. Messages Are Data All services receive messages. These messages contain operators asking the service to perform a function . The function may be a business instruction or perhaps a product order. The function may also be to accept some incoming reference data. Once the services receive the messages, they record and commit them as data in a Structured Query Language (SQL) database. This ensures the data is stored and retrievable. Next, a transaction takes place that marks the incoming messages as consumed. As a part of the transaction, outgoing messages are queued in the local database for later transmission. Finally, the whole transaction is atomically committed .......................... With the possibility a transaction may abort, outgoing messages are never sent until the transaction is processed to ensure message transmission is atomic with the rest of the transaction. If for instance, a message is sent and then the transaction is aborted, the message may still be processed even when the transaction failed. The atomicity of the transaction is violated in this situation because the transaction has not been completely undone. in addition to the transactional support achieved by storing the incoming messages in the SQL database, there are business benefits. The Contents of the Messages Can Be Easily Retrieved For Different Purposes Such as Audits and Business Intelligence Analysis.

As an added benefit, data in a SQL database allows for management and monitoring of the ongoing work to be based on SQL queries Kinds of Data Inside Services Inside of services, three classes of data are found:. Table 2. Data inside servicesReference Data from Other Services

This reference data is transmitted by one service to another service that reads and stores the data This includes three types of reference data:.. Operands, historic artifacts, and shared collections Periodically, new versions of the reference data are received and stored internally along with The appropriate Version Identifier. Messages (Operators and Responses)

Messages Refer to Both incoming and outgoing Operators (Requests) and their responses. Service-Private Data

Service-private data is never directly exposed outside of the service. Note: this data is frequently exposed Indirectly Through Business Logic.

The following sections examine the characteristics and uses of the three classes of data mentioned in the above table. Service-Private Data Service-private data resides inside a service and is protected by the business logic of that service. Its contents are not readily known or available to anyone besides the service in which it lives. The only way to read service-private data from outside the service is by calls through the business logic, which controls what data is exposed. Typically, this data is heavily processed to yield a particular result? highly specific information. Consider a bank's ATM. Customers are not aware of the bank's backend from their account management system data. Customers may only see their account balance or their last 10 banking transactions. This information has all been heavily processed by the bank's Business logic. The only way to change the service is by subsmitting a business operation to the service. for instance, alterin G Bank Data May Occur WHEN A Customer Performs a Transaction Such as a withdrawal. This Transaction Changes The Bank '

s backend service-private data indirectly through the business operation of the withdrawal. Replication of Reference Data A single publisher commonly sends reference data to many subscribers. Since reference data is both immutable and versioned, it is easy to replicate across different services. It is also easy to keep many copies of the data since no semantic ambiguity exists. Reference data may also be imported into a service. As it is read into a service, it may be processed, reformatted, and indexed. Data stored in the service remains immutable . While the syntax and internal representation of the reference data may be changed to suit the needs of the service, the semantics remain intact and are considered a representation of the same immutable data.Note Reference data stored inside the subscribing services are replicas. However, .............. ..

Figure 12. Transaction use of data on the inside Data:.. Then and Now Significant differences exist between the temporal interpretation of data inside services and outside services This section examines the different perspectives and uses of time in a service oriented architecture Life in the Now : Transactions and Inside Data Transactional systems have worked hard to provide the application developer with a sense they are alone manipulating the database Serializability refers to ensuring that for all transactions, any other transaction that interacts with the database appears to occur before or after the transaction. in question. It is reasonable to consider that transactions, as they are executing, live in the "now". Due to serializability, there is no possibility that anything else is happening concurrently from the application's perspective. Although subject to security, the application is Able To Examine And Modify Almost Anything In The Database Viewing The Most Up-to-Date Informa tion possible. This leads to a perspective that the application lives firmly in the "now". Inside a service, the business logic of the service is dealing with only the latest-and-greatest view of the service's private data. In this fashion, IT is said That the service logic is discount

of the service and its service-private data Life in the World of Then:. Data on the Outside When operators are sent in messages, they are requests for business functions to be performed In effect, the sender is hoping the service will perform the. business function in the not-too-distant future. As the transaction commits on the sending node, it is perfectly clear the requested operation has not yet occurred, but will happen in the near future. Consider the various kinds of reference data sent between services and the temporal semantics of the data As discussed above, reference data falls into three broad categories:.. operands, historic artifacts, and shared collections operands describe the data used to form an operator request for a business function Just like a department store catalog. , Operands Are Typically Valid for a Specified Amount of Time. Outside of this Time, The Operands Are LIKELY TO BE INVALID IF USED IN The Creation of An Operator. While this Range of Time Is Likely T o include the present, it clearly is not about the immediacy of the "now". It is a supported range of "then". Historic artifacts describe what went on inside the publishing service in the past. There is no information about the use of historic artifacts dealing with the present or the future;. it is only about the past Shared collections of data are also about the past For example, the authoritative service may publish a view of the state of the enterprise's customers on a daily basis Partner.. Services do their work based on Last Night's View of the State of the Customers. Again, The Perspective Is One Dealing with "Then"

. Services: Dealing with Now and Then One of the biggest challenges in the transition to Service Oriented Architectures is getting programmers to understand they have no choice but to understand both the "then" of data that has arrived from partner services, via the outside, and the "now" inside of the service itself. The semantics of the business functions provided by the service must alleviate this tension. by abstracting and loosening the behavior supported by services in their messaging contracts for business functionality, it is possible to cope with the difference between "then" and "now". This is exactly what has been seen for generations in cross-business work. for example, the department store catalog includes many different products and guarantees the price as shown in the catalog for more than six months . Business logic and the intelligent design of the service contracts can Cover with the impedance between "the" and "now"

. Representations of Data:. Inside and Outside The remainder of the paper focuses on the representations of data on the inside and outside It also analyzes and compares three models, Extensible Markup Language (XML), Structured Query Language (SQL), and objects. The information presented ultimately shows seminal differences between data inside a service and data sent outside the service. Also revealed is that the strength of each model in one use becomes its weakness in another use. Inside and Outside Data Data can be broken down into two main classes, data on the inside and data on the outside. Data on the outside is sent across service boundaries in the form of messages and include business-function and reference data, which must be understood by both the sender and the receiver. The data is Always Immutable and Can Be Versioned. Since It Travels Between Services, Versions Are Likey Stored As Replicas by The Receiving Services. Conversely, Data On The Inside Lives In The Service and it is rarely sent out of the service. If it is transmitted outside, it must be processed by the business logic. This class of data is by nature private to the service and encapsulated by code. Below is a table providing additional information on both classes Of Data: Table 3. Data INSIDE VS. Data OutsideImmutAblenormalizationIs InterestingStableOutsideSidAyesno: ImmutableYesIndAnoyesNot Necessarily

The table identifies data on the outside as always immutable. This makes the notion of normalization unimportant. Yet, immutability is not enough because data on the outside must also be stable so its meaning is clearly understood across different times and locations. Versioning and time stamping are recommended to make data stable. Although stability is not a concern for data on the inside, it can be stable. for instance, the data can include stable items if it refers to data being sent to the outside. Since data on the inside is Not Necessarily Immutable, IT Should Be Normalized to Prevent Update Anomalies. Bounded and UNBounded Data Reperesentations let '

s consider the ways in which SQL and XML represent their data and the implications on the scope of that representation. All data stored inside SQL databases live within the bounds of the database. Therefore, value based comparisons are only meaningful if the domain of the values is the same. Interpretation of a SQL database outside of the database itself is impossible. The scope of the transaction used to modify the database defines the temporal bound for relating values ​​contained inside the database. for instance, if the transaction is committed and a copy of the data is sent outside the service, the underlying values ​​may change before the copy is used. The interpretation of the values ​​after they are unlocked is subject to interesting semantic anomalies and is usually avoided. lastly, relational data also has a tightly managed schema The Schema Is Modifiable Through Data Definition Language (DDL) WITHIN A Transaction. DDL IS Usually Tightly Associated with the SQL Database. Indeed, as soon as one transaction commits, the next may change the DDL that made the previous transaction meaningful! This extremely flexible behavior is correctly defined only within the bounds of the database. Unlike SQL, XML documents and their messages are unbounded because of its open schema Xml '

s schema definition allows independent creation of the schema, which lets people design their own customized markup languages, or borrow portions of other schema. Moreover, each schema is identified with a Universal Resource Identifier (URI), indicating an immutable version of the meta- data. As a message is sent, the URI for its meta-data unambiguously specifies the schema for interpreting the message. This meta-data remains invariant across space and time. Another matter that sets XML and SQL apart is that XML uses references and not values ​​to connect information. Connections between sub-trees and across documents are done through references, which are implemented as URIs. When implemented as URIs, references are an unambiguous mechanism for connecting data together that remains intact in the face of schema changes, location changes And Temporal Changes. Because XML Information Lives in The "TEN" and is always referring to the pas or the full, it can be unambiguously interpreted anytime. The notion of "now" is difficult across systems that do not share atomic transactions. This ability to specify "then" in the semantics of the data makes it interpretable both anytime and anywhere. SQL, living in the intimacy of the "now "within the SQL Database Cannot Be Accurately Understood Except in The" now "

and inside the bounds of the SQL database or its surrogates. Characteristics of Inside and Outside Data The next section takes a more in depth look at data on the inside and data on the outside and further differentiates between the two by comparing message data, reference data , and service-private data against numerous characteristics. Table 4. Characteristics of data on the inside and outsideOutside DataInside Data Message DataReference DataService Private DataImmutable? YesYesNoRequires Open Schema for Interoperability? YesYesNoRepresent in XML? YesYesNoEncapsulation Useful? NoNoYesEncapsulated AccessNoNoMaybeLong-Lived Evolving Data with Evolving SCHEMA? NONO: IMMUTABLE VERSIS ISYESYESSSTORE IN SQL? YES: COPY OF XML Stored In Sqlyes: Copy of Xml Stored In Sqlyes

Message data and reference data, both data on the outside, are similar in that they are both immutable with an open schema, and best represented in XML. Service-private data, on-the-other-hand, promotes encapsulation which is the opposite of an interoperable open schema. Even schema changes in different ways with data on the inside and data on the outside. For instance, when the message schema is changed, explicit versioning of the schema is used. The evolution of data on the inside may occur vibrantly as DDL changes the current state of the schema. lastly, one reason both incoming and outgoing messages are shredded into SQL is because business intelligence is an important part of all data regardless of their location, inside or outside. Usually, the amount of XML shredded for queries is based on the amount someone wants analyzed. The extensibility of XML means that shredding is sometimes easy and sometimes more challenging as data may arrive that does not map to the schema. Once the different kinds of data are identified and their functions understood, most people start to wonder what technologies to use. The following section examines three models, XML, SQL, and objects, and their representation of data. What about Objects?

Most people know about the power of object-orientation to facilitate software engineering. It, too, has a place in the battle for the representation of data. People have seen object persistence, and object-oriented databases become popular and, sometimes, not live up to expectations. Still, there are important forces that encourage the use of object-orientation as a means of representing data. The biggest advantage objects have over SQL and XML is that they provide encapsulation. Data being stored are hidden from the user of the data and only the behavior of the methods provided by the object is visible. This is very similar to the way services expose business functionality through the messages defined by their schema and their contracts. The seminal difference between objects and services is that services never share data Except As Reference Data. This is a Much Looser Relationship That Exists Across Objects. Still, The Use of Objects To Implement Services IS HIGHLY Recommended. IT IS difficult to believe that anyone would want to implement a service without the benefits of an object-oriented environment If a service is implemented using objects, it is opaque to all of its partner services The ruling triumvirate:!. XML, SQL, and objects It Is Interesting to Know That Each Model '

s strength is simultaneously its weakness. For instance, it is the independence of schema definition coupled with a reference-based hierarchical representation, and the temporal interpretation of the data, which make XML wonderful for communicating across services. These immutable messages are easily created and interpreted across different services. These features derive directly from the unbounded nature of XML. Still, these features of XML for the "outside" are debilitating weaknesses on the inside. It is problematic to query, shape, and update XML with the richness available to normalized data, representing the "now", and stored in SQL. These weaknesses are also directly from the unbounded nature of XML. Because of its characteristics, SQL makes a great tool for representing data on the inside of services. These strengths are inextricably linked To The Bounded Nature In Both Space and Time of Sql, Which make it fantastic for representing data on the "inside". unlike XML, SQL HAS ST rong querying capabilities. SQL's makes comparisons between almost anything within the bounds of the database. Because of SQL's bounded nature, however, it is incapable of the strengths of XML in the "outside"

. SQL does not offer independent definition of schema as it depends heavily on a centralized and tightly coupled DDL. Neither model has encapsulation capabilities. In XML, encapsulation is impossible because of its open schema. Encapsulation is also unachievable and not enforced by SQL since data changes only by UPDATE DML. Unlike XML and SQL, objects and components thrive on encapsulation. by its very nature, encapsulation prevents the arbitrary comparison of any data since the data is not visible. Therefore, it is impossible to perform queries. Extensibility and independent definition are also impossible in this model since encapsulation implies that the schema is concealed. in summary, XML thrives in the world of communicating requests, responses, and reference data between services. It provides all of the functionality, scalability and granularity required by messages. In Term of Storing Data, SQL Database Is a Leader Offering Many Outstanding Benefits Like Storing Incoming and O utgoing messages. Its capabilities are further bolstered when utilized for audits, compliance, or business intelligence. When building a service, objects are recommended because encapsulation facilitates the construction of software. Figure 13. XML, SQL, and objects working together In the end, THIS INFORMATION IS NOTE PRESENTED TO LOBBY FOR ONE MODEL OVER ANOTHER. ILLUSTRATE IS OFFERED TOELUSTRATE A FASCINATING FACT? Each Model '

s strength is at the same time its weakness. It is important to recognize, however, all three models are critical in a Service Oriented Architecture. Conclusion Conclusion This paper examines an intricate part of SOA, data inside a service and data sent outside the service boundary. a discussion of the roles and relationships between services, messages, and different technology models were explored to illustrate the difference between the two kinds of data. this article explains the intricate part of the SOA, not data service both inside and outside. Discuss roles and relationships between services and messages. Different technical models have been studied to explain the difference between these two data. Services are connected only by messages otherwise;. They are independent and behave differently from each other The messages sent between services describe a business function and contain operands that commonly express parameters or options for the operation This is a much freer and less intimate relationship than. traditional distributed systems. Because services are different, atomic database transactions are not shared across service boundaries. The uncertainty of joint decisions is handled by the business logic of the interacting services. only use the message service connection. They are independent, the behavior of the project is different, and the message is transmitted between the service to describe business functions, which includes operands - generally parameter or operation options. This is more free than traditional distributed systems, reduces the close relationships between each other. Because the service is different, the atomic database transaction cannot be shared across the service limit. The uncertainty of the connection is solved by interacting business logic. Messages are also different. Once a message is outside the service boundary, it must be immutable. In addition, special attention must be given to the stability of the data. Stability ensures the data is understood across space and time. Message is different. Once the news is outside the service, it will not be variable. In addition, it is necessary to give data stability. Stability ensures that the data across time space is understood.

Reference data plays an important role in messaging. It refers to data published across service boundaries. Operands, historic artifacts, and shared collections are all types of reference data. Operands are parameters or options used to create operator requests sent out for processing. Historic artifacts describe past events that took place inside the publishing service. Shared collections of data are used by multiple services. They are also constantly evolving. As a result, partner services usually only have access to a recent version of the data. reference data transmitted message Aspect has played an important role. It refers to data released across the service. Operand, historical data, and sharing interpretation are all types of reference data. The operands and parameters or options are used to create an operation request and send it to the handler. Historical data describes events that have happened within the release service. Sharing data sets are used by multiple services, they are constantly changing. The result is that Partnent services often get the most recent version of services. When discussing the representation of data inside and outside of services, SQL, XML and Objects all have a worthy place. Interestingly, the essence of what makes one of these models strong in one area of ​​use also makes it weak in another area of ​​use. THIS II REAON for the LONGEVITY OF THE DIFEENCES ACROSS The Communities of Specialists in Data Reperestation. When the service inside and outside data is expressed, SQL, XML, objects have their Worthy Place. Interestingly, these models have an advantage in an aspect, then they must have weaknesses in other ways. This is the reason for the longevity of the differences across the communities of specialists in data representation. Finally, data is different outside a service from the inside of a service. Data on the inside is described as living in the "now." The data is usually private to the service and encapsulated by service code. On-the-other-hand, data on the outside lives in the past. It is passed in messages and understood by both the sender and receiver. Finally, within the service external data It is different. Service internal data is described as "now", which is generally packaged by service code.

On the other hand, the service external data represents "past", which transmits the information that serves both parties understand. About the Author

Pat Helland has 25 years of experience in the software industry and has been an architect at Microsoft since 1994. He has worked for more than 20 years in database, transaction processing, distributed systems, as well as fault tolerant and scalable systems. Pat worked at Tandem Computers designed TMF (Transaction Monitoring Facility). He was one of the founders of the team that implemented and shipped Microsoft Transaction Server (MTS), now COM . Pat has recently focused his thinking on loosely coupled application environments. Pat can be reached at Phelland@microsoft.com.