Thesis (Ph.D.) -- Mississippi State University. Department of Industrial and Systems Engineering. / Title from title screen. Includes bibliographical references.

This dissertation examines aspects of the relationship between connectivity and the development of genetic structure in subdivided coral reef populations using both simulation and algebraic methods. The first chapter develops an object-oriented, individual based method of simulating the dynamics of genes in subdivided populations. The model is then used to investigate how changes to different components of population structure (e.g., connectivity, birth rate, population size) influence genetic structure through the use of autocorrelation analysis. The autocorrelograms also demonstrate how relationships between populations change at different spatial and temporal scales. The second chapter uses discrete multivariate distributions to model the relationship between connectivity, selection and resource use in subdivided populations. The equations provide a stochastic basis for multiple-niche polymorphism through differential resource use, and the role of scale in changing selective weightings is also considered. The third chapter uses matrix equations to study the expected development of genetic structure among Caribbean coral reefs. The results show an expected break between eastern and western portions of the Caribbean, as well as additional nested structure within the Bahamas, the central Caribbean (Jamaica and the reefs of the Nicaraguan Rise) and the Mesoamerican Barrier Reef. The matrix equations provide an efficient means of modeling the development of genetic structure in subdivided populations through time. The fourth chapter uses matrix equations to examine the expected development of genetic structure among Southeast Asian coral reefs. Projecting genetic structure reveals an expected unidirectional connection from the South China Sea into the Coral Triangle region via the Sulu Sea. Larvae appear to be restricted from moving back into the South China Sea by a cyclonic gyre in the Sulu Sea. Additional structure is also evident, including distinct clusters within the Philippines, in the vicinity of the Makassar Strait, in the Flores Sea, and near Halmahera and the Banda Sea. The ability to evaluate the expected development of genetic structure over time in subdivided populations offers a number of potential benefits, including the ability to ascertain the expected direction of gene flow, to delineate natural regions of exchange through clustering, or to identify critical areas for conservation or for managing the spread of invasive material via elasticity analysis.

Programmers worldwide share components and jointly develop components on a global scale in contemporary software development. An important aspect of such library-based programming is the need for technical communication with regard to libraries – library communication. As part of their work, programmers must discover, study, and learn as well as debate problems and future development. In this sense, the electronic, networked media has fundamentally changed programming by providing new mechanisms for communication and global interaction through global networks such as the Internet. Today, the baseline for library communication is hypertext documentation. Improvements in quality, efficiency, cost and frustration of the programming activity can be expected by further developments in the electronic aspects of library communication. This thesis addresses the use of the electronic networked medium in the activity of library communication and aims to discover design knowledge for communication tools and processes directed towards this particular area. A model of library communication is provided that describes interaction among programmer as webs of interrelated library communities. A discussion of electronic, networked tools and processes that match such a model is also provided. Furthermore, research results are provided from the design and industrial valuation of electronic reference documentation for the Java domain. Surprisingly, the evaluation did not support individual adaptation (personalization). Furthermore, global library communication processes have been studied in relation to open-source documentation and user-related bug handling. Open-source documentation projects are still relatively uncommon even in open-source software projects. User-related Open-source does not address the passive behavior users have towards bugs. Finally, the adaptive authoring process in electronic reference documentation is addressed and found to provide limited support for expressing the electronic, networked dimensions of authoring requiring programming skill by technical writers. Library communication is addressed here by providing engineering knowledge with regards to the construction of practical electronic, networked tools and processes in the area. Much of the work has been performed in relation to Java library communication and therefore the thesis has particular relevancefor the object-oriented programming domain. A practical contribution of the work is the DJavadoc tool that contributes to the development of reference documentation by providing adaptive Java reference documentation. / On the day of the public defence the title of article I was: Designing Electronic Library Reference Documentation.

After the book, Design Patterns: Elements of Reusable Object-Oriented Software was published in 1994, usage of design patterns in object-oriented (OO) programming has been investigated by many researchers. However, the effects of design patterns on non-object oriented (non-OO) programming have not been analyzed too much in the literature. This study focuses on various design pattern implementations using non OO programming and investigates the benefits of design patterns upon real-time software. In order to evaluate the results, specific quality metrics were selected and performance of traditionally developed software was compared with that of software developed using design patterns.

