Search

This commentary on John Symons' and Jack Horner's paper, besides sharing its main argument, challenges the authors' statement that there is no effective method to evaluate software-intensive systems as a distinguishing feature of software intensive science. It is underlined here how analogous methodological limitations characterise the evaluations of empirical systems in non-software intensive sciences. The authors' claim that formal methods establish the correctness of computational models rather than of the represented programme is here compared with the empirical adequacy problem typifying the model-based reasoning approach in physics, and the remark that testing all the paths of a software-intensive system is unfeasible is related to the enumerative induction problem in the justification of empirical law-like hypotheses in non-software intensive sciences. [ABSTRACT FROM AUTHOR]

This paper provides a reply to articles by Nicola Angius and Guiseppe Primiero responding to our paper 'Software Intensive Science' (Symons and Horner, Philosophy and Technology, ). [ABSTRACT FROM AUTHOR]

Modern compilers can be useful, not only in detecting programming errors but also by suggesting several repairs and solutions for those errors using error repair techniques. Error repair refers to the process of finding a repair for an error that happens as a result of compiling a piece of code written by computer programmers. However, a repair is not always consistent with the purpose of programmers. This means a compiler suggests a repair which is different from what the programmer wanted to write. Many compilers fail to suggest the correct repair when programming errors occur as a result of misspelling errors. The aim of this paper is to enhance the error repair process in compilers using spelling correction algorithms. A typical compiler does not provide solutions for the most common syntax programming errors which occur as a result of misspelling. Such errors are easy to detect by compilers but difficult to suggest a fix that is the correct form. Therefore, a novel error correction mechanism which is called CoEdit approach is developed to help compilers to suggest the most suitable repair for programming errors occurred as a result of mistyping errors. Four-Way and Editex algorithms are well known spelling correction algorithms are also extended and employed to be compatible to work with programming languages. CoEdit approach employs these algorithms in order to find repairs to misspelling errors. CoEdit is a generic approach to enhance error repair in any compilers for any language because it targets misspelling compiler errors. This paper concludes that using the Editex algorithm with CoEdit is the best choice in the case of finding repairs to programming errors that occur as a result of spelling errors. [ABSTRACT FROM AUTHOR]

The primes, including the twin primes and the other prime pairs, are the building-blocks of the integers. Euclid's proof of the infinitude of the primes is generally regarded as elegant. It is a proof by contradiction, or, reductio ad absurdum, and it relies on an algorithm which always brings in larger and larger primes, an infinite number of them. However, the proof is also subtle and is misinterpreted by some, with one wellknown mathematician even remarking that the algorithm might not work for extremely large numbers. A long unsettled related problem, the twin primes conjecture, has also aroused the interest of many researchers. The author has been conducting research on the twin primes for a long time and had published a paper on them (see, B. Wong, Possible solutions for the "twin" primes conjecture - The infinity of the twin primes, International Mathematical Journal, 3(8), 2003, 873-886). This informative paper presents some important facts on the twin primes which would be of interest to prime number researchers, with some remarks/reasons that point to the infinitude of the twin primes, including a reasoning which is somewhat similar to Euclid's proof of the infinity of the primes; very importantly, two algorithms are developed in Section 5 for sieving out the twin primes from the infinite list of the integers, which would be of interest to cryptographers and even to computer programmers. [ABSTRACT FROM AUTHOR]

No abstract received. [ABSTRACT FROM AUTHOR]

Android is the most well-known portable working framework having billions of dynamic clients worldwide that pulled in promoters, programmers, and cybercriminals to create malware for different purposes. As of late, wide-running inquiries have been led on malware examination and identification for Android gadgets while Android has likewise actualized different security controls to manage the malware issues, including a User ID (UID) for every application, framework authorizations. In this paper, we advance and assess various kinds of machine learning (ML) by applying ensemble-based learning systems for identifying Android malware related to a substring-based feature selection (SBFS) strategy for the classifiers. In the investigation, we have broadened our previous work where it has been seen that the ensemble-based learning techniques acquire preferred outcome over the recently revealed outcome by directing the DREBIN dataset, and in this manner they give a solid premise to building compelling instruments for Android malware detection. [ABSTRACT FROM AUTHOR]

This paper examines the behavior of job seekers and recruiters in the labor market for software engineers. I obtained data from a recruiting platform where individuals can self-report their computer programming skills and recruiters can message individuals they wish to contact about job opportunities. I augment this data set with measures of each individual's previous programming experience based on analysis of actual computer source code they wrote and shared within the open-source software community. This novel data set reveals that candidates' self-reported technical skills are quantitatively important predictors of recruiter interest. Consistent with social psychology and behavioral economics studies, I also find female programmers with previous experience in a programming language are 11.07% less likely than their male counterparts to self-report knowledge of that programming language on their resume. Despite public pronouncements, however, recruiters do not appear more inclined toward recruiting female candidates who self-report knowing programming languages. Indeed, recruiters are predicted to be 6.47% less likely to express interest in a female candidate than a male candidate with comparable observable qualifications even if those qualifications are very strong. Ultimately, a gender gap in the self-reporting of skills on resumes exists; but recruiters do not appear to be adjusting their response to such signals in ways that could increase the representation of women among software engineering recruits. This paper was accepted by Yan Chen, behavioral economics and decision analysis. [ABSTRACT FROM AUTHOR]

