SBGN Bricks Ontology as a tool to describe recurring concepts in molecular networks.

A comprehensible representation of a molecular network is key to communicating and understanding scientific results in systems biology. The Systems Biology Graphical Notation (SBGN) has emerged as the main standard to represent such networks graphically. It has been implemented by different software tools, and is now largely used to communicate maps in scientific publications. However, learning the standard, and using it to build large maps, can be tedious. Moreover, SBGN maps are not grounded on a formal semantic layer and therefore do not enable formal analysis. Here, we introduce a new set of patterns representing recurring concepts encountered in molecular networks, called SBGN bricks. The bricks are structured in a new ontology, the Bricks Ontology (BKO), to define clear semantics for each of the biological concepts they represent. We show the usefulness of the bricks and BKO for both the template-based construction and the semantic annotation of molecular networks. The SBGN bricks and BKO can be freely explored and downloaded at sbgnbricks.org

Software Visualization in 3D: Implementation, Evaluation, and Applicability

The focus of this thesis is on the implementation, the evaluation and the useful application of the third dimension in software visualization. Software engineering is characterized by a complex interplay of different stakeholders that produce and use several artifacts. Software visualization is used as one mean to address this increasing complexity. It provides role- and task-specific views of artifacts that contain information about structure, behavior, and evolution of a software system in its entirety. The main potential of the third dimension is the possibility to provide multiple views in one software visualization for all three aspects. However, empirical findings concerning the role of the third dimension in software visualization are rare. Furthermore, there are only few 3D software visualizations that provide multiple views of a software system including all three aspects. Finally, the current tool support lacks of generating easy integrateable, scalable, and platform independent 2D, 2.5D, and 3D software visualizations automatically. Hence, the objective is to develop a software visualization that represents all important structural entities and relations of a software system, that can display behavioral and evolutionary aspects of a software system as well, and that can be generated automatically. In order to achieve this objective the following research methods are applied. A literature study is conducted, a software visualization generator is conceptualized and prototypically implemented, a structured approach to plan and design controlled experiments in software visualization is developed, and a controlled experiment is designed and performed to investigate the role of the third dimension in software visualization. The main contributions are an overview of the state-of-the-art in 3D software visualization, a structured approach including a theoretical model to control influence factors during controlled experiments in software visualization, an Eclipse-based generator for producing automatically role- and task-specific 2D, 2.5D, and 3D software visualizations, the controlled experiment investigating the role of the third dimension in software visualization, and the recursive disk metaphor combining the findings with focus on the structure of software including useful applications of the third dimension regarding behavior and evolution

Informatisation d'une forme graphique des Langues des Signes : application au système d'écriture SignWriting

Les recherches et les logiciels présentés dans cette étude s'adressent à une importante minorité au sein de notre société, à savoir la communauté des sourdes. De nombreuses recherches démontrent que les sourdes se heurtent à de grosses difficultés avec la langue vocale, ce qui explique pourquoi la plu- part d'entre eux préfère communiquer dans la langue des signes. Du point de vue des sciences de l'information, les LS constituent un groupe de minorités linguistiques peu représentées dans l'univers du numérique. Et, de fait, les sourds sont les sujets les plus touchés par la fracture numérique. Cette étude veut donc être une contribution pour tenter de resserrer cette fracture numérique qui pénalise les sourdes. Pour ce faire, nous nous sommes principalement concentrés sur l'informatisation de SignWriting, qui constitue l'un des systèmes les plus prometteurs pour écrire la LS.The studies and the software presented in this work are addressed to a relevant minority of our society, namely deaf people. Many studies demonstrate that, for several reasons, deaf people experience significant difficulties in exploiting a Vocal Language (VL English, Chinese, etc.). In fact, many of them prefer to communicate using Sign Language (SL). As computer scientists, we observed that SLs are currently a set of underrepresented linguistic minorities in the digital world. As a matter of fact, deaf people are among those individuals which are mostly affected by the digital divide. This work is our contribution towards leveling the digital divide affecting deaf people. In particular, we focused on the computer handling of SignWriting, which is one of the most promising systems devised to write SLs

