Oilfield Production Surveillance as a Management Tool for Environmental Monitoring

Oilfield production surveillance is the effective monitoring of petroleum reservoirs, producing wells, flow station facilities and flow lines. Through surveillance, the production of unwanted effluents (formation water,excess gas, etc.) can be controlled. Production problems such as sand production, emulsion, corrosion, scale formation and wax blockage can lead to disposal problems and poor integrity of facilities and consequent financial losses. This paper presents a system approach for carrying out oilfield production surveillance process. Using case studies it isshown that the process can be used to identify unfavourable conditions such as gas leaks, corrosivity, and unsafe wells. It is further recommended that the frequency of surveillance should be monthl

The relevance of application domains in empirical findings

The term 'software ecosystem' refers to a collection of software systems that are related in some way. Researchers have been using different levels of aggregation to define an ecosystem: grouping them by a common named project (e.g., the Apache ecosystem); or considering all the projects contained in online repositories (e.g., the GoogleCode ecosystem). In this paper we propose a definition of ecosystem based on application domains: software systems are in the same ecosystem if they share the same application domain, as described by a similar technological scope, context or objective. As an example, all projects implementing networking capabilities to trade Bitcoin and other virtual currencies can be considered as part of the same "cryp-tocurrency" ecosystem. Utilising a sample of 100 Java software systems, we derive their application domains using the Latent Dirichlet Allocation (LDA) approach. We then evaluate a suite of object-oriented metrics per ecosystem, and test a null hypothesis: 'the OO metrics of all ecosystems come from the same population'. Our results show that the null hypothesis is rejected for most of the metrics chosen: the ecosystems that we extracted, based on application domains, show different structural properties. From the point of view of the interested stakeholders, this could mean that the health of a software system depends on domain-dependent factors, that could be common to the projects in the same domain-based ecosystem

An empirical study on object-oriented software dependencies: logical, structural and semantic

This thesis was submitted for the award of Doctor of Philosophy and was awarded by Brunel University LondonThree of the most widely studied software dependency types are the structural, logical and semantic dependencies. Logical dependencies capture the degree of co-change between software artifacts. Semantic dependencies capture the degree to which artifacts, comments and names are related. Structural dependencies capture the dependencies in the source code of artifacts. Prior studies show that a combination of dependency analysis (e.g., semantic and logical analysis) improves accuracy when predicting which artifacts are likely to be impacted by ripple effects of software changes (though not to a large extent) compared to individual approaches. In addition, some dependencies could be hidden dependencies when an analysis of one dependency type (e.g., logical) does not reveal artifacts only linked by another dependency type (semantic). While previous studies have focused on combining dependency information with minimal benefits, this Thesis explores the consistency of these measurements, and whether hidden dependencies arise between artifacts, and in any of the axes studied. In this Thesis, 79 Java projects are empirically studied to investigate (i) the direct influence and the degree of overlap between dependency types on three axes (logical – structural (LSt); logical – semantic (LSe); structural – semantic (StSe)) (structural, logical and semantic), and (ii) the presence of hidden coupling on the axes. The results show that a high proportion of hidden dependencies can be detected on the LSt and StSe axes. Notwithstanding, the LSe axis shows a much smaller proportion of hidden dependencies. Practicable refactoring methods to mitigate hidden dependencies are proposed in the Thesis and discussed with examples

An empirical analysis of source code metrics and smart contract resource consumption

A smart contract (SC) is a programme stored in the Ethereum blockchain by a contract‐creation transaction. SC developers deploy an instance of the SC and attempt to execute it in exchange for a fee, paid in Ethereum coins (Ether). If the computation needed for their execution turns out to be larger than the effort proposed by the developer (i.e., the gasLimit ), their client instantiation will not be completed successfully. In this paper, we examine SCs from 11 Ethereum blockchain‐oriented software projects hosted on GitHub.com, and we evaluate the resources needed for their deployment (i.e., the gasUsed ). For each of these contracts, we also extract a suite of object‐oriented metrics, to evaluate their structural characteristics. Our results show a statistically significant correlation between some of the object‐oriented (OO) metrics and the resources consumed on the Ethereum blockchain network when deploying SCs. This result has a direct impact on how Ethereum developers engage with a SC: evaluating its structural characteristics, they will be able to produce a better estimate of the resources needed to deploy it. Other results show specific source code metrics to be prioritised based on application domains when the projects are clustered based on common themes

