Search

Obtaining geo-data and attributes of spatial units from heterogeneous database systems with different data formats for the same land properties is still one of the main problems. The emerging technologies, such as decentralized databases, distributed networks and big data powered by blockchain, can potentially improve land registration processes. In this article, I developed a data model for a geospatially enabled blockchain infrastructure, using an object-oriented architecture model. Such a model can better find spatio-temporal patterns of land transactions and better query time-varying locations of land properties. Additionally, it will make the land registry system secure and protect privacy. [ABSTRACT FROM AUTHOR]

Copyright of Ordnance Industry Automation is the property of Editorial Board for Ordnance Industry Automation and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Diabetes is among the socially significant diseases, which leads to high costs for the diagnosis and treatment of diabetes. Diagnosis and treatment of diabetes is currently one of the important tasks in medicine at the present stage of development of medical services. An important direction in the development of medical services for the population is the development and implementation of various problem-oriented information systems. Similar systems developed earlier did not cover the entire amount of heterogeneous information that is collected when diagnosing and prescribing the course of diabetes treatment, nor did they use technologies and cloud services as tools for Big Data. In this article, let’s make use of the predictive analytic to forecast and categorize the type of diabetes which offers an effective method for treating and curing patients at a reduced cost, with improved results such as affordability and availability. An information system platform has been developed and configured to manage the Hadoop cluster, as well as a non-relational database that uses and processes unstructured data in various formats. All experimental research, development of methods and algorithms, as well as solving computational problems were implemented using software languages for application development. The novelty lies in the research of distributed computing models that provide efficient execution of developed algorithms using the conceptual model of the processes of search, extraction and analysis of unstructured data in large data sets. The practical implementation of algorithms was carried out on the basis of methods of objectoriented programming and object-oriented databases. [ABSTRACT FROM AUTHOR]

Copyright of Railway Signalling & Communication Engineering is the property of Railway Signalling & Communication Engineering and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Modern organizations are successfully using project teams to address complex tasks. Yet these teams often use approaches for project data management that may not capture project processes, contexts, rationales, or artifacts in a way that enables new project members to familiarize themselves quickly with the project history. Project information is rarely captured, retained, or indexed so that people external to the project can retrieve and apply it to future tasks. To address the issue of capturing a comprehensive project history that can subsequently be retrieved and applied to current problems, a generalizable object-oriented data model is developed. It decomposes project information into five discrete classes: projects, users, events, meetings, and documents. Through inheritance and domain references, the model describes the people, temporal events (such as meetings or single agenda items within a meeting), and archival documents that are created within a project or support some aspect of the project. These project items can be retrieved based on either contextual information (such as the dates they were created or last revised, who created them, or the projects they pertain to) or user-supplied descriptive keywords. Hypertext-like links can also be created to associate related items. Based on this model, a prototype system, Project Memory, has been developed to validate the model structure and system requirements. [ABSTRACT FROM AUTHOR]

The visual cues from multiple support regions of different sizes and resolutions are complementary in classifying a candidate box in object detection. Effective integration of local and contextual visual cues from these regions has become a fundamental problem in object detection. In this paper, we propose a gated bi-directional CNN (GBD-Net) to pass messages among features from different support regions during both feature learning and feature extraction. Such message passing can be implemented through convolution between neighboring support regions in two directions and can be conducted in various layers. Therefore, local and contextual visual patterns can validate the existence of each other by learning their nonlinear relationships and their close interactions are modeled in a more complex way. It is also shown that message passing is not always helpful but dependent on individual samples. Gated functions are therefore needed to control message transmission, whose on-or-offs are controlled by extra visual evidence from the input sample. The effectiveness of GBD-Net is shown through experiments on three object detection datasets, ImageNet, Pascal VOC2007 and Microsoft COCO. Besides the GBD-Net, this paper also shows the details of our approach in winning the ImageNet object detection challenge of 2016, with source code provided on https://github.com/craftGBD/craftGBD. In this winning system, the modified GBD-Net, new pretraining scheme and better region proposal designs are provided. We also show the effectiveness of different network structures and existing techniques for object detection, such as multi-scale testing, left-right flip, bounding box voting, NMS, and context. [ABSTRACT FROM AUTHOR]