Computer software is ubiquitous. More than 35 × 10 18 computer instructions are executed around the globe each second. As computers dominate more aspects of our lives, there is a growing need to reason more accurately about computer software. Most contemporary computer software is written using object-oriented (OO) programming languages, such as J AVA, C#, and C++. How should we mathematically characterize object-oriented software? This is the question this thesis addresses by presenting an accurate domain-theoretic model of mainstream object-oriented programming. Mainstream object-oriented languages are class-based. In such languages, the name of a class is part of the meaning of an object, a property often called "nominality". Most mainstream OO languages also conform to a static type discipline. Hence, the focus of this thesis is the construction of an accurate model of nominal, statically-typed OO languages. In statically-typed nominal OO languages, class names are also part of the meaning of corresponding class types, and class inheritance (subclassing) is explicitly declared; one class is a subclass of another only if it is declared as such. When static type systems are formulated to describe sets of objects, subtyping is defined so that subclassing is consistent with subtyping. Nevertheless, some programming languages (PL) theoreticians dismiss this identification as a design error because the only published models of OO languages exclude nominal information from objects and define subtyping in a way that ignores nominality. In nominal OO languages, program behavior depends on the nominal information embedded in objects. This thesis builds a model of OO languages called NOOP that includes nominal information and defines static types in accord with mainstream OO language designs. In NOOP , the meaning of every object includes its class name. Similarly, types are defined such that objects belong to a particular class type if and only if they are members of classes that inherit from the class corresponding to the class type. To demonstrate the utility of the model, we show that in NOOP inheritance and OO subtyping coincide. This work shows that mainstream OO languages are not technically defective in identifying inheritance and subtyping. In models that include nominal information and define types that respect nominal information, this identification is mathematically correct. The folklore among OO programming language researchers that "inheritance is not subtyping" is incorrect.

Because software systems are imperfect, developers are forced to fix bugs and add new features. The common way of applying changes to a running system is to stop the application or machine and restart with the new version. Stopping and restarting causes a disruption in service that is at best inconvenient and at worst causes revenue loss and compromises safety. Dynamic software updating (DSU) addresses these problems by updating programs while they execute. Prior DSU systems for managed languages like Java and C# lack necessary functionality: they are inefficient and do not support updates that occur commonly in practice. This dissertation presents the design and implementation of Jvolve, a DSU system for Java. Jvolve's combination of flexibility, safety, and efficiency is a significant advance over prior approaches. Our key contribution is the extension and integration of existing Virtual Machine services with safe, flexible, and efficient dynamic updating functionality. Our approach is flexible enough to support a large class of updates, guarantees type-safety, and imposes no space or time overheads on steady-state execution. Jvolve supports many common updates. Users can add, delete, and change existing classes. Changes may add or remove fields and methods, replace existing ones, and change type signatures. Changes may occur at any level of the class hierarchy. To initialize new fields and update existing ones, Jvolve applies class and object transformer functions, the former for static fields and the latter for object instance fields. These features cover many updates seen in practice. Jvolve supports 20 of 22 updates to three open-source programs---Jetty web server, JavaEmailServer, and CrossFTP server---based on actual releases occurring over a one to two year period. This support is substantially more flexible than prior systems. Jvolve is safe. It relies on bytecode verification to statically type-check updated classes. To avoid dynamic type errors due to the timing of an update, Jvolve stops the executing threads at a DSU safe point and then applies the update. DSU safe points are a subset of VM safe points, where it is safe to perform garbage collection and thread scheduling. DSU safe points further restrict the methods that may be on each thread's stack, depending on the update. Restricted methods include updated methods for code consistency and safety, and user-specified methods for semantic safety. Jvolve installs return barriers and uses on-stack replacement to speed up reaching a safe point when necessary. While Jvolve does not guarantee that it will reach a DSU safe point, in our multithreaded benchmarks it almost always does. Jvolve includes a tool that automatically generates default object transformers which initialize new and changed fields to default values and retain values of unchanged fields in heap objects. If needed, programmers may customize the default transformers. Jvolve is the first dynamic updating system to extend the garbage collector to identify and transform all object instances of updated types. This dissertation introduces the concept of object-specific state transformers to repair application heap state for certain classes of bugs that corrupt part of the heap, and a novel methodology that employes dynamic analysis to automatically generate these transformers. Jvolve's eager object transformation design and implementation supports the widest class of updates to date. Finally, Jvolve is efficient. It imposes no overhead during steady-state execution. During an update, it imposes overheads to classloading and garbage collection. After an update, the adaptive compilation system will incrementally optimize the updated code in its usual fashion. Jvolve is the first full-featured dynamic updating system that imposes no steady-state overhead. In summary, Jvolve is the most-featured, most flexible, safest, and best-performing dynamic updating system for Java and marks a significant step towards practical support for dynamic updates in managed language virtual machines. / text

