Source Code Control Research Articles

ARCHITECTING LOCATION INTELLIGENCE PLATFORMS USING OPEN-SOURCE COMPONENTS

Abstract. Location Intelligence is an emerging application of geospatial industry. It allows professionals from different business domains (finance, disaster management, retail, health) and with minimum expertise in GIS technologies to use efficiently many spatial analysis tools and algorithms to solve their day-to-day problems. One of the major characteristics of Location Intelligence is the use of multisource and alternative data either user ingested or directly available in the platform (by geo-enrichment).In this contribution we investigate the architectural challenges raised by the development of this kind of platforms, particularly in term of functionalities, use of open-source components, management practices, deployment on the Cloud and source code control. To validate our assumptions, we built a new platform, named “Geoweba”, based on the GeoNode Project and having as objective to disrupt the Algerian consulting market. The resulting platform is deployed on the internet and freely available for users. In this contribution we demonstrate that our development approach based on Agile principles and open-source components gives a good result, mainly in the early stages when just a Minimum Viable Product (MVP) is needed for market validation of the idea.

Project repositories for machine learning with TensorFlow

Abstract In machine learning, models capture intelligence from data using algorithms implemented on frameworks like TensorFlow. Models learn during the training phase; an iterative process in which parameters are tuned to improve the prediction accuracy. Software repositories are used to save the artifacts of model development so that they can be modified in subsequent releases and shared between development teams. Issues in saving the state of machine learning projects is different from standard software practices. Machine learning models are equivalent to binary executable programs and ideally one should be able to recreate the model from the information preserved in project repositories. Recreation of the model becomes necessary when there is a change in the development team as part of the product transition. Retraining of models also becomes necessary when the inaccuracy in the predictions made on new data increases beyond the acceptable limit. When traditional source code management systems are used for maintaining repositories of machine learning projects, we face challenges in keeping complete information required for model development starting from saved states. This paper presents the results of the studies conducted to identify the challenges in maintaining TensorFlow machine learning projects in repositories. Some of the existing tools are compared and recommendations are made to improve the ease of recreation of machine learning models by saving complete information in project repositories maintained in normal source code control systems.

Scalable Source Code Similarity Detection in Large Code Repositories

Source code similarity are increasingly used in application development to identify clones, isolate bugs, and find copy-rights violations. Similar code fragments can be very problematic due to the fact that errors in the original code must be fixed in every copy. Other maintenance changes, such as extensions or patches, must be applied multiple times. Furthermore, the diversity of coding styles and flexibility of modern languages makes it difficult and cost ineffective to manually inspect large code repositories. Therefore, detection is only feasible by automatic techniques. We present an efficient and scalable approach for similar code fragment identification based on source code control flow graphs fingerprinting. The source code is processed to generate control flow graphs that are then hashed to create a unique fingerprint of the code capturing semantics as well as syntax similarity. The fingerprints can then be efficiently stored and retrieved to perform similarity search between code fragments. Experimental results from our prototype implementation supports the validity of our approach and show its effectiveness and efficiency in comparison with other solutions.

Files synchronization from a large number of insertions and deletions

Synchronization between different versions of files is becoming a major issue that most of the applications are facing. To make the applications more efficient a economical algorithm is developed from the previously used algorithm of “File Loading Algorithm”. I am extending this algorithm in three ways: First, dealing with non-binary files, Second backup is generated for uploaded files and lastly each files are synchronized with insertions and deletions. User can reconstruct file from the former file with minimizing the error and also provides interactive communication by eliminating the frequency without any disturbance. The drawback of previous system is overcome by using synchronization, in which multiple copies of each file/record is created and stored in backup database and is efficiently restored in case of any unwanted deletion or loss of data. That is, to introduce a protocol that user B may use to reconstruct file X from file Y with suitably low probability of error. Synchronization algorithms find numerous areas of use, including data storage, file sharing, source code control systems, and cloud applications. For example, cloud storage services such as Drop box synchronize between local copies and cloud backups each time users make changes to local versions. Similarly, synchronization tools are necessary in mobile devices. Specialized synchronization algorithms are used for video and sound editing. Synchronization tools are also capable of performing data duplication.

Using Formal Game Design Methods to Embed Learning Outcomes into Game Mechanics and Avoid Emergent Behaviour