Purpose: In the field of assisted reproductive technology (ART), medical accidents can result in serious legal and social consequences. This study was conducted to develop a security system (called IVF-guardian; IG) that could prevent mismatching or mix-ups in ART. Materials and methods: A software program was developed in collaboration with outside computer programmers. A quick response (QR) code was used to identify the patients, gametes and embryos in a format that was printed on a label. There was a possibility that embryo development could be affected by volatile organic components (VOC) in the printing material and adhesive material in the label paper. Further, LED light was used as the light source to recognize the QR code. Using mouse embryos, the effects of the label paper and LED light were examined. The stability of IG was assessed when applied in clinical practice after developing the system. A total of 104 cycles formed the study group, and 82 cycles (from patients who did not want to use IG because of safety concerns and lack of confidence in the security system) to which IG was not applied comprised the control group. Results: Many of the label paper samples were toxic to mouse embryo development. We selected a particular label paper (P touch label) that did not affect mouse embryo development. The LED lights were non-toxic to the development of the mouse embryos under any experimental conditions. There were no differences in the clinical pregnancy rates between the IG-applied group and the control group (40/104 = 38.5 % and 30/82 = 36.6 %, respectively). Conclusions: The application of IG in clinical practice did not affect human embryo development or clinical outcomes. The use of IG reduces the misspelling of patient names. Using IG, there was a disadvantage in that each treatment step became more complicated, but the medical staff improved and became sufficiently confident in ART to offset this disadvantage. Patients who received treatment using the IG system also went through a somewhat tedious process, but there were no complaints. These patients gained further confidence in the practitioners over the course of treatment. [ABSTRACT FROM AUTHOR]

The paper discusses the need of a high-level query language to allow analysts, geographers and, in general, non-programmers to easily cross-analyze multi-source VGI created by means of apps, crowd-sourced data from social networks and authoritative geo-referenced data, usually represented as JSON data sets (nowadays, the de facto standard for data exported by social networks). Since an easy to use high-level language for querying and manipulating collections of possibly geo-tagged JSON objects is still unavailable, we propose a truly declarative language, named J-CO-QL, that is based on a well-defined execution model. A plug-in for a GIS permits to visualize geo-tagged data sets stored in a NoSQL database such as MongoDB; furthermore, the same plug-in can be used to write and execute J-CO-QL queries on those databases. The paper introduces the language by exemplifying its operators within a real study case, the aim of which is to understand the mobility of people in the neighborhood of Bergamo city. Cross-analysis of data about transportation networks and VGI from travelers is performed, by means of J-CO-QL language, capable to manipulate and transform, combine and join possibly geo-tagged JSON objects, in order to produce new possibly geo-tagged JSON objects satisfying users’ needs. [ABSTRACT FROM AUTHOR]

Leading high performance computing systems achieve their status through use of highly parallel devices such as NVIDIA graphics processing units or Intel Xeon Phi many-core CPUs. The concept of performance portability across such architectures, as well as traditional CPUs, is vital for the application programmer. In this paper we describe targetDP, a lightweight abstraction layer which allows grid-based applications to target data parallel hardware in a platform agnostic manner. We demonstrate the effectiveness of our pragmatic approach by presenting performance results for a complex fluid application (with which the model was co-designed), plus separate lattice quantum chromodynamics particle physics code. For each application, a single source code base is seen to achieve portable performance, as assessed within the context of the Roofline model. TargetDP can be combined with Message Passing Interface (MPI) to allow use on systems containing multiple nodes: we demonstrate this through provision of scaling results on traditional and graphics processing unit-accelerated large scale supercomputers. [ABSTRACT FROM AUTHOR]

Smart pointers play an important role in bypassing memory leaks in C++. Since C++11 standard the smart pointers have become widely-used tools because they let the programmers not to deal with memory deallocation. However, abstraction penalty occurs because of this convenience. Overhead is related to runtime, memory usage and compilation time. There are many different smart pointers in the standard library. However, the performance difference between the smart pointers and raw pointers is not measured before. This paper presents an analysis of their effectiveness. An alternative approach to the C++17's optional construct is searched for. [ABSTRACT FROM AUTHOR]

This paper takes part in the methodological debate concerning the nature and the justification of hypotheses about computational systems in software engineering by providing an epistemological analysis of Software Testing, the practice of observing the programs' executions to examine whether they fulfil software requirements. Property specifications articulating such requirements are shown to involve falsifiable hypotheses about software systems that are evaluated by means of tests which are likely to falsify those hypotheses. Software Reliability metrics, used to measure the growth of probability that given failures will occur at specified times as new executions are observed, is shown to involve a Bayesian confirmation of falsifiable hypotheses on programs. Coverage criteria, used to select those input values with which the system under test is to be launched, are understood as theory-laden principles guiding software tests, here compared to scientific experiments. Redundant computations, fault seeding models and formal methods used in software engineering to evaluate test results are taken to be instantiations of some epistemological strategies used in scientific experiments to distinguish between valid and non-valid experimental outcomes. The final part of the paper explores the problem, advanced in the context of the philosophy of technology, of defining the epistemological status of software engineering by conceiving it as a scientifically attested technology. [ABSTRACT FROM AUTHOR]