This dissertation defines "modular-objective coupling", and shows that programming language designs which imply reduced modular-objective coupling reduce complexity of remodularizations--behaviour-preserving restructurings for which the only intended goals are to change program source code structure. We explicitly distinguish between two points of view on program structure: modular structure--the structure of a program as a set of static text documents, and objective structure--the structure of a program as a dynamic computational model during execution. We define modular-objective coupling as the degree to which changes in modular structure imply changes to objective structure, for a given programming language. We use the term remodularization to refer to any behaviour-preserving source code restructuring, for which the only intended goal is to change modular structure. We argue that programming languages with strong modular-objective coupling introduce accidental complexity into remodularizations, by requiring complex objective structure changes to achieve intended modular structure changes. Our claim is that a programming language design which implies reduced modular-objective coupling reduces remodularization complexity in the language. To validate this claim, we first present SubjectJ, a subject-oriented programming system that extends Java. The design of Java implies strong modular-objective coupling, while SubjectJ is designed for reduced modular-objective coupling. We then perform a series of remodularization case studies comparing Java and SubjectJ. Our results suggest that remodularizations are less complex in SubjectJ.

Software systems are permanently changed in order to meet new requirements and to adapt them to permanently changing technology. Design modularity decouples design concerns that probably can be changed and in this way facilitates further system changes. Unfortunately, some design concerns, called crosscutting concerns, cannot be modularized using traditional modularization methods and techniques. Modularization of crosscutting concerns is the research subject of the new emerging software engineering paradigm, aspect-oriented analysis and design. However, this paradigm is still not enough mature. It is still unknown, which design patterns developed in the object-oriented paradigm can be adapted for aspect-oriented paradigm and how to transform them from one paradigm to another in a systematic way. Despite the fact that some attempts have been done to solve this problem, the proposed solutions only eliminate crosscutting concerns in object-oriented design patterns, but do not generate pure aspect-oriented patterns. The thesis defines the class of object-oriented design patterns which can be transformed into pure aspect-oriented ones, proposes a systematic procedure for such transformation and investigates properties of resulting patterns from the viewpoint of their applicability in the design of aspect-oriented domain frameworks. This is the main contribution of the research work. The case study methodology has been used for the experimental research of the properties of... [to full text] / Programų sistemos yra dažnai keičiamos, siekiant jas pritaikyti prie pasikeitusių reikalavimų ir dėl nuolat kintančių technologijų. Modulinė sistemos architektūra įgalina nepriklausomus dalykinius turinius realizuoti nepriklausomais ar nedaug vienas nuo kito priklausomais moduliais, kuriuos galima keisti nepriklausomai vienas nuo kito. Tačiau esamomis priemonėmis galima atskirti ne visus turinius. Kai kurie dalykiniai turiniai yra susipynę tarpusavyje ir jų negalima realizuoti savarankiškais moduliais. Šiai problemai spręsti buvo pasiūlyta nauja programų sistemų inžinerijos paradigma – aspektinė paradigma. Tačiau sistemų projektavimo technologija joje kol kas dar nėra pakankamai brandi. Vis dar nėra žinoma, kuriuos objektinio projektavimo šablonus galima panaudoti aspektinėje paradigmoje ir kaip juos transformuoti, keliant iš vienos paradigmos į kitą. Nors keliuose darbuose yra parodoma, kaip objektinių šablonų realizacijas perrašyti aspektinėmis programavimo kalbomis, nė viename iš jų šablonų transformavimo klausimai nebuvo nagrinėti sistemiškai. Šioje disertacijoje nagrinėjami grynieji aspektinio projektavimo šablonai, kurie buvo transformuoti iš objektinių projektavimo šablonų, apibrėžiama sistemiška tokio transformavimo procedūra ir analizuojamas tokių šablonų taikymas aspektiniams dalykiniams karkasams projektuoti. Atskiro atvejo analizės tyrimo metodas disertacijoje yra naudojamas, siekiant išsiaiškinti, kokį poveikį grynieji aspektiniai šablonai padaro aspektinių... [toliau žr. visą tekstą]