Software stability is an important factor for better software quality. Stable classes tend to reduce the software maintenance cost and effort. Therefore, achieving class stability is an important quality objective when developing software. Designers can make better decisions to improve class stability if they can predict it before the fact using some predictors. In this paper, we investigate the correlation between some available design measurements and class stability over versions and propose a stability prediction model using such available measurements. We conducted a set of experiments using artificial neural network (ANN) and support vector machine (SVM) to build different prediction models. We compared the accuracy of these prediction models. Our experiments reveal that ANN and SVM prediction models are effective in predicting object-oriented class stability. [ABSTRACT FROM AUTHOR]

Saliency detection aims at quantitatively predicting attended locations in an image. It may mimic the selection mechanism of the human vision system, which processes a small subset of a massive amount of visual input while the redundant information is ignored. Motivated by the biological evidence that the receptive fields of simple cells in V1 of the vision system are similar to sparse codes learned from natural images, this paper proposes a novel framework for saliency detection by using image sparse coding representations as features. Unlike many previous approaches dedicated to examining the local or global contrast of each individual location, this paper develops a probabilistic computational algorithm by integrating objectness likelihood with appearance rarity. In the proposed framework, image sparse coding representations are yielded through learning on a large amount of eye-fixation patches from an eye-tracking dataset. The objectness likelihood is measured by three generic cues called compactness, continuity, and center bias. The appearance rarity is inferred by using a Gaussian mixture model. The proposed paper can serve as a basis for many techniques such as image/video segmentation, retrieval, retargeting, and compression. Extensive evaluations on benchmark databases and comparisons with a number of up-to-date algorithms demonstrate its effectiveness. [ABSTRACT FROM AUTHOR]

Object-oriented (00) approaches of software development promised better maintainable and reusable systems, but the complexity resulting from its features usually introduce some faults that are difficult to detect or anticipate during software change process. Thus, the earlier they are detected, found and fixed, the lesser the maintenance costs. Several 0 0 metrics have been proposed for assessing the quality of 0 0 design and code and several empirical studies have been undertaken to validate the impact of 0 0 metrics on fault proneness (FP). The question now is which metrics are iiseful in measuring the FP of 0 0 classes? Gonsequently, we investigate the existing empirical validation of GK + SLOG metrics based on their state of significance, validation and usefulness. We used systematic hterature review (SLR) methodology over a number of relevant article sources, and our results show the existence of 29 relevant empirical studies. Further analysis indicates that coupling, complexity and size measures have strong impact on FP of OO classes. Based on the results, we therefore conclude that these metrics can be used as good predictors for building quality fault models when that could assist in focusing resources on high risk components that are liable to cause system failures, when only GK + SLOG metrics are used. [ABSTRACT FROM AUTHOR]

Software designs decay as systems, uses, and operational environments evolve. Decay can involve the design patterns used to structure a system. Classes that participate in design pattern realizations accumulate grime-non-pattern-related code. Design pattern realizations can also rot, when changes break the structural or functional integrity of a design pattern. Design pattern rot can prevent a pattern realization from fulfilling its responsibilities, and thus represents a fault. Grime buildup does not break the structural integrity of a pattern but can reduce system testability and adaptability. This research examined the extent to which software designs actually decay, rot, and accumulate grime by studying the aging of design patterns in three successful object-oriented systems. We generated UML models from the three implementations and employed a multiple case study methodology to analyze the evolution of the designs. We found no evidence of design pattern rot in these systems. However, we found considerable evidence of pattern decay due to grime. Dependencies between design pattern components increased without regard for pattern intent, reducing pattern modularity, and decreasing testability and adaptability. The study of decay and grime showed that the grime that builds up around design patterns is mostly due to increases in coupling. [ABSTRACT FROM AUTHOR]

The article discusses the employment of semantic networks in agile software and computer system development. The role of semantic networks as object-oriented models allowing forecasts of interaction between different topics within the system is presented, and it is argued that it is superior to older methods for modeling knowledge representation.