Peer assessment mechanism is becoming increasingly important in different computer programming courses to give students opportunities to learn from each other, to improve the learning experience and to reach efficient learning outcomes. Nevertheless, new methodological approaches developed to help students in computer programming courses have had to deal with a thorough study of the aspects related to the gender difference in this context. The paper presents a web-based system, which improved students' program skills by reviewing peers' source codes and delivering feedback to peers. The purpose was to provide evidence that peer assessment in computer programming has a positive instructive effect. Moreover, we want to investigate if there is a gender gap in the traditional introductory programming course and how can we use peer assessment principles to reduce it. [ABSTRACT FROM AUTHOR]

In this paper, the Barcelona basic model (BBM) was implemented in a finite difference-based computer program to simulate the behavior of unsaturated soils subjected to wetting. The BBM implementation was verified using analytical solutions, and the verified model was used to simulate the wetting-induced response of a compacted fill embankment subjected to complete saturation as the worst-case scenario for design. Results showed that considerable amount of total and differential settlements could develop at the top surface of the embankment. Additionally, upper sections of the embankment had a tendency to heave, whereas lower sections under larger confining stresses could collapse due to wetting. Results of a subsequent parametric study indicated that initial moisture content, embankment height, and slope angle have significant influences on the wetting-induced deformations and stability of unsaturated embankments. [ABSTRACT FROM AUTHOR]

This paper provides a comparison between methods used to represent unary, binary and n-ary relations in the relational database (RDB) and object-oriented database (OODB) models and the model proposed in terms of their unambiguity. We have elaborated upon the RDB, OODB and models perceived from the perspective of the categories applied to define them. What has been discussed is a number of solutions assuming the form of schemes for the model. We substantiate that those solutions have unequivocally met the conditions of relations of any chosen arity and multiplicity, at the same time keeping the notation concise, unambiguous and considerably expressive. [ABSTRACT FROM AUTHOR]

Despite the proven success of using computer video games as a context for teaching introductory programming (CS1/2) courses, barriers including the lack of adoptable materials, required background expertise (in graphics/games), and institutional acceptance still prevent interested faculty members from experimenting with this approach. Game-themed programming assignment (GTA) modules are designed specifically for these faculty members. The GTA modules are independent, and each is a self-contained game-like programming assignment that challenges students on concepts pertaining to a specific curriculum topic area. A faculty member can selectively pick and choose a subset of GTA modules to experiment with and gradually adopt the materials in his or her own classes. Each GTA module also includes a step-by-step tutorial guide that supports and encourages interested faculty to develop their own expertise and game-themed materials. This paper begins with a survey of previous results. Based on this survey, the paper summarizes the important considerations when designing materials for selective adoption. The paper then describes the design, implementation, and assessment of the GTA modules. The results from ongoing GTA workshops for CS1/2 faculty members and from a yearlong project in adopting the GTA modules in classes are then presented. In this case, the collected results verified that introductory programming concepts can be examined, practiced, and learned by means of GTA modules when neither the faculty nor the students involved have backgrounds in graphics or games. More importantly, these results demonstrated that it is straightforward to blend the GTA modules into existing classes with minimum alterations. In these ways, the GTA modules are excellent catalysts enabling faculty to begin exploring and developing their own expertise and materials to teach with games. [ABSTRACT FROM AUTHOR]

Modern GPUs open a completely new field to optimize embarrassingly parallel algorithms. Implementing an algorithm on a GPU confronts the programmer with a new set of challenges for program optimization. Especially tuning the program for the GPU memory hierarchy whose organization and performance implications are radically different from those of general purpose CPUs; and optimizing programs at the instruction-level for the GPU. In this paper we analyze different approaches for optimizing the memory usage and access patterns for GPUs and propose a class of memory layout optimizations that can take full advantage of the unique memory hierarchy of NVIDIA CUDA. Furthermore, we analyze some classical optimization techniques and how they effect the performance on a GPU. We used the Gravit gravity simulator to demonstrate these optimizations. The final optimized GPU version achieves a 87 x speedup compared to the original CPU version. Almost 30% of this speedup are direct results of the optimizations discussed in this paper. [ABSTRACT FROM AUTHOR]

This paper examines how a team of software professionals goes about estimating the effort of a software project using a judgment-based, bottom-up estimation approach. By employing a social practice perspective that highlights the distributed character of expertise and conceives actions as mediated by cultural tools, the paper analyzes the interaction al process through which the estimation tasks were collectively accomplished. The findings show how software effort estimation is carried out through complex series of explorative and sense-making actions, rather than by applying assumed information or routines. During the explorative work, the team alternated between the planning and the problem solving aspects of the activity. The requirement specification served several mediating functions in the interactional process, through which expertise was mobilised and coordinated. The paper argues that to grasp the complexity of software estimation, there is a need for more research that accounts for the communicative and interactional dimensions of this activity. Moreover, by revealing the interactional details of a planning activity the paper contributes to our understanding of the future-oriented and constructive dimensions of social practices. [ABSTRACT FROM AUTHOR]

Competition from open source software and free software (OSS/FS) alternatives is causing proprietary software producers to reevaluate product strategies. OSS/FS alternatives complicate an already complex information goods market plagued by piracy concerns. Although producer perspectives on software pricing and piracy controls have been addressed extensively, consumers' perspective and willingness to pay for commercial software is not very well understood. This paper empirically determines willingness to pay for a leading commercial software application (Microsoft Office) in the presence of an OSS/FS alternative. A contingent valuation approach is used to elicit willingness to pay for the application. The research design employs a 2 × 2 × 2 experiment to investigate the impact of preventive control, deterrence control, and OSS/FS alternative. The results indicate that the availability of an OSS/FS alternative has little impact on willingness to pay for Microsoft Office. However, piracy controls significantly increase willingness to pay for Microsoft Office, even in the presence of OSS/FS alternatives. [ABSTRACT FROM AUTHOR]