Prosodic Font : the space between the spoken and the written

Thesis (S.M.)--Massachusetts Institute of Technology, School of Architecture and Planning, Program in Media Arts and Sciences, 1998."August 1998."Includes bibliographical references (leaves 131-133).by Tara Michelle Graber Rosenberger.S.M

Generic Roles: Reducing Code Replication

In partial fulfillment of requirements for the degree of Doctor of Philosophy in Informatics Enginnering by the Doctoral Program in Informatics EngineeringFor many years the concept of modularity has been considered a very important part in the development of large software systems. Modules help to manage the system’s complexity by decomposing it in smaller parts. These parts can be assigned to individuals or teams for development. Modules hide the information they manipulate behind an interface, allowing its developers to develop the module independently of any other module in the system. Developers can change the information their module manipulates and even the way it does it without the need to consult other developers, and breaking their code. This enables the interchangeability of modules, allowing one module to be substituted by another without further modifications to the system. It also reduces compiling time as modules can be precompiled. The concept of modularization lead to the dawn of several decompositions techniques, each with its own ideas on how a system should be decomposed into modules. For each decomposition technique and to help programmers extract the most benefits from modularization, several programming languages provide support for expressing modules. In object-oriented decomposition, for example, several programming languages provide support to define abstract data types, usually in the form of classes. Ideally, each module would capture one coherent concept that would deal with a set of coherent concerns related to the module’s concept. Unfortunately that is not always true. Sometimes, modules need to interact in more complicated and intertwined manners. Sometimes, the need to communicate with other modules lead one module to assume concerns that are not related to its main concern. This is, as argued by many authors, because only a single decomposition strategy is used . To avoid this we may need to use more than one decompositions strategy or extend an existing one. Code clones are an outcome of the lack of other decomposition strategies, among others sources. Code cloning in a system is considered a bad thing with multiple drawbacks. One of the more known problems is the inconsistent maintenance: bugs are fixed in some clones, but not in others. Another major objection to the use of cloning is that it degrades the design of the system over time. Awkward, verbose designs lead to the accumulation of irrelevant code that ends up obscuring the original intent of the code. In this dissertation we study the reduction of the code replication using modularity as a cornerstone around which our solution must be based. We intend to reduce code replication using another kind of module, which we can use to extend the object-oriented strategy. The module that we will study is the role. Roles have been used to specify na object’s behavior related to a specific collaboration in the modeling stages of a system. But in the implementation that specification is merged with all the object’s other collaboration behaviors, inside a class. It is a purpose of this dissertation to take the specification from the design phase to the implementation phase and study its impact on the code replication problem. The solution proposed in this dissertation is to use roles as a way to compose classes and thus reducing code replication. To pursue this goal a role language is designed and a suitable compiler is implemented. The JavaStage language allows a programmer to “program with roles”. It introduces several features like a powerful renaming mechanism and to state role dependencies easily. Using JavaStage and roles we were able to identify several refactorings that enables us to write the replicated code as roles thus removing the code clone. The use of these refactorings proved their value when applied to a series of case studies developed to assess the amount of duplicated code that could be removed using roles. As already mentioned, the modularity principles were followed throughout the design of the proposed solution and, to assess the reusability of roles, a role library was started. Its evolution corroborates the idea that roles are reusable modules and can be used as a compositional element.A modularidade é, já há muitos anos, vista como uma peça importante no desenvolvimento de sistemas informáticos de grandes dimensões. Os módulos ajudam a gerir a complexidade do sistema decompondo-o em várias partes mais pequenas que podem ser adjudicadas a um indivíduo ou a uma equipa para desenvolvimento. Os módulos encapsulam a informação que manipulam e o modo como a manipulam, permitindo assim aos seus autores desenvolvêlo independentemente dos outros módulos do sistema. Os autores de um módulo podem, inclusivé, alterar o modo de representação da informação à medida das suas necessidades, ou até alterar o modo de a manipular, sem consultar os autores dos outros módulos e sem quebrar os módulos destes. Isto permite a permutação de módulos, podendo assim um módulo ser substituído por outro sem que o sistema sofra outras alterações. Também permite um tempo de compilação mais rápido devido a poder-se pré-compilar os vários módulos. O conceito de modularização levou ao surgimento de várias estratégias de decomposição, cada uma com as suas ideias sobre como um sistema deveria ser decomposto em módulos. Para cada uma destas estragégias, e para ajudar os programadores a usufruir ao máximo dos benefícios da modularização, surgiram várias linguagens de programação com suporte para a representação de módulos. Por exemplo, na decomposição orientada a objetos, muitas linguagens permitem a definição de tipos abstratos de dados, normalmente na forma de classes. Idealmente, cada módulo capturaria um conceito coerente e esse conceito lidaria com um conjunto coerente de responsabilidades ligadas ao conceito principal do módulo. Infelizmente, não é assim. Por vezes os módulos precisam de interagir de forma mais complexa e interligada com outros módulos. Outras vezes a necessidade de comunicar com outros módulos leva-os a assumir responsabilidades que não estão de acordo com a sua “razão de ser”. Isto, como é argumentado por muitos autores, é uma consequência do uso de uma única estratégia de decomposição. Para evitar isto provavelmente necessita-se de uma outra forma de decomposição ou expandir uma já existente. O aparecimento de clones no código é uma consequência do uso de uma única estratégia de decomposição, entre outras causas. A presença de código repetido num sistema é considerada um mau indício e acarta muitas consequências nefastas. Um dos problemas mais conhecidos é a inconsistência na manutenção: os bugs são reparados em algumas instâncias do código repetido mas não em todas. Outro grande problema do uso de cópias de código é que o seu uso irá degradar o design do sistema a longo prazo. Isto leva à acumulação de código irrelevante que acaba por obscurecer o objectivo inicial do código. Nesta tese tenta-se estudar a redução de código repetido usando a modularidade como “pedra de toque” em torno da qual a nossa solução se baseará. Tencionámos reduzir a repetição de código usando outro tipo de módulo, que nos permita expandir a decomposição orientada a objetos. O módulo que iremos estudar será o role. Os roles têm vindo a ser usados para especificar o comportamento de um objeto em relação a outro objeto, dentro de uma colaboração, na etapa de modelação do sistema. Mas, na fase de implementação, essa especificação é agrupada com todos os comportamentos que o objeto exibe em todas as suas colaborações, dentro de uma classe. É um dos propósitos desta tese levar esta especificação desde a fase de modelação até à fase de implementação e estudar o seu impacto no problema de repetição de código. A solução proposta nesta dissertação é usar os roles como uma maneira de compor classes e assim reduzir a repetição de código. Para atingir este objectivo uma linguagem de programação que suporta roles será idealizada e um compilador adequado desenvolvido. A linguagem JavaStage permite a um programador “programar com roles”. Ela introduz algumas funcionalidades como um mecanismo de renomeação de métodos poderoso e uma forma de exprimir as dependências do role facilmente. Usando a JavaStage e os roles fomos capazes de identificar várias refactorings que nos permitem expressar o código presente nas várias repetições como roles e assim remover o código repetido associado. Estas refactorings mostraram o seu valor quando usadas numa série de casos de estudo que foram desenvolvidos com o propósito de avaliar a quantidade de código repetido que se poderia remover usando roles. Como já foi mencionado os princípios da modularidade foram seguidos ao longo da concepção da solução proposta e para avaliar a reutilização dos roles a construção de uma biblioteca de roles foi iniciada. A sua evolução corrobora a ideia de que os roles são módulos reutilizáveis e podem ser usados como um elemento composicional de classes