Application domains in the Research Papers at BENEVOL: a retrospective

Research on empirical software engineering has increasingly used the data that is made available in online repositories , specifically Free/Libre/Open Source Software projects (FLOSS). The latest trends for researchers is to gather "as much data as possible" to (i) prevent bias in the representation of a small sample, (ii) work with a sample as close as the population itself, and (iii) showcase the performance of existing or new tools in treating vast amount of data. The effects of harvesting enormous amounts of data have been only marginally considered so far: data could be corrupted; repositories could be forked; and developer identities could be duplicated. In this paper we posit that there is a fundamental flaw in harvesting large amounts of data, and when generalising the conclusions: the application domain, or context, of the analysed systems must be the primary factor for the cluster sampling of FLOSS projects. This paper presents two contributions: first, we analyse a collection of 100 BENEVOL papers that appeared showing whether (and how much) FLOSS data has been harvested, and how many times the authors flagged an issue in their different application domains. Second, we discuss the implications of using 'application domain' as the clustering factor in FLOSS sampling, and the generalisations within and outside the clusters

Lexical content as a cooperation aide: a study based on Java software

Collaborative development is a paradigm shift in software development. Loosely coupled developers coordinate their work via distributed versioning systems (SVN, Git, and others), code reviews and priority-led bug tracking systems. This development approach allows many different developers to input additional source code to the same source artifact. This article focuses on the lexical content of the source code produced in a collaborative environment. The lexical content is described as the 'dictionary' of the key terms contained within a source artifact. We posit that the lexical content of a Java class will increase as long as more developers add more content to the same class. We analyse the 100 top-ranked GitHub applications (at the time of the sampling) written in Java. Each of their classes is reduced to its lexical content , its size (in LOCs) recorded, as well as the number of different developers who contributed to its source code. Our results show that (i) the lexical content of Java classes is bounded in size, (ii) more developers make the size of the lexical content larger, and (iii) the lexical content of a system's classes might increase with more developers, but depending on its application domain. The implications for practitioners are twofold: (i) classes with a large set of lexical content should be split in multiple classes, to minimize the need for further maintenance; and (ii) classes developed by many developers should adhere to specific guidelines so that its lexical content does not increase boundlessly. We tested our results in a tailored case study and we confirmed our findings: larger-than-threshold class corpora tend to deteriorate the class cohesion

Trust-based Approaches Towards Enhancing IoT Security: A Systematic Literature Review

The continuous rise in the adoption of emerging technologies such as Internet of Things (IoT) by businesses has brought unprecedented opportunities for innovation and growth. However, due to the distinct characteristics of these emerging IoT technologies like real-time data processing, Self-configuration, interoperability, and scalability, they have also introduced some unique cybersecurity challenges, such as malware attacks, advanced persistent threats (APTs), DoS /DDoS (Denial of Service & Distributed Denial of Service attacks) and insider threats. As a result of these challenges, there is an increased need for improved cybersecurity approaches and efficient management solutions to ensure the privacy and security of communication within IoT networks. One proposed security approach is the utilization of trust-based systems and is the focus of this study. This research paper presents a systematic literature review on the Trust-based cybersecurity security approaches for IoT. A total of 23 articles were identified that satisfy the review criteria. We highlighted the common trust-based mitigation techniques in existence for dealing with these threats and grouped them into three major categories, namely: Observation-Based, Knowledge-Based & Cluster-Based systems. Finally, several open issues were highlighted, and future research directions presented.Comment: 20 Pages, Conferenc