The article focuses on the computer industry. It offers a history of Computer Science and software engineering which concentrates on virtual reality and related areas. The author shares the realization and the idea of abstraction that computer programming is not an easy job. The author relates his experience with Computer Science and software engineering during his undergraduate project at the University of Limerick on the subject of software development where the book changed the direction of his career for both its technical content and for sentimental reasons.

For real-time video encoder, low-complexity video encoding algorithms are required in many applications. This paper provides an early termination scheme to make the conventional binary block motion estimation algorithm significantly faster. The difference between the intensity of original frame and its filtered version is used as an input to something in this paper. With video codec, the proposed scheme shows improved visual quality while reducing complexity. Experimental results are provided to compare the performance of the proposed scheme with the conventional algorithms. [ABSTRACT FROM AUTHOR]

Teaching programming to novices has proved challenging for both learner and lecturer due to the abstraction and complexity of the subject matter. The work described in this paper is part of an EU funded Minerva project called TUPULO (Teaching Undergraduate Programming Using Learning Objects) which aims to address the challenges faced by novice programmers by providing them with an innovative learning tool. This learning tool that is currently under development and rollout incorporates a set of Reusable Learning Objects (RLOs) based on sound pedagogical principles and encapsulated in a Constructivist Learning Environment (CLE), which includes a meta-cognitive interface. The subject matter experts and instructional designers in the local academic partner institutions designed these learning objects. The outputs and findings of the TUPULO project will not only benefit learners in the partner institutions involved, but by being disseminated to the wider educational community, they will also help learners in the domain on a broader scale. This paper describes the preparatory work undertaken in order to establish a set of potential LOs for development based on the student's main areas of weakness. When attempting to build learning objects for use in any domain the primary consideration should always be the needs and abilities of the learners. This paper describes the work done by the authors in conducting a user needs analysis in order to establish the key problem areas facing learners of introductory programming. A methodology for user needs capture and analysis was produced based on the set of user groups available at the Institutions and the needs of the users were captured and analysed. The methodology was devised to incorporate both quantitative and qualitative analysis of the information available to us regarding students. Exam scripts and corresponding results together with focus group discussions were used in order to ascertain perceptions regarding the course content, delivery, level of difficulty and areas of difficulty in programming. Additional institutional information such as students' leaving certificate points and Maths grade together with students' overall performance in other subject areas were used to investigate possible correlations. The analysis of this data provided some preliminary information on the ways in which students interpret various questions and their conceptual difficulties in understanding certain topics. This analysis leads to the final selection of programming topics for potential development as reusable learning objects. [ABSTRACT FROM AUTHOR]

Expert programmers possess schemas, abstractions of concrete experiences, which help them solve programming problems and lessen the load on their working memory during problem solving. Possession of schemas is a key difference between novices and experts, which is why instructors need to help students construct them. One recent tool for facilitating schema formation in introductory programming are roles of variables, which represent stereotypes of variable use in computer programs (Sajaniemi, 2002). For instance, a variable with the role STEPPER is assigned values in a systematic and predictable order (e.g. ascending integers 0, 1, 2, ...), whereas a FIXED VALUE is a variable whose value does not change. Roles of variables embody expert programmers' tacit knowledge on variable usage patterns, which can be made explicit and taught to novice programmers. A small set of roles covers the vast majority of variable use in introductorylevel programs. Prior results obtained through analysis of examination results and observation of students suggest that using roles of variables in introductory programming education can increase students' skills in comprehending and constructing programs (Byckling & Sajaniemi, 2006; Sajaniemi & Kuittinen, 2005). Little has been published about the experiences of teachers in higher education who have adopted roles in their programming courses, or about the methods of instruction that can be used to introduce roles. The main research questions in this paper are: how can instructors benefit from roles of variables while creating and maintaining their teaching materials, and what kind of influence does roles-based instruction have on teaching and learning in general? In this paper, we present the experiences of two programming teachers, who have adopted roles of variables into their courses. In one of the two courses, a very casual 'lightweight' approach to introducing roles of variables to students was used. In the other course, somewhat more effort was spent on introducing roles to students. We discuss the changes made to our courses, describe the effects that the process had on our teaching methods and materials, and suggest new ideas on how to make use of roles of variables in pedagogy. Using feedback questionnaires and analyses of examination answers, we also explore what impact roles of variables had on our students. From a teachers' point of view, we found roles of variables to be very useful. Roles are concrete and easily linked to code. They help with teaching stepwise refinement of program designs, and can be taught in introductory courses naturally alongside other variable-related concepts, such as type and scope. Roles provided us with new ways to assess and improve our teaching materials and methods. Our assessment of the impact of roles of variables on CS1 students is in agreement with earlier findings and suggests that roles-based instruction can improve students' programming knowledge, perhaps especially with program comprehension tasks. Not all students involved in our experiment found roles useful for learning programming, however, and our results indicate that more than a lightweight introduction to roles is needed in order for students to adopt them into active use. We conclude that roles of variables are a very promising pedagogical tool for introductory programming teachers. [ABSTRACT FROM PUBLISHER]