Software quality attribute measurement and analysis based on class diagram metrics

Software quality measurement lies at the heart of the quality engineering process. Quality measurement for object-oriented artifacts has become the key for ensuring high quality software. Both researchers and practitioners are interested in measuring software product quality for improvement. It has recently become more important to consider the quality of products at the early phases, especially at the design level to ensure that the coding and testing would be conducted more quickly and accurately. The research work on measuring quality at the design level progressed in a number of steps. The first step was to discover the correct set of metrics to measure design elements at the design level. Chidamber and Kemerer (C&K) formulated the first suite of OO metrics. Other researchers extended on this suite and provided additional metrics. The next step was to collect these metrics by using software tools. A number of tools were developed to measure the different suites of metrics; some represent their measurements in the form of ordinary numbers, others represent them in 3D visual form. In recent years, researchers developed software quality models which went a bit further by computing quality attributes from collected design metrics. In this research we extended on the software quality modelers’ work by adding a quality attribute prioritization scheme and a design metric analysis layer. Our work is all focused on the class diagram, the most fundamental constituent in any object oriented design. Using earlier researchers’ work, we extract a class diagram’s metrics and compute its quality attributes. We then analyze the results and inform the user. We present our figures and observations in the form of an analysis report. Our target user could be a project manager or a software quality engineer or a developer who needs to improve the class diagram’s quality. We closely examine the design metrics that affect quality attributes. We pinpoint the weaknesses in the class diagram, based on these metrics, inform the user about the problems that emerged from these classes, and advice him/her as to how he/she can go about improving the overall design quality. We consider the six basic quality attributes: “Reusability”, “Functionality”, “Understandability”, “Flexibility”, “Extendibility”, and “Effectiveness” of the whole class diagram. We allow the user to set priorities on these quality attributes in a sequential manner based on his/her requirements. Using a geometric series, we calculate a weighted average value for the arranged list of quality attributes. This weighted average value indicates the overall quality of the product, the class diagram. Our experimental work gave us much insight into the meanings and dependencies between design metrics and quality attributes. This helped us refine our analysis technique and give more concrete observations to the user