In this paper we offer an approach for making queries from a fuzzy object-oriented database in the case that user adds some combined limitations (AND, OR) and assigns weights to them with respect to their importance and expects to obtain ideal answers. Then, using the proposed method the obtained results will be sorted in terms of their degree of dependency on the obtained answer set. Moreover, we suggest an approach enabling us to guarantee that each query will result in an answer even in the case that there is no element meeting all user defined limitations. This would be a beneficial approach in the case that it is impossible to meet all limitations and user expects a guaranteed answer. Implementing this approach will result in flexible queries and causes queries as well as databases to get closer to the real world. In this way, users will have easy interactions with database and the database will have better efficiency in response to fuzzy complex and combined queries.Implementation of this case study reveals that compared with crisp method the proposed approach results in more answers which are closer to real cases. [ABSTRACT FROM AUTHOR]

Aiming at distinguishing entities, the concept of entity comparison plays an important role in object management in object-oriented databases as well as object-oriented knowledge bases. In order to model uncertain data and complex-valued attributes as well as complex relationships among objects/classes, fuzzy object-oriented databases have been introduced. In this paper, we identify two levels of entities in fuzzy object-oriented databases, which are fuzzy classes and fuzzy objects. Based on the semantic measure of fuzzy data, we identify several possible relationships between fuzzy entities being compared, and propose a more general way to compare the objects and classes with fuzzy data types in the fuzzy object-oriented databases. We introduce the notion of equivalence degree of two fuzzy entities. We apply this notion to compare two fuzzy entities so that we know to which extent two objects or two classes refer to the same real-world entity. [ABSTRACT FROM AUTHOR]

Many studies have investigated the relationships between object-oriented (OO) metrics and change-proneness and conclude that OO metrics are able to predict the extent of change of a class across the versions of a system. However, there is a need to re-examine this subject for two reasons. First, most studies only analyze a small number of OO metrics and, therefore, it is not clear whether this conclusion is applicable to most, if not all, OO metrics. Second, most studies only uses relatively few systems to investigate the relationships between OO metrics and change-proneness and, therefore, it is not clear whether this conclusion can be generalized to other systems. In this paper, based on 102 Java systems, we employ statistical meta-analysis techniques to investigate the ability of 62 OO metrics to predict change-proneness. In our context, a class which is changed in the next version of a system is called change-prone and not change-prone otherwise. The investigated OO metrics cover four metric dimensions, including 7 size metrics, 18 cohesion metrics, 20 coupling metrics, and 17 inheritance metrics. We use AUC (the area under a relative operating characteristic, ROC) to evaluate the predictive effectiveness of OO metrics. For each OO metric, we first compute AUCs and the corresponding variances for individual systems. Then, we employ a random-effect model to compute the average AUC over all systems. Finally, we perform a sensitivity analysis to investigate whether the AUC result from the random-effect model is robust to the data selection bias in this study. Our results from random-effect models reveal that: (1) size metrics exhibit moderate or almost moderate ability in discriminating between change-prone and not change-prone classes; (2) coupling and cohesion metrics generally have a lower predictive ability compared to size metrics; and (3) inheritance metrics have a poor ability to discriminate between change-prone and not change-prone classes. Our results from sensitivity analyses show that these conclusions reached are not substantially influenced by the data selection bias. [ABSTRACT FROM AUTHOR]