Programų sistemos yra dažnai keičiamos, siekiant jas pritaikyti prie pasikeitusių reikalavimų ir dėl nuolat kintančių technologijų. Modulinė sistemos architektūra įgalina nepriklausomus dalykinius turinius realizuoti nepriklausomais ar nedaug vienas nuo kito priklausomais moduliais, kuriuos galima keisti nepriklausomai vienas nuo kito. Tačiau esamomis priemonėmis galima atskirti ne visus turinius. Kai kurie dalykiniai turiniai yra susipynę tarpusavyje ir jų negalima realizuoti savarankiškais moduliais. Šiai problemai spręsti buvo pasiūlyta nauja programų sistemų inžinerijos paradigma – aspektinė paradigma. Tačiau sistemų projektavimo technologija joje kol kas dar nėra pakankamai brandi. Vis dar nėra žinoma, kuriuos objektinio projektavimo šablonus galima panaudoti aspektinėje paradigmoje ir kaip juos transformuoti, keliant iš vienos paradigmos į kitą. Nors keliuose darbuose yra parodoma, kaip objektinių šablonų realizacijas perrašyti aspektinėmis programavimo kalbomis, nė viename iš jų šablonų transformavimo klausimai nebuvo nagrinėti sistemiškai. Šioje disertacijoje nagrinėjami grynieji aspektinio projektavimo šablonai, kurie buvo transformuoti iš objektinių projektavimo šablonų, apibrėžiama sistemiška tokio transformavimo procedūra ir analizuojamas tokių šablonų taikymas aspektiniams dalykiniams karkasams projektuoti. Atskiro atvejo analizės tyrimo metodas disertacijoje yra naudojamas, siekiant išsiaiškinti, kokį poveikį grynieji aspektiniai šablonai padaro aspektinių... [toliau žr. visą tekstą] / Software systems are permanently changed in order to meet new requirements and to adapt them to permanently changing technology. Design modularity decouples design concerns that probably can be changed and in this way facilitates further system changes. Unfortunately, some design concerns, called crosscutting concerns, cannot be modularized using traditional modularization methods and techniques. Modularization of crosscutting concerns is the research subject of the new emerging software engineering paradigm, aspect-oriented analysis and design. However, this paradigm is still not enough mature. It is still unknown, which design patterns developed in the object-oriented paradigm can be adapted for aspect-oriented paradigm and how to transform them from one paradigm to another in a systematic way. Despite the fact that some attempts have been done to solve this problem, the proposed solutions only eliminate crosscutting concerns in object-oriented design patterns, but do not generate pure aspect-oriented patterns. The thesis defines the class of object-oriented design patterns which can be transformed into pure aspect-oriented ones, proposes a systematic procedure for such transformation and investigates properties of resulting patterns from the viewpoint of their applicability in the design of aspect-oriented domain frameworks. This is the main contribution of the research work. The case study methodology has been used for the experimental research of the properties of... [to full text]

El testing del software es una tarea crucial y a la vez muy desafiante dentro del proceso de desarrollo de software. El testing permite encontrar errores y problemas del software contra la especificación del mismo y cumple un rol fundamental en el aseguramiento de la calidad del producto. Entre los tipos de pruebas que se pueden realizar al software están las pruebas de unidad, carga, integración y funcionales. Cada una de ellas tiene distintos objetivos y son realizadas en diferentes etapas del desarrollo del software. En el primer tipo mencionado, se desarrollan pruebas a componentes individuales de un sistema de software. Los desarrolladores especifican y codifican pruebas para cubrir todos o al menos una parte significativa de los posibles estados/configuraciones del artefacto o unidad de software, para simular el entorno del componente y descubrir la presencia de errores o “bugs”. Dado que escribir todas esas pruebas de forma manual es costoso, las pruebas de unidad son generalmente realizadas de manera ineficiente o simplemente dejadas de lado. El panorama es aún peor, más allá del esfuerzo, porque el testing no puede ser usado para probar la usencia de errores en el software sino tan solo la presencia. Por eso es necesario atacar el problema desde diferentes enfoques, cada uno teniendo sus fortalezas y ventajas. Actualmente existen muchas técnicas para hacer testing de software, y la mayoría de ellos se basan en la automatización de pasos o caminos de ejecución, con valores fijos o componentes predefinidos (hard-coded) o estáticos, y condiciones específicas. En este trabajo de maestría, se presenta un enfoque para pruebas de unidad en la programación orientada a objetos, basado en la generación de objetos de manera aleatoria. El fundamento básico de este enfoque propuesto es el testing aleatorio. También se presenta una herramienta de testing de unidad que usa el enfoque dicho, y que fue escrita en un lenguaje orientado a objetos de amplia difusión. El testing aleatorio (RT o random testing) como técnica no es nueva. Tampoco lo es la generación de valores aleatorios para pruebas. En el paradigma funcional, existe una herramienta muy conocida para probar especificaciones sobre funciones llamada QuickCheck. Ésta herramienta (escrita en Haskell) y sus ideas subyacentes son usadas como fundamento para la herramienta creada en este trabajo. La herramienta desarrollada en el presente trabajo cubre además características que existen en el paradigma orientado a objetos de manera inherente, tales como el estado de los objetos (en particular los objetos singleton con estado), clases abstractas e interfaces, que no existen en la programación funcional pura. La constribución de este trabajo de maestría es la presentación de una forma alternativa de realizar tests de unidad en la programación orientada a objetos (POO), basada en un trabajo anterior para el paradigma funcional. También se presenta una herramienta llamada YAQC4J que plasma esas ideas en un lenguaje orientado a objetos de amplia difusión. Finalmente se incluyen ejemplos que ilustran el uso de la herramienta, y se presenta una comparación con herramientas existentes que han intentado implementar el enfoque de testing. Este trabajo está dirigido a los desarrolladores de software interesados en conocer soluciones alternativas para el testing de unidad, y al mismo tiempo una forma complementaria a las ya existentes para pruebas de unidad.