Shape interpretation with design computing

How information is interpreted has significant impact on how it can be used. This is particularly important in design where information from a wide variety of sources is used in a wide variety of contexts and in a wide variety of ways. This paper is concerned with the information that is created, modified and analysed during design processes, specifically with the information that is represented in shapes. It investigates how design computing seeks to support these processes, and the difficulties that arise when it is necessary to consider alternative interpretations of shape. The aim is to establish the problem of shape interpretation as a general challenge for research in design computing, rather than a difficulty that is to be overcome within specific processes. Shape interpretations are common characteristics of several areas of enquiry in design computing. This paper reviews these, brings an integrated perspective and draws conclusions about how this underlying process can be supported

Zero-gravity movement studies

The use of computer graphics to simulate the movement of articulated animals and mechanisms has a number of uses ranging over many fields. Human motion simulation systems can be useful in education, medicine, anatomy, physiology, and dance. In biomechanics, computer displays help to understand and analyze performance. Simulations can be used to help understand the effect of external or internal forces. Similarly, zero-gravity simulation systems should provide a means of designing and exploring the capabilities of hypothetical zero-gravity situations before actually carrying out such actions. The advantage of using a simulation of the motion is that one can experiment with variations of a maneuver before attempting to teach it to an individual. The zero-gravity motion simulation problem can be divided into two broad areas: human movement and behavior in zero-gravity, and simulation of articulated mechanisms

On the Feasibility of Transfer-learning Code Smells using Deep Learning

Context: A substantial amount of work has been done to detect smells in source code using metrics-based and heuristics-based methods. Machine learning methods have been recently applied to detect source code smells; however, the current practices are considered far from mature. Objective: First, explore the feasibility of applying deep learning models to detect smells without extensive feature engineering, just by feeding the source code in tokenized form. Second, investigate the possibility of applying transfer-learning in the context of deep learning models for smell detection. Method: We use existing metric-based state-of-the-art methods for detecting three implementation smells and one design smell in C# code. Using these results as the annotated gold standard, we train smell detection models on three different deep learning architectures. These architectures use Convolution Neural Networks (CNNs) of one or two dimensions, or Recurrent Neural Networks (RNNs) as their principal hidden layers. For the first objective of our study, we perform training and evaluation on C# samples, whereas for the second objective, we train the models from C# code and evaluate the models over Java code samples. We perform the experiments with various combinations of hyper-parameters for each model. Results: We find it feasible to detect smells using deep learning methods. Our comparative experiments find that there is no clearly superior method between CNN-1D and CNN-2D. We also observe that performance of the deep learning models is smell-specific. Our transfer-learning experiments show that transfer-learning is definitely feasible for implementation smells with performance comparable to that of direct-learning. This work opens up a new paradigm to detect code smells by transfer-learning especially for the programming languages where the comprehensive code smell detection tools are not available

Knowledge Representation with Ontologies: The Present and Future

Recently, we have seen an explosion of interest in ontologies as artifacts to represent human knowledge and as critical components in knowledge management, the semantic Web, business-to-business applications, and several other application areas. Various research communities commonly assume that ontologies are the appropriate modeling structure for representing knowledge. However, little discussion has occurred regarding the actual range of knowledge an ontology can successfully represent

Process Modeling For BPR: Event-Process Chain Approach

Most of the recent research on business process redesign (BPR) focused on people or management related issues. Completing a successful BPR project, however, requires a disciplined method to model the target business processes effectively as well. Currently available process modeling methods fail to meet the specific BPR process characteristics (cross-functional, customer-oriented) and the ideai features of a modeling formalism (expressiveness, simplicity) simultaneously. In this paper, a new process modeling method exclusively designed to support BPR fromthecustomer\u27sperspective,basedontheconceptofevent-processchain(EPC),isintroduced. TheEPCmodel is analyzed, along with five other methods, over the above criteria to prove its appropriateness for BPR and its strength as a powerful and elegant modeling formalism. We also report on the application of the EPC modeling method to three real world BPR projects and suggest its future enhancement directions

An Architecture for Integrating Concurrency Control into Environment Frameworks

Research in layered and componentized systems shows the benefit of dividing the responsibility of services into separate components. It is still an unresolved issue, however, how a system can be created from a set of existing (independently developed) components. This issue of integration is of immense concern to software architects since a proper solution would reduce duplicate implementation efforts and promote component reuse. In this paper we take a step towards this goal within the domain of software development environments (SDEs) by showing how to integrate an external concurrency control component, called Pern, with environment frameworks. We discuss two experiments where we integrated Pern with Oz, a multi-site, decentralized process centered environment, and Process WEAVER, a commercial process server. We introduce an architecture for retrofitting an external concurrency control component into an environment

Static Analysis of Shape in TensorFlow Programs

Machine learning has been widely adopted in diverse science and engineering domains, aided by reusable libraries and quick development patterns. The TensorFlow library is probably the best-known representative of this trend and most users employ the Python API to its powerful back-end. TensorFlow programs are susceptible to several systematic errors, especially in the dynamic typing setting of Python. We present Pythia, a static analysis that tracks the shapes of tensors across Python library calls and warns of several possible mismatches. The key technical aspects are a close modeling of library semantics with respect to tensor shape, and an identification of violations and error-prone patterns. Pythia is powerful enough to statically detect (with 84.62% precision) 11 of the 14 shape-related TensorFlow bugs in the recent Zhang et al. empirical study - an independent slice of real-world bugs