Regardless of the supremacy of relational database management systems (RDBMS) in the databases, object-oriented database management systems (OODBMS) continue to play crucial role in the management of data. Generally, the complex data are often found in telecommunications, business, engineering and web based applications. The most common approach of accessing such data is navigation. However, the approach of navigational access of data has the potential of generating excessive disk IO because objects in the path of navigation may be placed in different disk pages. Excessive disk IO is becoming increasingly undesirable because disk IO performance improves at only 5-8% per year whereas CPU performance doubles approximately every 18 months. Thus disk IO is likely to be a bottleneck in an increasing number of OODB applications. This paper focuses on reducing disk IO effects to improve OODBMS performance. In database environment effective buffer management of the main memory is the key in increasing efficiency through reducing the disk IO bottleneck in OODBMSs. There has been much existing work, namely in the areas of: static clustering; dynamic clustering; buffer replacement; and pre-fetching. All of these techniques can be used together in a complimentary manner. Most existing research has focused on finding the best solution for each area with little regard on how solutions from the different areas affect each other. We believe synergy exists between the areas, and that exploiting the synergy leads to the best overall solution. This paper focuses on exploring whether synergistic techniques are both feasible to implement and outperform their non-synergistic counterparts. [ABSTRACT FROM AUTHOR]

As we move toward developing object-oriented (OO) programs, the complexity traditionally found in functions and procedures is moving to the connections among components. Different faults occur when components are integrated to form higher-level structures that aggregate the behavior and state. Consequently, we need to place more effort on testing the connections among components. Although OO technologies provide abstraction mechanisms for building components that can then be integrated to form applications, it also adds new compositional relations that can contain faults. This paper describes techniques for analyzing and testing the polymorphic relationships that occur in OO software. The techniques adapt traditional data flow coverage criteria to consider definitions and uses among state variables of classes, particularly in the presence of inheritance, dynamic binding, and polymorphic overriding of state variables and methods. The application of these techniques can result in an increased ability to find faults and to create an overall higher quality software. Copyright © 2010 John Wiley & Sons, Ltd. This paper describes techniques for analyzing and testing the polymorphic relationships that occur in object-oriented software. The techniques adapt traditional data flow coverage criteria to consider definitions and uses among state variables of classes, particularly in the presence of inheritance, dynamic binding, and polymorphic overriding of state variables and methods. The application of these techniques can result in an increased ability to find faults and to create overall higher quality software. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The Pascal Visual Object Classes (VOC) challenge is a benchmark in visual object category recognition and detection, providing the vision and machine learning communities with a standard dataset of images and annotation, and standard evaluation procedures. Organised annually from 2005 to present, the challenge and its associated dataset has become accepted as the benchmark for object detection. This paper describes the dataset and evaluation procedure. We review the state-of-the-art in evaluated methods for both classification and detection, analyse whether the methods are statistically different, what they are learning from the images (e.g. the object or its context), and what the methods find easy or confuse. The paper concludes with lessons learnt in the three year history of the challenge, and proposes directions for future improvement and extension. [ABSTRACT FROM AUTHOR]

In this paper we approach the problem of adaptive refactoring, the process of adapting the class structure of a software system when new application classes are added. We have previously introduced an adaptive clustering method that deals with the evolving structure of any object oriented application. The aim of this paper is to extend the evaluation of the proposed method on the open source case study JHotDraw, emphasizing, this way, the potential of our approach. [ABSTRACT FROM AUTHOR]

This paper presents a novel approach for mapping an existing object-oriented database into XML and vice versa. The major motivation to carry out this study is the fact that it is necessary to facilitate platform independent exchange of the content of object oriented databases and the need to store XML in a structured database. There are more common features between the object-oriented model and XML and thus the the two-way mapping from object-oriented databases into XML (and vice versa) should be less problematic. To achieve the mapping, what we call the object graph is derived based on characteristics of the schema to be mapped. For object-oriented schema, the object graph simply summarizes and includes all nesting and inheritance links, which are the basics of the object-oriented model. Then, the inheritance is simulated in terms of nesting to get a simulated object graph. This way, everything in a simulated object graph is directly representable in XML format. Finally, we handle the mapping of the actual data from the objectoriented database into corresponding XML document(s). On the other hand, the common features between the object-oriented model and XML make it is more attractive to map from XML into object-oriented database; such mapping preserves database specifics. To achieve the mapping, the object graph is derived based on characteristics of the XML schema; it simply summarizes and includes all complex and simple elements and the links, which are the basics of the XML schema. Then, the links are simulated in terms of nesting to get a simulated object graph. This way, everything in a simulated object graph is directly representable in object-oriented database. Finally, we handle the mapping of the actual data from XML document(s) into the corresponding object-oriented database. [ABSTRACT FROM AUTHOR]