Hacking Cultural Heritage : the Hackathon as a Method for Heritage Interpretation

Hackathons were originated from both the evolution of and revolution caused by personal computers. Initially, they have been implemented as a collaborative method for solving computer-related problems or conceptualizing new possibilities based on specific infrastructures. Only later on, when Cultural Institutions had undergone intensive digitization, Hackathons started to be part of their repertoire. Because of the special nature of Cultural Institutions, Hackathons for Cultural Heritage cannot be understood in the same way as their counterparts happening in a purely engineering domain. Problem solving and conceptualization through collaborative programming are entangled with the significance of the content matter they intend to deal with: the institutionsa collections. Based on these considerations, this thesis aims at explaining the underlying principles, interactions, and infrastructures of the Hackathon as a method for Heritage Interpretation. Moreover, the thesis also proposes a Fast-speed IT Platform, which was designed within the context of the Two-speed IT infrastructure, where a foundational, stable, and slow infrastructure is complemented by an additional creative, experimental, and agile infrastructure, which is capable of promptly responding to the needs of communities. The platform is an effort to implement strategies for interpreting, recontextualizing, and telling stories with Digital Collections. In addition, the platform aims at mitigating problems concerning technical knowledge that is usually required for taking advantage of the affordances of Digital Collections as a creative material

Semantic Domains in Akkadian Text

The article examines the possibilities offered by language technology for analyzing semantic fields in Akkadian. The corpus of data for our research group is the existing electronic corpora, Open richly annotated cuneiform corpus (ORACC). In addition to more traditional Assyriological methods, the article explores two language technological methods: Pointwise mutual information (PMI) and Word2vec.Peer reviewe