An increasing body of research relies on genre to analyze academic and professional communication and to describe how members of a community use language. The purpose of this paper is to provide a review of genre-based research in technical communication and to describe the different approaches to genre and to genre teaching. While some research focuses on the textual analysis of genres, other studies focus on the analysis of the social context and the ideology and structure of the discourse community that owns the genre, and on the role of genres as social rhetorical actions of the community. These two perspectives are also reflected in the teaching of genre in technical communication. [ABSTRACT FROM AUTHOR]

During the past several years, there has been a growing demand for skilled software engineers, a demand that, unfortunately, has not been satisfied, resulting in a variety of problems for the discipline. This paper presents a new approach called learner-centered Web-based instruction in software engineering that can be used to educate skilled engineers. The approach is based on three ideas. First, software engineering education must become more realistic. Second, software engineering education has to move closer to the learner. Finally, it must take advantage of the Web since this technology has the power of being a unique tool for implementing change in education. This paper reports and discusses the results from the evaluation of the approach. [ABSTRACT FROM AUTHOR]

In this paper, we examine how the motivations and attitudes of open source software (OSS) developers affect their preference among the three common OSS license types--Strong-Copyleft, Weak-Copyleft, and Non-Copyleft. Despite the importance of the license type and developers to OSS projects, there is little understanding in open source literature of the license choice from a developer's perspective. The results from our empirical study of OSS developers reveal that the intrinsic motivation of challenge (problem solving) is associated with the developers' preference for licenses with moderate restrictions, while the extrinsic motivation of status (through peer recognition) is associated with developers' preference for licenses with least restrictions. We also find that when choosing an OSS license, a developer's attitude toward the software redistribution rights conflicts with his or her attitude toward preserving the social benefits of open source. A major implication of our findings is that OSS managers who want to attract a limited number of highly skilled programmers to their open source project should choose a restrictive OSS license. Similarly, managers of software projects for social programs could attract more developers by choosing a restrictive OSS license. [ABSTRACT FROM AUTHOR]

Various interventions to attract girls into computing careers have been instigated around the world in recent years. There have also been many efforts to understand factors influencing girls' career choices, and several career choice models have been developed. This pilot study investigated the career preferences of teenage girls who participated in a New Zealand-based intervention: the Programming Challenge 4 Girls. Results revealed three sociability needs as the girls' primary factors influencing career choice. The girls wanted a career that will allow them to engage socially, with a sense of fun, and in a 'cool' environment. The study also investigated sources of information about programming careers. Most girls did not know where to seek programming career information and their parents and career advisors were found to need more knowledge about IT careers. A government careers website was unsatisfactory with respect to teenage girls' preferences, whereas an industry-based programme partially addressed girls' needs. The paper distinguishes between formal and informal sources of programming career information and proposes a modification to a widely-cited model of girls' career choices. [ABSTRACT FROM AUTHOR]

It is almost universally accepted that traditional provider-patient relationships should be governed, at least in part, by the ethical principles set forth by Beauchamp and Childress (Beauchamp and Childress, Principles of biomedical ethics, 1979). These principles include autonomy, beneficence, non-maleficence and justice (Beauchamp and Childress, Principles of biomedical ethics, 1979). Recently, however, the nature of medial practice has changed. The pervasive presence of computer technology in medicine raises interesting ethical questions. In this paper we argue that some software designers should be considered health care providers and thus be subject the ethical principles incumbent upon "traditional" providers. We argue that these ethical responsibilities should be applied explicitly rather than as a passive, implicit, set of guidelines. [ABSTRACT FROM AUTHOR]

Our current understanding of how programmers perform feature location during software maintenance is based on controlled studies or interviews, which are inherently limited in size, scope and realism. Replicating controlled studies in the field can both explore the findings of these studies in wider contexts and study new factors that have not been previously encountered in the laboratory setting. In this paper, we report on a field study about how software developers perform feature location within source code during their daily development activities. Our study is based on two complementary field data sets: one that reflects complete IDE activity of 67 professional developers over approximately one month, and the other that reflects usage of an IR-based code search tool by nearly 600 developers. Analyzing this data, we report results on how often developers use which type of code search tools, on the types of queries and retreival strategies used by developers, and on patterns of developer feature location behavior following code search. The results of the study suggest that there is (1) a need for helping developers to devise better code search queries; (2) a lack of adoption of niche code search tools; (3) a need for code search tool to handle both lookup and exploratory queries; and (4) a need for better integration between code search, structured navigation, and debugging tools in feature location tasks. [ABSTRACT FROM AUTHOR]

Although there have been many advances in end-user programming environments, recent empirical studies report that programming still remains difficult for end-users. We hypothesize that one reason may be lack of effective support for helping end-user programmers problem-solve their own way around barriers they encounter. Therefore, in this paper, we describe the Idea Garden, a concept designed to help end-user programmers generate new ideas and problem-solve when they run into barriers. The Idea Garden has its roots in Minimalist Learning Theory and problem-solving theories. Our proof-of-concept prototype of the Idea Garden concept in the CoScripter end-user programming environment currently targets three barriers reported in end-user programming literature. It does so using an integrated, just-in-time combination of scaffolding for problem-solving strategies, for design patterns and for programming concepts. Our empirical results showed that this approach helped end-user programmers overcome all three types of barriers that our prototype targeted. [ABSTRACT FROM AUTHOR]