Abstract: In this paper we reflect on the differences between prototype-based and class-based programming languages and we introduce a new approach, called the Oea framework, that will allow JavaScript developers to write programs using a class-based style, which we assert is easy to use, has a syntax style that resembles that of the Java class-based approach and has high performance and reliability. We present a survey of the most widely used class-based techniques for JavaScript describing their methods and highlighting their shortcomings and compare the new approach with this earlier work. The approach has been developed in the context of a framework for developing Web applications using Scalable Vector Graphics (SVG), JavaScript and the Resource Description Framework (RDF) which involved the construction of substantial libraries and other code using the approach. [Copyright &y& Elsevier]

In this paper, we focus on the notion of events in the context of an active object-oriented database that are the most important research in an active system. First, we describe the model of primitive and composite events and define the algebra permitting to deduct the interval of validity of a composite event according to their components. Second, we demonstrate how the synchronized Petri Nets are used as mechanism for the modelling and detection of composite events. Finally, the architecture of our model is presented. [ABSTRACT FROM AUTHOR]

We follow signature-based approach to object-oriented query handling in this paper. The use of signature files as an index for full text search has been widely known and used. Signature file based access methods initially applied on text have now been used to handle set-oriented queries in Object-Oriented Data Bases (OODB). All the proposed methods use either efficient search method or tree based intermediate data structure to filter data objects matching the query. Use of search techniques retrieves the objects by sequentially comparing the positions of 1s in it. Such methods take longer retrieval time. On the other hand tree based structures traverse multiple paths making comparison process tedious. In this paper we describe a new indexing technique for representing signature file using the dynamic balancing of B+ tree called Signature Declustering tree (SD-tree). The structure has the positions of 1s in the signatures distributed over a set of leaf nodes. Using this for a given query signature all the matching signatures can be retrieved cumulatively from a single node. Also for signature insertion an optimal search path is calculated by keeping a threshold value and by using forward pointers in leaf nodes. To promote optimal search between subsequent queries the backward leaf node pointers are used. Experiments have been conducted to analyze the time and space overhead of the SD-tree by varying the signature length and the distribution of signature weight for varying query signature patterns. Also, to validate the proposed structure a hypothetical object schema is considered and sample queries evaluated. [ABSTRACT FROM AUTHOR]

This paper presents the trajectory tree as a hierarchical region-based representation for video sequences. Motion, as well as spatial features from multiple frames are used to generate a set of temporal regions structured within a hierarchy of scale and motion coherency. The resulting representations offer a global description of the entire video sequence and enhance semantic analysis potential. A multiscale segmentation strategy is proposed whereby region-merging criteria of progressively greater complexity are used to define partition layers of increasing aptitude for object detection. A novel data structure, called the trajectory adjacency graph, is defined for the long-term analysis of partition sequences. Furthermore, mechanisms for assessing connectivity, verifying temporal continuity, and proposing merging operations based on color, affine, and translational motion homogeneity characteristics over the entire sequence are also introduced. Finally, as demonstrated through experimental results, the trajectory tree offers a concise yet versatile sup- port for video object segmentation, description and retrieval tasks. [ABSTRACT FROM AUTHOR]

Abstract: Recent years saw the development of a composition mechanism called traits. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition. To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not exhibit all possible composition problems, since the hierarchies were previously expressed using single inheritance and following certain patterns. This paper presents our work on designing and implementing a new trait-based stream library named Nile. It evaluates how far traits enable reuse, what problems can be encountered when building a library using traits from scratch and compares the traits solution to alternative composition mechanisms. Nile''s core allows the definition of compact collection and file streaming libraries as well as the implementation of a backward-compatible new stream library. Nile method size shows a reduction of 40% compared to the Squeak equivalent. The possibility to reuse the same set of traits to implement two distinct libraries is a concrete illustration of trait reuse capability. [Copyright &y& Elsevier]

