Usually, runtime system (memory manager of runtime system is in our interest) uses dierent prim- itives to increase and decrease the address space of \heap" and \stack"; \heap" is the memory space that houses dynamically allocated objects, whereas \stack" is the memory space for keeping the local variables of functions when they are activated. Figure 2 depicts how the address space of a running process, especially \heap" and \stack", grows. For example, \gcc", the gnu c compiler, provides \obstack" (object stack) routines for resizing the stack space and allocation libraries for resizing the \heap". When a user program needs more space, it issues an allocation request. User process memory manager, in response, returns the address of the block of memory as large as the requested size. If the process memory manager cannot successfully respond to the request, it will acquire more memory from Operating System (OS) memory manager via kernel system calls. Unix like OSs provides two families of system calls for such purposes: \brk, sbrk" and \mmap, munmap". \brk" returns so- called break point of the user process address space. Via \sbrk", user process memory manager is able to either acquire more memory from OS or release some of the unused portion of its available memory back to the OS. One of the main concerns with \sbrk" is that the caller is responsible for page alignment of the returned addresses. The functionality of the other
When an object is brought into main memory, its fields must be translated from the long form to short form. The object is assigned an appropriate short Oop (one to which its long Oop hashes), a block of memory is reserved for it, and all of its fields are translated from long Oops to short Oops. Leaves . Leaves are pseudo-objects that represent an object on secondary storage. They have a short Oop hashed by that object’s long Oop and ROT entry, but their image in memory only contains a length word, disk address words, and the delta word. Their image contains no class word or fields. Leaves, therefore, take only up to 4 words of memory, whereas an average object (object in its expanded form) takes up 13. Leaves are created without looking at that object’s image on secondary storage. This is very important, since a major cost in virtual memories is the number of disk accesses. The short Oop of the leaf may be treated as if it were the short Oop of the object; it may be stored into fields of other objects, without ever needing the actual contents of that object. Its reference-count can be incremented and decremented just like a fully expanded object’s reference count.
1 I NTRODUCTION Innovations in Artificial Intelligence are responsible to generate enormous amount of data every day. Many embedded applications and devices are collecting the data from different sources and converting it into big data. This data is in structured as well as unstructured format. The real challenge in such case is to maintain the data for easy access which responds and gives required output faster. In upcoming days most of the companies and businesses are willing to incorporate IoT services in their applications. IoT based applications need big amount of data to be generated, transferred and analyze for each millisecond. Due to this, the demand of optimized data storage solutions has been increased to handle all such digital contents. The solution for this is not only to generate and use big data storage devices, but also there is a need of intelligent data storage strategies for optimized use of memory . The study summarizes the evolution of data storage structure as and when it was required by industries . It also discusses the challenges of traditional data storage solutions and object-based storage as a solution for unstructured data. Relational database management system mostly concentrates on textual data. Unstructured data like images, videos or audio files are difficult to store in traditional data storage structure. There is a need of object-based storage structure for improved performance .
According to the pattern used in this paper to name the function related to the initial schema and due to the uniqueness of class names, the name of the function related to the initial schema of each class is unique. Hence, the child class can easily call the functions related to the initial schema of the parent classes. In the case of operation schemas, with the same name, the function related to the last class mentioned in the Mixinattribute is chosen. Similar to the previous mapping rule, all instances of SubClass are instances of all super classes using the method described in Subsection 18.104.22.168. Discussion on soundness. The provided mapping rules for each studied inheritance case preserve the semantics of class inheritance in Object-Z specications by ensuring the following required properties:
Naja and Haghighi  described some mapping rules from Object-Z specications to C++ code. Their method supports the mapping of formal generic param- eters, visibility list, local denitions, class union, object aggregation, type denitions, object, state schema, initial state schema, operations, inheritance, multiple inheritance, object containment, and promotion. In another publication, Naja and Haghighi  pre- sented general ideas (not specic rules and related code) for mapping some new constructs and cases of Object-Z specications into C++ that have not been considered in . Naja and Haghighi  presented another much more comprehensive version of their method, which has advantages, such as covering more Object-Z constructs and proposing mapping rules in a much more detailed way in comparison to the previous work. In addition, they provided templates for constructors and destructors that have not been considered in any previous work. Finally, Naja and Haghighi  presented new work that describes mapping rules formally and proves their correctness formally, too.
On the one hand, and to give a promising answer to the productivity problem, the Model Driven Architecture (MDA) approach was proposed by the ObjectManagement Group (OMG) in 2001. This approach intends to promote the use of models as a basic way of designing and implementing systems. It also aims to provide enterprises with the ability to evolve with rapidly changing technologies. On the other hand, the use of different systems and technologies by the same enterprise raises the needs to make these applications (which are based on different platforms) communicate with each other. This is what is called the Interoperability problem between Enterprise Applications and software. Interoperability is defined as “the ability for a system or a product to work with other systems or products without special effort on the part of the customer”. It can also be defined as “the ability of Enterprise Software and Applications to interact” [ 1 ]. In order to consider that interoperability has been achieved, interactions between Enterprise Applications must take place on at least three levels, data, application and enterprise business.
A second concrete instantiation of the cur- riculum is a stand-alone week-long intensive course for MSc students at Lancaster Univer- sity. The course has been running for two years, with an adapted version the second year (this version is now largely stable). The course lasts one week to support the needs of part- time students from industry, which make up about 50 percent of the attendees. Although we utilize traditional lectures, much time is de- voted to exercises in various forms. Con- cretely, we have individual exercises for Mod- ules 1 and 3 (both utilize AspectJ); group exercises for Modules 2, 3, 4, and 6 (some of these utilize AspectJ while others are based on aspect-oriented analysis and design techniques from relevant literature); and a roundtable ses- sion on AOP’s pros and cons for Module 5. When the week ends, we expect students to spend two weeks completing an individual project that covers topics from all modules. Although we have no statistical data, student feedback has been unanimously positive.
Gateway-Based Object Persistence Applications: There are several systems that are using GOP e.g. VisualAge C++ Data Access Builder, SMRC, ObjectStore Gateway, Persistence, UniSQL/M, Gemstone/Gateway and Subtleware/SQL. GOP applications can access other OODBMSs and can store complex objects natively in them while continuing to access and update data in legacy databases but this feature is still facing some problems and challenges and experts are working on them. Some problems are related to integration of object persistence with object query, object transaction and workflow, and object security. The OMG group is continuously specifying standards in this area for greater use of objects.
As mentioned before, it would be useful to have a mean to integrate existing databases. This is however not an easy task when the requirements of content management should be applicable. For instance, one has to think about the problem how to handle multilingual concepts with an input database providing only means for one language. It is clear, that a simple, yet powerful solution is hard to find. Nevertheless we strongly believe that the basic concepts in our system will also have to be present in a such an advanced system. Constructs like containers, pages and directories are of utmost importance when trying to structure the raw data of a database.
The beneﬁt to the user is apparent. The method x[t] provided by the class DHOc yields the correct solution of (1) for any valid combination of parameters m, p and k which are now quantiﬁed by the object they belong to, i.e. they do not interfere with the variable t nor with any other object. An attempt to set them to illegal values will be immediately recognized by the type system. In this way, the user obtains a solution which is general, reliable, correct, easy to use, and containing all information needed to guarantee its validity.
In this paper, we proposed an object-oriented design and implementation of fault management function to handle link and node faults efficiently in MPLS network. We also proposed a scheme to guarantee differentiated service QoS according to the differentiated path protection options, such as 1:1, 1:N or M:N fast-reroute by NMS, standby mode, path-option, and link/node protection scheme by Cisco MPLS routers. The restoration times of fast reroute schemes were measured to be around 8ms in a test bed network with Cisco MPLS routers.
We already regained functions for lazy evaluation (section 22.214.171.124 on page 57) but may also want to have lazy object state semantics too. Otherwise, internal object state might be computed without being requested at all. One approach to achieve lazy effects relies on a refined state monad concept [Launchbury93, Launchbury & Jones94]. Another opportunity is to use models from concurrent object-oriented languages and to propose lazy message mailboxes for objects. In the context of this dissertation we will be satisfied with lazy functions only, though. A short note is in order regarding the remark that dynamic binding does not co- habit with lazy evaluation (see section 126.96.36.199 on page 56). First, dynamic binding only requires to know the type the receiver which amounts to a partial evaluation only. Second, function application is strict in its first argument anyway. One might evaluate arguments first but eventually the function to be applied must be eval- uated to a function abstraction. Therefore, dynamic binding poses no additional requirements that would render lazy evaluation useless.
The real advantage of using a computer program accrues when the written code is repeated many times, thus saving the implementor considerable time and effort. For example, if we wished to produce a table representing the cost of different weights of apples, then a computer program is constructed that repeats the lines of Ada 95 code that evaluate the cost of a specific weight of apples. However, for each iteration of the calculation the memory location that contains the weight of the apples is changed. A fragment of Ada 95 code to implement this solution is illustrated below:
9. Future Work. In this paper the RITA theory, use, and mechanics have been shown to be portable from multiprocessing shared memory systems (avionics), grid systems (telecommunications), and has applicability to cloud computing systems. To improve the RITA specifications for a cloud computing environment, the implementation language for portions of the event engine and event dispatch portions of the event monitor need porting from the current C and C++ code base to a language developed for concurrency in cloud computing environments. The recently developed Go language sponsored by Google  provides good programming support for RITA. A re-hosting of RITA concepts in Go is advantageous as event propagation is naturally mapped to the Go language interface types, and Go’s “Goroutines” provide a natural way to program Guards and Conditions.
In relational database, connections between two relations are represented by foreign key attribute in one relation that references the primary key of another relation. Individual tuples having same values in foreign and primary key attribute are logically related. Relational model uses logical references. In objectoriented database, relationships are represented by references via the object identifier (OID). These are similar to foreign keys but at place of user-defined attributes internal system identifiers are being used. The ObjectOriented model supports complex object structures, specification of methods and inheritance mechanism by using tuple, list, set and other constructors. It helps in creation of new class definitions from existing ones. 
Return. When one object commands another, a value is often returned. This may be a value computed by the object as a result of the command or a return code indicating whether the object completed processing the command successfully. In some instances the object may not be able to return this information immediately. This indicates the flow of information was based on a previous request.
The paper proposes a set of diagrams based on object orientation principle which describes the functionalities from various perspectives. The diagrams depicts the functional, behavioral and structural aspects of automated passport system. The proposed modeling methodology is based on the principle of object orientation, which allows describing both software and functionalities explicitly. Furthermore, it is illustrated how the well-known object-oriented specification language unified modeling language can be adopted, to provided an adequate formalization of its semantics, to describe structural and behavioral aspects of smart phone database management system related to both logical and physical parts. It is needed to implement the software on the basis of ObjectOriented Model developed. Flaw in modeling process can substantially contribute to the development cost and time. The operational efficiency may be affected as well. Here special attention is paid in planning phase and the same is extended to the implementation phase of the paper.
The second main feature of an environment is multi-user support which means document change in general and in particular the above sketched change prop- agation must be subject to concurrency control and access rights dened for a team of developers, e.g. an automatic immediate update of one document as a consequence of a change in another document can not be performed in any case. The two features of an environment, i.e. maintaining inter-document depen- dencies and even inter-document consistency and providing multi-user support demand complex-structured, persistent data and thus the use of a sophisticated database management system as a key architectural component of a CASE- environment. In commercial CASE-environment development this demand is often not (yet) taken very seriously, i.e. a lot of existing tools or environments are still based on rather rudimentary extensions of le systems. This is, to our view, due to the lack of appropriate database management systems for CASE (cf. Section 5 and and ).
Maintainability Estimation Model for Object-Oriented Software in Design Phase (MEMOOD)S. W. A. Rizvi and R. A. Khan : In this paper, author discussed about the development of a multivariate linear model „Maintainability Estimation Model for ObjectOriented software in Design phase. Its increasing maintainability by adding two new factors understandability and modifiability into it. This paper shows the models, the models use design level objectoriented metrics. These models use the multiple linear regression techniques . The values of understandability, modifiability and maintainability are used in the software development process. These values help software designer to review the design and to take appropriate measures. The maintenance team uses the information to know that on what module to focus during maintenance.
 Larsen L. and M. Jean Harrold.: Slicing object-oriented software. In Proc. of the 18th International Conference on Soft- ware Engineering Berlin, Germany, Mar 1996, pp 495–505  Horwitz S., T.Reps, and D.Binkley, :Interprocedural slicing using dependence graphs, ACM Transaction on Programming Languages and System Jan 1990, Volume:12, Issue: 1, pp.26-60  Malloy B. A., J. D. McGregor, A. Krishnaswamy, and M. Medikonda. :An extensible program representation for object- oriented software. ACM SIGPLAN Notices Dec 1994, vol 29, pp 38–47