The art of programming is taught, learned, and often practiced as if programs are disposable, personal objects owned solely by the programmer. This paper uses examples to illustrate why real software is neither personal nor disposable; it shows how even simple programs are shared by others. From the examples, the paper extracts four principles for program development. Finally, it thaws conclusions about programming practices and the education of programmers. [ABSTRACT FROM AUTHOR]

Design scripting is initially based on secondary syntactic mechanisms that control sequential executions of code. This model of computation, called control flow programming, was introduced to designers as the only way of creating algorithms. Dataflow represents a widespread alternative to control flow by utilizing concurrent streams of data. Dataflow programming languages are also considered to be pedagogical tools in fields where the coders are not expert computer programmers. In the last decade, new parametric modeling tools introduced this conception to design scripting, shifting its practical and educational foundations. Dataflow programming represents a promising platform for studying contemporary parametric modeling techniques in design, while architects and designers increasingly use it as their algorithmic sketchbooks. This paper describes a purpose to reflect this shift in design education, pursuing four pedagogical patterns derived from in-class experiments: 'explication', 'kit of components', 'objectification', and 're-generation'. [ABSTRACT FROM AUTHOR]

The paper presents a new method of lifetime calculations of steam turbine components operating at high temperatures. Component life is assessed on the basis of creep-fatigue damage calculated using long-term operating data covering the whole operating period instead of representative events only. The data are analysed automatically by a dedicated computer program developed to handle big amount of process data. Lifetime calculations are based on temperature and stress analyses performed by means of finite element method and using automatically generated input files with thermal and mechanical boundary conditions. The advanced lifetime assessment method is illustrated by an example of lifetime calculations of a steam turbine rotor. [ABSTRACT FROM AUTHOR]

This paper argues that the difference between contemporary software intensive scientific practice and more traditional non-software intensive varieties results from the characteristically high conditionality of software. We explain why the path complexity of programs with high conditionality imposes limits on standard error correction techniques and why this matters. While it is possible, in general, to characterize the error distribution in inquiry that does not involve high conditionality, we cannot characterize the error distribution in inquiry that depends on software. Software intensive science presents distinctive error and uncertainty modalities that pose new challenges for the epistemology of science. [ABSTRACT FROM AUTHOR]

We present the methodological principles underlying the scientific activities of the DHST Commission on the History and Philosophy of Computing. This volume collects refereed selected papers from the First International Conference organized by the Commission. [ABSTRACT FROM AUTHOR]

Background: The clinical SAS (www.sas.com) programming industry, in India, has seen a rapid growth in the last decade and the trend seems set to continue, for the next couple of years, due to cost advantage and the availability of skilled labor. On one side the industry needs are focused on less execution time, high margins, segmented tasks and the delivery of high quality output with minimal oversight. On the other side, due to the increased demand for skilled resources, the wants of the programmers have taken a different shift toward diversifying exposure, unsustainable wage inflation due to multiple opportunities and generally high expectations around career progression. If the industry needs are not going to match with programmers want, or vice versa, then there is the possibility that the current year on year growth may start to slow or even go into decline. Aim: This paper is intended to identify the gap between wants and need and puts forwards some suggestions, for both sides, in ways to change the equation to benefit all. Settings and Design: Questionnaire on similar themes created to survey managers and programmers working in clinical SAS programming industry and was surveyed online to collect their perspectives. Their views are compared for each theme and presented as results. Materials and Methods: Two surveys were created in www.surveymonkey.com. Management: https://www.surveymonkey.com/s/SAS_India_managment_needvswant_survey. Programmer: https://www.surveymonkey.com/s/SAS_India_programmer_needvswant_survey. Statistical Analysis Used: Bar chart and pie chart used on data collect to show segmentation of data. Results and Conclusions: In conclusion, it seeks to highlight the future industry direction and the skillset that existing programmers need to have, in order to sustain the momentum and remain competitive, to contribute to the future pipeline and the development of the profession in India. [ABSTRACT FROM AUTHOR]

Modern machines consist of multiple compute devices and complex memory hierarchies. For many applications, it is imperative that any data movement between and within the various compute devices be done as efficiently as possible in order to obtain maximum performance. However, hand-optimizing code for one architecture will likely sacrifice both performance portability and software maintainability. In addition, some optimization decisions are best made at runtime. This suggests that the problem ought to be tackled on two fronts. First, provide the programmer with a declarative language to describe data layouts and data motion. This would allow the runtime system to be tuned for each architecture by a specialist and free the programmer to concentrate on the application itself. Second, exploit the execution time information to optimize the data movement code further. MPI derived datatypes accomplish the former task and Just In Time (JIT) compilation can be used for the latter. In this paper, we present DAME—a language and interpreter designed to be used as the backend for MPI derived datatypes. We also present DAME-L and DAME-X, two JIT-enabled implementations of DAME, all of which have been integrated into MPICH. We evaluate their performance on DDTBench and two mini-applications written with MPI derived datatypes and obtain communication speedups of up to 20× and mini-application speedups of up to 3×. [ABSTRACT FROM AUTHOR]