This paper offers an approach to designing game-based learning experiences inspired by the Mechanics-Dynamics-Aesthetics (MDA) model (Hunicke et al., 2004) and the elemental tetrad model (Schell, 2008) for game design. A case for game based learning as an active and social learning experience is presented including arguments from both teachers and game designers concerning the value of games as learning tools. The MDA model is introduced with a classic game- based example and a non-game based observation of human behaviour demonstrating a negative effect of extrinsic motivators (Pink, 2011) and the need to closely align or embed learning outcomes into game mechanics in order to deliver an effective learning experience. The MDA model will then be applied to create a game based learning experience with the goal of teaching some of the aspects of using source code control to groups of Computer Science students. First, clear aims in terms of learning outcomes for the game are set out. Following the learning outcomes, the iterative design process is explained with careful consideration and reflection on the impact of specific design decisions on the potential learning experience. The reasons those decisions have been made and where there may be conflict between mechanics contributing to learning and mechanics for reasons of gameplay are also discussed. The paper will conclude with an evaluation of results from a trial of computer science students and staff, and the perceived effectiveness of the game at delivering specific learning outcomes, and the approach for game design will be assessed.

A hybrid methodology to detect memory leaks in soft real-time embedded systems software

As embedded software becomes complex and time to production needs to be minimized, early fixing of flaws in a software design is important. Memory leaks are the most important memory-related problems commonly occurring in embedded software development. We propose a novel hybrid automated memory leak detection approach for soft real-time embedded system software. Our approach combines static and dynamic methodologies to overcome their individual limitations. The static phase generates potential memory leak warnings with the help of source code annotation and control flow graphs. The dynamic phase involves simulation of abstracted memory behaviour with data collected in an abstract memory model (AMM). Actual leaks are determined from the potential leak warnings generated in the static phase. The dynamic simulation phase makes our approach faster and enables early phase leak detection. Our approach is platform independent and evaluation shows that it is more accurate than existing tools.

A hybrid methodology to detect memory leaks in soft real-time embedded systems software

As embedded software becomes complex and time to production needs to be minimized, early fixing of flaws in a software design is important. Memory leaks are the most important memory-related problems commonly occurring in embedded software development. We propose a novel hybrid automated memory leak detection approach for soft real-time embedded system software. Our approach combines static and dynamic methodologies to overcome their individual limitations. The static phase generates potential memory leak warnings with the help of source code annotation and control flow graphs. The dynamic phase involves simulation of abstracted memory behaviour with data collected in an abstract memory model (AMM). Actual leaks are determined from the potential leak warnings generated in the static phase. The dynamic simulation phase makes our approach faster and enables early phase leak detection. Our approach is platform independent and evaluation shows that it is more accurate than existing tools.

An Approach for Detecting Unnecessary Cyclomatic Complexity on Source Code

Seeking product's quality is essential nowadays. One of the many quality aspects in software development is the source code complexity. Not paying attention to the complexity during the development can result in unexpected cost, caused by the difficulty on the source code understanding. The goal of this paper is to introduce an initial approach to identify unnecessary complexity in source code. Besides identifying, the approach can also show to its user how to properly rewrite the source code without the unnecessary complexity. The approach is based on the static analysis of the source code control flow graph. Once the unnecessary complexity is identified, the graph is refactored in order to allow the user to understand the improvement on the source code. The approach was included in a software tool in order to prove its concept. A performance evaluation of the approach was performed, resulting in a high accuracy. Two experimental studies were also performed to assess the viability of the approach when used by real users. The evidences provided by these studies suggests that the approach support the unnecessary complexity removal.

TOWARD A UNIFIED ENGLISH-LIKE REPRESENTATION OF SEMANTIC MODELS, DATA, AND GRAPH PATTERNS FOR SUBJECT MATTER EXPERTS

The Semantic Application Design Language (SADL) combines advances in standardized declarative modeling languages based on formal logic with advances in domain-specific language (DSL) development environments to create a controlled-English language that translates directly into the Web Ontology Language (OWL), the SPARQL graph query language, and a compatible if/then rule language. Models in the SADL language can be authored, tested, and maintained in an Eclipse-based integrated development environment (IDE). This environment offers semantic highlighting, statement completion, expression templates, hyperlinking of concepts to their definition, model validation, automatic error correction, and other advanced authoring features to enhance the ease and productivity of the modeling environment. In addition, the SADL language offers the ability to build in validation tests and test suites that can be used for regression testing. Through common Eclipse functionality, the models can be easily placed under source code control, versioned, and managed throughout the life of the model. Differences between versions can be compared side-by-side. Finally, the SADL-IDE offers an explanation capability that is useful in understanding what was inferred by the reasoner/rule engine and why those conclusions were reached. Perhaps more importantly, explanation is available of why an expected inference failed to occur. The objective of the language and the IDE is to enable domain experts to play a more active and productive role in capturing their knowledge and making it available as computable artifacts useful for automation where appropriate and for decision support systems in applications that benefit from a collaborative human-computer approach. SADL is built entirely on open source code and most of SADL is itself released to open source. This paper explores the concepts behind the language and provides details and examples of the authoring and model lifecycle support facilities.