With the wide increase in using distributed object-oriented databases, it became important to find an efficient technique to store large-scale databases on the different sites. The allocation of object-oriented database involves allocation of both methods and attributes within the classes. The main objective of this paper is to introduce a new technique for allocating the distributed object-oriented database methods and attributes among N sites. The proposed technique uses genetic algorithm to find the best allocation (optimal or near optimal) of the object-oriented database methods and attributes to the available sites. A cost function that computes the total data transfer during the execution of queries is developed. The genetic algorithm steps use this cost function to evaluate the possible allocations of methods. Validation of the proposed technique is done via simulation. The experimental results of the proposed technique depict that it has a great impact in reducing the total time required to find the best allocation and in most of the cases it reaches the optimal allocation of the methods. [ABSTRACT FROM AUTHOR]

An important step in developing the requirements for an information system is analyzing the application domain. In this step, conceptual models are used for representing an application domain. However, while languages for software design are available and widely used, no generally accepted language exists for conceptual modeling. This work suggests the use of object-oriented software modeling languages also for conceptual modeling. Such use can support a more accurate transition from domain models to software models. As software-modeling languages were not intended for modeling application domains, their constructs lack the required semantics. While previous papers addressed the representation of structural elements of domains using object concepts, this paper addresses behavioral aspects, related to change and interaction. The proposed semantics are based on a mapping between ontological concepts that describe behavior and object-oriented constructs related to dynamics. Based on these mappings, modeling rules are proposed to guide the modeler in creating ontologically well-formed models. The mappings and rules are exemplified using UML and are demonstrated using a case study. [ABSTRACT FROM AUTHOR]

Subtype tests are an important issue in the implementation of object-oriented programming languages. Many techniques have been proposed, but none of them perfectly fulfills the five requirements that we have identified: constant-time, linear-space, multiple inheritance, dynamic loading and inlining. In this article, we propose a subtyping test implementation that involves a combination of usual hashtables and Cohen's display, which is a well-known technique for single inheritance hierarchies. This novel approach is based on perfect hashing, that is, an optimized and truly constant-time variant of hashing that applies to immutable hashtables. We show that the resulting technique closely meets all five requirements. Furthermore, in the framework of JAVA-like languages—characterized by single inheritance of classes and multiple subtyping of interfaces—perfect hashing also applies to method invocation when the receiver is typed by an interface. The proposed technique is compared to some alternatives, including the proposal by Palacz and Vitek [2003]. Time-efficiency is assessed at the cycle level in the framework of Driesen's pseudo-code and the linear-space criterion is validated by statistical simulation on benchmarks consisting of large-scale class hierarchies. [ABSTRACT FROM AUTHOR]

In this paper a run-time model is proposed. The run-time model enforces integrity constraints for attributes that are derived from composition and inheritance hierarchies. The run-time model is designed for enforcing the logical integrity constraints in object-oriented databases during the run-time. A new technique called detection method is designed to check the object meta data to detect and catch the object-oriented databases violation before it occurs. Furthermore, we have implemented the RTM and supported set of definitions that are for checking attribute values validity, object-oriented databases consistency, and also a method for verifying attribute values when inserting, deleting, and updating objects. [ABSTRACT FROM AUTHOR]

A multi-aspects object data model enables multiple aspects of a real-world entity to be represented and to be acquired/lost dynamically. In multi-aspects object databases, object migration (OM) updating membership relationships between an object and classes occur, as the properties of the object evolve in its lifetime. Temporal object migration (TOM) behaviour modelling framework using coloured Petri nets (CPN) has been presented to construct TOM behaviour models, a temporally extended version of OM behaviour models. In manual construction of TOM behaviour models, however, it becomes more difficult to make the models consistent and complete as their scales grow larger. To overcome the problem, this paper proposes a technique for automatically constructing TOM behaviour models from TOM consistency constraints and class schemas, which are described in a concise, fragmentary, and declarative form. [ABSTRACT FROM AUTHOR]

