Serialization Uses Of Serialization Consequences Of

In computer science, serialization means to force one-at-a-time access for the purposes of concurrency control, or to encode a data structure as a sequence of bytes.

This latter form of serialization (which is also referred to as marshalling) involves taking a data structure or object and encoding it into a regular and usually architecture-independent form, suitable for archival to a file, piping to another application, or, by extension, transmission across a network. Usually the encoding takes the form of a byte stream (a sequence of bytes). When receiving a serialized stream, the encoding process is reversed to get a copy of the original data structure.

1 Uses of serialization

For some of these features to be useful, architecture independence must be maintained. For example, for maximal use of distribution, a computer running on a different hardware architecture should be able to reliably reconstruct a serialized data stream, regardless of endianness. This means that the simpler and faster procedure of directly copying the memory layout of the data structure, cannot work reliably for all architectures. Serializing the data structure in an architecture independent format means that we do not suffer from the problems of byte ordering, memory layout, or simply different ways of representing data structures in different programming languageAn alternate rewrite has been has been. Please refer to it for large rewrites. A programming language or computer language is a standardized communication technique for expressing instructions to a computer. It is a set of syntactic and semantic rules uses.

Serialization however, in some forms, has the disadvantage that since the encoding of the data is serial, merely extracting one part of the data structure that is serialized means that the entire object must be reconstructed or read before this can be done. The serialization capabilities in the Cocoa framework, NSKeyedArchiver, alleviate the problem somewhat, by allowing an object to be archived with each instance variable of the object accessible by using a key.

2 Consequences of serialization

Serialization, however, breaks the opacityA substance or object that is opaque is neither transparent nor translucent . It does not allow light to pass through it. The property of being opaque is called opacity . Degrees of opacity are converse to degrees of transparency. In science the phrase an of an abstract data typeAbstract data types or ADTs are datatypes described in terms of the operations they support—their interface—rather than how they are implemented. An ADT consists of two components: an interface and an implementation. Users of an ADT are aware of the inter by potentially exposing private implementation details. To discourage competitors from making compatible products, publishers of proprietary softwareProprietary software is any closed-source material which fundamentally means that the user does not control what it does or cannot study or edit the code. The Free Software Foundation defines it as any software that is not free software or is only partial often keep the details of their programs' serialization formats a trade secretIntellectual property A trade secret is a confidential practice, method, process, design, or other information used by a company to compete with other businesses. It is also referred to in some jurisdictions as confidential information. The concept is tha. Some deliberately obfuscateIn computing, obfuscation refers to the deliberate act of nondestructively changing either the source code of a computer program or machine code when the program is in some compiled or binary form, so that it is not easy to understand or read. Binary obfu or even encrypt the serialized data.

Yet, interoperability requires that applications be able to understand the serialization of each other. Therefore remote method call architectures such as CORBA define their serialization formats in detail and often provide methods of checking the consistency of any serialized stream when converting it back into an object.

3 Human readable serialization

There is a push to redefine, or provide an alternative to the standard serialization protocol that uses XML and produces a human readable encoding, which started in the late 1990s. Such an encoding could be useful for persistent objects that may be read and understood by humans, or communicated to other systems regardless of programming language, but this has the disadvantage of losing the more compact, byte stream based encoding, which is generally more practical.

4 Serialization in programming languages

Several object-oriented programming languages directly support object serialization (or object archival), either by syntactic sugar elements or providing a standard interface for doing so.

Some of these programming languages are Smalltalk, Objective-C, Java, and the .NET family of languages.

4.1 Serialization in Objective-C

In the Objective-C programming language, serialization (most commonly known as archival) is achieved by overriding the write: and read: methods in the Object root class (NB this is in the GNU runtime variant of Objective-C, in the NeXT-style runtime, the implementation is near identical).

4.1.1 Example

The following example demonstrates two independent programs, a "sender", who takes the current time (as per time in the C standard library), archives it and prints the archived form to the standard output, and a "receiver" which decodes the archived form, reconstructs the time and prints it out.

When compiled, we get a sender program and a receiver program. If we just execute the sender program, we will get out a serialization that looks like:

GNU TypedStream 1D@îC¡

(with a NULL character after the 1). If we pipe the two programs together, as sender | receiver, we get

received 1089356705

showing the object was serialized, sent, and reconstructed properly.

In essence, the sender and receiver programs could be distributed across a network connection, providing distributed object capabilities.

4.1.1.1 Sender.h

#import #import #import @interface Sender : Object { time_t current_time; } - (id) setTime; - (time_t) time; - (id) send; - (id) read: (TypedStream *) s; - (id) write: (TypedStream *) s; @end

4.1.1.2 Sender.m

#import "Sender.h" @implementation Sender - (id) setTime { //Set the time current_time = time(NULL); return self; } - (time_t) time; { return current_time; } - (id) write: (TypedStream *) stream { /* * Write the superclass to the stream. * We do this so we have the complete object hierachy, * not just the object itself. */ [super write:stream]; /* * Write the current_time out to the stream. * time_t is typedef for an integer. * The second argument, the string "i", specifies the types to write * as per the @encode directive. */ objc_write_types(stream, "i", ¤t_time); return self; } - (id) read: (TypedStream *) stream { /* * Do the reverse to write: - reconstruct the superclass... */ [super read:stream]; /* * And reconstruct the instance variables from the stream... */ objc_read_types(stream, "i", ¤t_time); return self; } - (id) send { //Convenience method to do the writing. We open stdout as our byte stream TypedStream *s = objc_open_typed_stream(stdout, OBJC_WRITEONLY); //Write the object to the stream [self write:s]; //Finish up - close the stream. objc_close_typed_stream(s); } @end

4.1.1.3 Sender.c

#import "Sender.h" int main(void) { Sender *s = [Sender new]; [s setTime]; [s send]; return 0; }

4.1.1.4 Receiver.h

#import #import "Sender.h" @interface Receiver : Object { Sender *t; } - (id) receive; - (id) print; @end;

4.1.1.5 Receiver.m

#import "Receiver.h" @implementation Receiver - (id) receive { //Open stdin as our stream for reading. TypedStream *s = objc_open_typed_stream(stdin, OBJC_READONLY); //Allocate memory for, and instantiate the object from reading the stream. t =

4.1.1.6 Receiver.c

.htm#import "Receiver.h" int main(void) { Receiver *r = [Receiver new]; [r receive]; [r print]; return 0; }

4.2 Serialization in Java

Java provides automatic serialization which only requires that the object be marked by implementing the Serializable interface. For some not-so-clear reason, the process of serialization is handled in a very idiosyncratic manner. There are no serialization methods defined on the Serializable interface; implementing the interface just marks the class as "okay to serialize." Java then handles serialization internally. The language does though allow the developer to override this by implementing another interface, the Externalizable interface, which includes two special methods used to save and restore the object's state.

The standard encoding method uses a simple translation of the fields into a byte stream. Primitives as well as referenced objects are encoded into the stream. Each object that is referenced by the serialized object must also be serialized and if any in the reference graph is not serializable, then serialization will fail (unless the developer has redefined the serialization for an object and truncates some portion of the reference graph).">Sender alloc] read:s];

objc_close_typed_stream(s); } - (id) print { fprintf(stderr, "received %d\n", [t time]); } @end

4.2.1 Receiver.c

#import "Receiver.h" int main(void) { Receiver *r = [Receiver new]; [r receive]; [r print]; return 0; }

4.3 Serialization in Java

programming

<Hide>

Home > Serialization