Pinpointing Critical Errors; Basic Sterilizer Tips

A: Chances are it is a bad network card, which is an easy fix once you know which room is affected. Start by turning off your central station. Go to your database server and locate your source code control (SCC). Unplug all the rooms that correspond to that station. Turn on the central station and allow it to do a complete reboot. When the central station comes up all rooms should be present on the display. Now go back to your SCC and plug in one room at a time (it helps to have a second person so that one can watch the central station and one can plug in each room). The room that is plugged in should now come up on the display in its appropriate place. If the central station does not give the “critical error...” message that bedside is ok. When the station displays the “critical error.....” message you have found the bedside that is causing the error. Replace the network card for that monitor. Once the network card has been replaced reboot the bedside. You can now plug all of the rooms back into the SCC and reboot the central station. All rooms should come up in their appropriate location. The central should not give the “critical error....” message. If you have slaves or satellite centrals connected to your main central station, they will also need to be rebooted. If this does not work, the next step is to reload the software. This is very time consuming and will not necessarily identify or fix the problem so it should not be done unless the above steps fail to pinpoint the problem. Pinpointing Critical Errors; Basic Sterilizer Tips

Copyright Issues Relating to Customized Software

The purpose of this paper is to study in detail the copyright issues relating to customized software, and to analyze the different laws relating to this area. The various copyright laws allover the world provide that the copyright in a work is initially owned by the author of the work. This is a simple enough statement of law, but it frequently presents significant problems when individuals and companies assume that they understand who the 'author' is and under what circumstances commissioning a work results in copyright ownership vesting in someone other than the author. This problem particularly manifests itself in the world of customized software creations. This essay tries to find answers to some very pertinent questions in this area. Firstly, it analyzes the viability of excluding customized software from the ‘work for hire’ doctrine. The software industry is unique, and deserves unique treatment under the doctrine. Computer software differs notably from other copyrightable subject matter. Much of the value of software comes from its utilitarian rather than its aesthetic aspects. Secondly, it inquires into the practicability of the commissioning parties being recognized as ‘joint authors.’ Joint authorship should not be predicated on the contribution of an 'abstract' idea acted upon by another. Conversely, an idea that has been developed in sufficient detail in effect dictates the ultimate expression, making the idea giver the sole author. Between these two rare extremes, the significance of the commissioner’s contribution of ideas depends on the quantity and quality of those ideas as embodied in his instructions to the contractor. Thirdly, it studies whether the source code should be mandatorily provided to the customer under the End User License Agreement. As per the current practice, usually, the software developers, as part of the End User License Agreement, provide only the object code to the customer, and not the source code. Source code control is especially important for customized software programs. Analyzing all these issues in great detail, the author comes to the conclusion that the copyright laws relating to customized software are heavily loaded in favour of the software developer, and need significant changes.

DYNAMIC MODELS FOR TESTING BASED ON TIME SERIES ANALYSIS

In this paper, we investigate a dynamic software quality model that incorporates software process and software product measures as covariates. Furthermore, the model is not based on execution time between failures. Instead, the method relies on data commonly available from simple problem tracking and source code control systems. Fault counts, testing effort, and code churn measures are collected from each build during the system test phase of a large telecommunications software system. We use this data to predict the number of faults to expect from one build to the next. The technique we use is called time series analysis and forecasting. The methodology assumes that future predictions are based on the history of past failures and related covariates. We show that the quality model incorporating testing effort as a covariate is better than the quality model derived from fault counts alone.

ARTICULATED CONFIGURATION MANAGEMENT