Data provenance is the history of an item of data from the point of its creation to its present state. It can support science by improving understanding of and confidence in data. RDataTracker is an R package that collects data provenance from R scripts (https://github.com/End-to-end-provenance/RDataTracker). In addition to details on inputs, outputs, and the computing environment collected by most provenance tools, RDataTracker also records a detailed execution trace and intermediate data values. It does this using R's powerful introspection functions and by parsing R statements prior to sending them to the interpreter so it knows what provenance to collect. The provenance is stored in a specialized graph structure called a Data Derivation Graph, which makes it possible to determine exactly how an output value is computed or how an input value is used. In this paper, we provide details about the provenance RDataTracker collects and the mechanisms used to collect it. We also speculate about how this rich source of information could be used by other tools to help an R programmer gain a deeper understanding of the software used and to support reproducibility. [ABSTRACT FROM AUTHOR]

Developing mobile applications remains difficult, time consuming, and error prone, in spite of the number of existing platforms and tools. In this paper, we develop MoDroid, a high-level modeling language to ease the development of Android applications. MoDroid allows developing models representing the core of applications. MoDroid provides Android programmers with the following advantages: (1) models are built using high-level primitives that abstract away several implementation details; (2) it allows the definition of interfaces between models to automatically compose them; (3) a native Android application can be automatically generated along with the required permissions definition; (4) it supports efficient testing execution that operates on models. MoDroid is fully implemented and was used to develop several non-trivial Android applications. [ABSTRACT FROM AUTHOR]

Tuning the kernel work-group size for GPUs is a challenging problem. In this paper, using the performance counters provided by GPUs, we characterize a large body of OpenCL kernels to identify the performance factors that affect the choice of a good work-group size. Based on the characterization, we realize that the most influential performance factors with regard to the work-group size include occupancy, coalesced global memory accesses, cache contention, and variation in the amount of workload in the kernel. By tackling the performance factors one by one, we propose auto-tuning techniques that selects the best work-group size and shape for GPU kernels. We show the effectiveness of our auto-tuner by evaluating it with a set of 54 OpenCL kernels on three different NVIDIA GPUs and one AMD GPU. On average, the auto-tuner needs to spend no more than 8 percent of the time required by an exhaustive search to find an optimal work-group size. The execution time of the selected sub-optimal work-group size is at most 1.14x slower than that of the optimal work-group size found by the exhaustive search, on average. [ABSTRACT FROM AUTHOR]

Programming is one of the career rewarding skills; however, learning programming skill is extremely hard and arduous as supported by several studies. The first programming language has an everlasting impact on the programmer's program's development abilities. In most of the universities the imperative paradigm is used for introductory programming courses and generally C language is used as a base language of a first programming course. The C language is a leading programming language and extensively utilized for commercial applications. The majority of the programming languages are highly motivated from the C language, yet its intrinsic complexities and non-pedagogic origin evidently makes it hard and a complex choice for a first programming course. This paper proposed a rational and realizable solution that can make a C language a suitable choice for a first the course of programming. [ABSTRACT FROM AUTHOR]

For the past four decades, the traditional relational databases have been in use in Information Technology industry. There was a phenomenal conversion in the IT industry in terms of commercial applications in the previous years. The applications that were running on a Single server in organizations IT infrastructure have been replaced or migrated with eapps. Also, the dedicated storages are replaced with system storages. The model of pay per use, flexibility and lesser cost are the main reasons, which caused the distributed computing pick up into reality. Cloud databases, Simple DB, and Amazon RDS are getting to be more familiar to communities because they have brought up and highlighted the issues and problems of current social databases in terms of usability, flexibility, and provisioning. Basically now, the cloud databases are at present considered as a solution for programmers, designers, and architects since they need to store the information of their applications in an adaptable and exceptionally accessible from backend when required. These Database-as-a- Service (DBaaS) administrations are cloud-based information stockpiling administrations can be arranged into two principle classifications: benefits that backing conventional social databases (RDB) (e.g., Amazon RDS, Google SQL, Microsoft Azure), and key/quality pair information stockpiling administrations (e.g., Amazon Simple DB, Google Data Store), which are otherwise called NoSQL Databases [Harrison John Bhatti and Babak Bashari Rad 2017]. In this paper, we are going to analyze and perform one such On-Premises to AWS RDS To support, Cloud migration which helps the users on performance, cost, and scalability [ABSTRACT FROM AUTHOR]

Implementation of an emulator of MIX, a mythical computer invented by Donald Knuth, is used as a case study of the features of the Scala programming language. The developed emulator provides rich opportunities for program debugging, such as tracking intermediate steps of program execution, an opportunity to run a program in the binary or the decimal mode of MIX, verification of correct synchronisation of input/output operations. Such Scala features as cross-compilation, family polymorphism and support for immutable data structures have proved to be useful for implementation of the emulator. The authors of the paper also propose some improvements to these features: flexible definition of family-polymorphic types, integration of family polymorphism with generics, establishing full equivalence between mutating operations on mutable data types and copy-and-modify operations on immutable data types. The emulator is free and open source software available at www.mix-emulator.org. [ABSTRACT FROM AUTHOR]

Recently, methodologies for developing brain-computer interface (BCI) games using the BCI have been actively researched. The existing general framework for processing brain waves does not provide the functions required to develop BCI games. Thus, developing BCI games is difficult and requires a large amount of time. Effective BCI game development requires a BCI game framework. Therefore the BCI game framework should provide the functions to generate discrete values, events, and converted waves considering the difference between the brain waves of users and the BCIs of those. In this paper, BCI game frameworks for processing brain waves for BCI games are proposed. A variety of processes for converting brain waves to apply the measured brain waves to the games are also proposed. In an experiment the frameworks proposed were applied to a BCI game for visual perception training. Furthermore, it was verified that the time required for BCI game development was reduced when the framework proposed in the experiment was applied [ABSTRACT FROM AUTHOR]

Uncertainty and dynamism surrounding pervasive systems require new and sophisticated approaches to defining, detecting, and handling complex exceptions. This is because the possible erroneous conditions in pervasive systems are more complicated than conditions found in traditional applications. We devised a novel exception description and detection mechanism based on "situation"- a novel extension of context, which allows programmers to devise their own handling routines targeting sophisticated exceptions. This paper introduces the syntax of a language support that empowers the expressiveness of exceptions and their handlers, and suggests an implementation algorithm with a straw man analysis of overhead [ABSTRACT FROM AUTHOR]

In loops, some arrays are referenced with induction variables. To parallelize such kind of loops, those induction variables should be substituted. Thus, those array references that were substituted are formulated as nonlinear expressions. The goal of data alignment is to intelligently map the computations and data onto a set of virtual processors which are organized as a Cartesian grid (or a template in HPF terms), and to provide data locality for parallelizing compilers so that data access communication costs can be minimized. Most data alignment methods are mainly devised to align the referenced arrays using linear subscripts or quadratic subscripts with n loop index variables, and the methods are well developed. Seldom work, however, is researched on the nonlinear expressions of index variables. This paper proposes a new communication-free data alignment technique to align the referenced arrays using exponential subscripts with n loop index variables or other complex nonlinear expressions. The experimental results using SPEC95FP Benchmarks point out that the techniques proposed in the paper can improve the execution time of the subroutines in these benchmarks. [ABSTRACT FROM AUTHOR]

Programmers productivity has always been overlooked as compared to the performance optimizations in high performance computing (HPC) community. In many parallel programming languages like MPI/MPI-IO, the performance optimizations are provided as various function options to the programmers. In order to write an efficient code, they are required to know the exact usage of the optimization functions, hence programmer productivity is limited. In this paper, we present RFSA, a Reduced Function Set Abstraction based on an existing parallel programming interface (MPI-IO) for I/O. The purpose of RFSA is to hide the performance optimization functions from the application developer, and relieve the application developer from deciding on a specific function. The proposed set of functions rely on a selection algorithm to decide among the most common optimizations provided by MPI-IO. We implement a selection algorithm for I/O functions like read, write, etc., and also merge a set of functions for data types and file views. By running different parallel I/O benchmarks on both medium-scale clusters and NERSC supercomputers, we show an improved programmer productivity (35.7% on average). This approach incurs an overhead of 2-5% for one particular optimization, and shows performance improvement of 17% when a combination of different optimizations is required by an application. [ABSTRACT FROM AUTHOR]

Automated assessment systems can be useful for both students and instructors. Ranking and immediate feedback can have a strongly positive effect on student learning. This paper presents an experience using automatic assessment in a programming tools course. The proposal aims at extending the traditional use of an online judging system with a series of assignments related to programming tools. Some empirical results on how students use an automated assessment system in a CS2 course are presented. Research suggested that automated assessment systems promoted the students' interest and produced statistically significant differences in the scores between experimental and control groups. [ABSTRACT FROM AUTHOR]

Software fault localization techniques typically rank program components, such as statements or predicates, in descending order of their suspiciousness (likelihood of being faulty). During debugging, programmers may examine these components, starting from the top of the ranking, in order to locate faults. However, the assigned suspiciousness to each component may not always be unique, and thus some of them may be tied for the same position in the ranking. In such a scenario, the total number of components that a programmer needs to examine in order to find the faults may vary considerably. The greater the variability, the harder it is for a programmer to decide which component to examine first, and the harder it is to accurately compute the expected effectiveness of a fault localization technique. In this paper, we first conduct a case study, based on three fault localization techniques across four sets of programs, which reveals that the phenomenon of assigning the same suspiciousness to multiple components is not limited to any technique or program in particular. Thus, to reduce variability and alleviate this problem, four tie-breaking strategies are discussed and evaluated empirically in our second case study. Results indicate that the strategies can not only reduce the number of ties in the rankings, but also maintain the effectiveness of the fault localization techniques. We also propose a new metric for evaluating fault localization techniques called CScore, which takes the notion of ties into account. Finally, an additional slicing-based approach to breaking ties is discussed briefly, which aims to provide further insights into tie-breaking and stimulate further research in the area. [ABSTRACT FROM AUTHOR]

In this paper, we take a concrete step towards materializing our long-term goal of providing a fully automatic end-to-end tuning infrastructure for arbitrary program components and full applications. We describe a general-purpose offline auto-tuning framework and apply it to an application benchmark, SMG2000, a semi-coarsening multigrid on structured grids. We show that the proposed system first extracts computationally intensive loop nests into separate executable functions, a code transformation called outlining. The outlined loop nests are then tuned by the framework and subsequently integrated back into the application. Each loop nest is optimized through a series of composable code transformations, with the transformations parameterized by unbound optimization parameters that are bound during the tuning process. The values for these parameters are selected using a search-based auto-tuner, which performs a parallel heuristic search for the best-performing optimized variants of the outlined loop nests. We show that our system pinpoints a code variant that performs 2.37 times faster than the original loop nest. When the full application is run using the code variant found by the system, the application’s performance improves by 27%. [ABSTRACT FROM AUTHOR]