A fuzzy object-oriented data model is a fuzzy logic-based extension to an object-oriented database model that permits uncertain data to be explicitly represented. The fuzzy object-oriented database (FOOD) model is one of the proposed models in the literature to handle uncertainty in object-oriented databases. Several kinds of fuzziness are dealt with in the FOOD model, including fuzziness at attribute level and between object and class and between class and superclass relations. The traditional index structures do not allow efficient access to both crisp and fuzzy objects for fuzzy object-oriented databases since they are not efficient enough in processing both crisp and fuzzy queries. In this study, we propose a new index structure, namely a FOOD index (FI), to deal with different kinds of fuzziness in fuzzy object-oriented databases and to support multidimensional indexing. In this paper, we describe this proposed index structure and show how it supports various types of flexible queries, and evaluate its performance for exact, range, and fuzzy queries. [ABSTRACT FROM AUTHOR]

Empirical studies have shown complexity metrics to be good predictors of testing effort and maintainability in traditional, imperative programming languages. Empirical validation studies have also shown that complexity is a good predictor of initial quality and reliability in object-oriented (OO) software. To date, one of the most empirically validated OO complexity metrics is the Chidamber and Kemerer Weighted Methods in a Class (WMC). However, there are many more OO complexity metrics whose predictive power has not been as extensively explored. In this study, we explore the predictive ability of several complexity-related metrics for OO software that have not been heavily validated. We do this by exploring their ability to measure quality in an evolutionary software process, by correlating these metrics to defect data for six versions of Rhino, an open-source implementation of JavaScript written in Java. Using statistical techniques such as Spearman's correlation, principal component analysis, binary logistic regression models and their respective validations, we show that some lesser known complexity metrics including Michura et al.'s standard deviation method complexity and Etzkorn et al.'s average method complexity are more consistent predictors of OO quality than any variant of the Chidamber and Kemerer WMC metric. We also show that these metrics are useful in identifying fault-prone classes in software developed using highly iterative or agile software development processes. Copyright © 2008 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Object-oriented systems development has attracted great interest in the information systems (IS) field because of a belief that using object-oriented development (OD) makes it easier to develop and maintain software plus achieve software reuse. However, the transition from structured to OD may be especially challenging for IS developers. In fact, some argue that structured development (SD) knowledge may interfere with the ability to learn OD approaches because of a form of proactive interference. To understand how knowledge of SD concepts influences the ability to gain OD knowledge, we assessed a team of IS developers' understanding of structured and object-oriented concepts at the beginning of their first OD project and repeated our assessment 1 year later. Developers increased their understanding of some object-oriented concepts, but these changes were associated with increases in understanding of one of the SD concepts. Further, at the beginning and end of the project, developers' mental models were highly consistent with one another and that of an OD expert with regard to most OD concepts. It appears that the formal training that developers received allowed them to attain a good understanding of most object-oriented concepts. These findings challenge the idea that structured developers must ‘unlearn’ SD to adopt OD approaches. Future research may wish to examine the different types of software development knowledge to ascertain which are amenable to positive transfer and which are more likely to suffer from proactive interference. [ABSTRACT FROM AUTHOR]

This work introduces the concept of an Object-Oriented Learning Object (OOLO) that is developed in a manner similar to the one that software objects are developed through Object-Oriented Software Engineering (OO SWE) techniques. In order to make the application of the OOLO feasible and efficient, an OOLO model needs to be developed based on Object-Oriented (OO) concepts. A sample OOLO model of inheritance is used to demonstrate the application of such Learning Objects (LOs) to a learning scenario. The benefits of this model are quantified in terms of savings on the number of new LOs that need to be developed and savings on metadata entry. Additionally, benefits extend to the quality of new LOs due to the automatic application of standards and the increased compatibility among LOs (due to inheritance) and the increased extendibility and functionality of LOs due to the OO characteristic of method and data encapsulation and polymorphism, which also make OOLOs more adaptable to the varied teaching styles. The study goes on to examine existing LO design and development models as well as relevant tools and assesses the ability of these models and tools to implement the OOLO concept. The study concludes by summing up the benefits that can be realized by the development of OOLOs and by outlining the work that needs to be done for achieving the application of OO techniques to LOs. [ABSTRACT FROM AUTHOR]