AbstractArticulated Configuration Management is a system that provides a backplane for status accounting, source code control, embedded processes, and project management. It does this by automating and linking the processes that previously were manual evolutions.The implementation, and indeed the definition, of Configuration Management varies widely among both Department of Defense and civilian activities. Some possible scenarios are presented in the hope that new technology may provide a better solution and definition for all concerned.This paper discusses the evolution of Configuration Management systems of the past into new technology that fully automates and articulates the Software Engineering Environment. It is presented and demonstrated in partnership with SQL Software Inc. of Vienna, VirginiaIn its purest form, Configuration Management has always been viewed as the process of tracking change. The change vehicle itself goes by many names within the industry. It may be called a bug report, trouble report, change proposal or a multitude of other names. For the purpose of this paper, I will refer to the change vehicle as a change document.Historically, Configuration Management and its associated change documents have been paper forms or manually updated forms within a database. This traditional Configuration Management very rarely had a meaningful connection to the source code modification it was supposed to track. The advent of state of the art Configuration Management systems now provides us with the capability to join or articulate the change document with the modified code and its outputs.Configuration Management systems are usually predicated on the development, baseline, and release philosophy of an organization. This philosophy generally is implemented in one or more of the following three scenarios.

Protecting CAD Files During Development: The Sunos SCCS System

Protecting CAD files during development: the SunOS SCCS system This is a practical introduction to the Source Code Control System (SCCS) for the development and protection of text-files. Familiar in software projects, it can be a valuable aid for CAD using textual hardware description. A Verilog example illustrates the method, and then the system's most useful features are explained.

Using SCCS to manage APL2 development projects

As workstations become more prevalent and networks expand, APL developers will need source control tools when working together on common programming projects. SCCS (Source Code Control System) is a tool found on UNIX systems used in development projects to control changes made to source code and documentation files. Putting a source file under the control of SCCS creates a single file containing the complete source and history of all modifications with comments. There is a set of SCCS commands to access this file for signing out modules for editing, merging in new changes, providing reports, and even recreating any prior version. Though SCCS is typically used for projects being written in languages like C or Fortran, it can be used in the development of APL2 applications. In trying to use SCCS, there are some problems unique to APL. Specifically, APL's potential to use all 256 ASCII values does cause problems for SCCS. This paper will provide solutions to these problems, and describe how to use SCCS to manage APL2 application development efforts in a networked environment.

Product Administration Through Sable and Nmake

Product administration is a strategic technology for managing software products. AT&T has developed two software systems, SABLE and NMAKE, that support a software product throughout its life cycle and contribute to good software project management. SABLE combines the traditional software administration role of source code control and modification request tracking with support for quality assurance, document generation, interproject communications, security, and software cost analysis. Using software components managed by SABLE, NMAKE controls software product manufacture by automatically maintaining source file interdependencies to build an up-to-date product. With SABLE and NMAKE, developers can also share official versions of code while maintaining private development areas.

The UNIX® timesharing operating system

IIX is a multi-processing and multi-user timesharing operating system. It has become quite popular since its inception in 1969, running on machines of varying processing power from microprocessors to mainframes across different manufacturers' product lines. UNIX provides a great range of programs and services that have made the UNIX system environment popular among users. This environment contains the command interpreter shell, text processing packages, the source code control, a powerful mailing system and many more. The importance of UNIX for manufacturers lies in its philosophy of simplicity and consistency. Since UNIX is written almost totally in a high-level programming language it is very easy to port the system to all kinds of different machines. As a result, by the beginning of 984, there were already about 100 000 UNIX or UNIX-like system installations around the whole world, and the number is still increasing.

A distributed file service based on optimistic concurrency control

The design of a layered file service for the Amoeba Distributed System is discussed, on top of which various applications can easily be intplemented. The bottom layer is formed by the Amoeba Block Services, responsible for implementing stable storage and repficated, highly available disk blocks. The next layer is formed by the Amoeba File Service which provides version management and concurrency control for tree-structured files. On top of this layer, the appficafions, ranging from databases to source code control systems, determine the structure of the file trees and provide an interface to the users.

A source code control system based on semantic nets

AbstractA major problem facing the developers of large pieces of software is source code version control. This paper describes how semantic nets can model this process and how a semantic net processor can be used to construct a flexible and portable source code control system.

Computer-Aided Software Engineering in a distributed workstation environment

Computer-Aided Software Engineering environments are becoming essential for complex software projects, just as CAD systems have become essential for complex hardware projects. DSEE, the DOMAIN Software Engineering Environment, is a distributed, production quality, software development environment that runs on Apollo workstations. DSEE provides source code control, configuration management, release control, advice management, task management, and user-defined dependency tracking with automatic notification. DSEE incorporates some of the best ideas from existing systems. This paper describes DSEE, contrasts it other systems, and discusses some of the technical issues involved in the construction of a highly-reliable, safe, efficient, and distributed development environment.