Search

This article introduces the articles in volume 31, number 3 of the "International Journal of Parallel Programming". The volume is devoted to a collection of papers on the parallel programming API OpenMP. The papers have been selected from the presentations at the second International Workshop on OpenMP: Experiences and Implementations WOMPEI2002, as part of ISHPC-IV International Symposium on High-Performance Computing, that took place in Kansai Science City in Japan. This collection includes 4 papers from some of the active research groups in OpenMP-related issues and its evaluation. It is the author's hope that the papers in the collection will prove to be interesting and useful to readers, and that the issues raised will stimulate many of them to further research on OpenMP.

This article introduces the themes of the papers featured in the April 2000 special issue of the "International Journal of Parallel Programming." The first paper describes a loop transformation algorithm. The second paper proposes a new way to develop concurrent programs, called hypersequential programming. The third paper introduces a workstation cluster implementing a distributed shared-memory mechanism. Lastly, the fourth paper discusses issues of multilevel parallelization and how they affect design of parallelizing compilers.

Just when modern computers (digital, electronic, and programmable) were being invented, John von Neumann and Herman Goldstine wrote a paper to illustrate the mathematical analyses that they believed would be needed to use the new machines effectively and to guide the development of still faster computers. Their foresight and the congruence of historical events made their work the first modern paper in numerical analysis. Von Neumann once remarked that to found a mathematical theory one had to prove the first theorem, which he and Goldstine did for the accuracy of mechanized Gaussian elimination--but their paper was about more than that. Von Neumann and Goldstine described what they surmised would be the significant questions once computers became available for computational science, and they suggested enduring ways to answer them. [ABSTRACT FROM AUTHOR]

Computer Science and programming courses are generally considered to be difficult, particularly for students in the first year of a third-level course. As such, it is an important role to support these students as they begin their education in order to better cement their learning, and to reduce drop-out rates and other early issues. In Ireland, many third-level institutions offer additional dedicated supports to their Computer Science and programming students to augment the traditional lectures, tutorials, and laboratory sessions. This paper provides a review of the current state of Computer Science Support in Ireland. It features case studies from a sample of six third-level institutions, with authors from each institution detailing the support services they offer to their students. A survey was also sent to all third-level institutions in Ireland, asking for feedback about their support services (or lack thereof). Fifteen responses were received from institutions who provide additional supports (no responses were received from institutions without). From the results of this survey, and the authors' personal perspectives and experience, recommendations will be made for those looking to develop their own support services, or to improve upon existing ones. Some of the key findings from this survey are that most supports in Ireland come in the form of dedicated tutors or support centres, more support is offered on average earlier in undergraduate degrees and that most respondents agree that we need to support novice programmers. Some of the recommendations include all institutions offering some form of support service, offering it as a free service and ensuring all ability levels are catered for. Advertising the service appropriately is also important. It is the correct time to undertake such a review due to the continued growth of Computer Science as a subject, not only at third level, but now also at second level with the introduction of Computer Science to the Leaving Certificate options. Further work is ongoing in this area, with both a national group setup and an annual workshop planned to enter its second iteration in 2022. [ABSTRACT FROM AUTHOR]

The article presents abstracts on engineering and computer science research presented during the 86th Annual Academy of Science Meeting at the University of West Alabama in Livingston from March 25-27, 2009 including one on the Jibu software library for concurrent programming, another on the kinematic structure of the bow echo observed on March 9, 2006 between Alabama and Mississippi, and one on a semantics-based method for extracting concepts from large documents.

Computer science (CS) is becoming an increasingly diverse domain. This paper reports on an initiative designed to introduce underrepresented populations to computing using an eclectic, multifaceted approach. As part of a yearlong computing course, students engage in Maker activities, participatory simulations, and computing projects that foreground the social and collaborative aspects of CS. Collectively, these activities are designed to introduce learners to the growing diversity of what CS looks like in the 21st century. This paper lays out the practical and theoretical motivations for the Computational Thinking for Girls (CT4G) project, specifically highlighting the use of Making through physical and social computing as ways to engage students in CS. A snapshot of one activity from the program is provided—Wearing the Web—in which students use open-hardware programmable badges to explore the underlying structure and technology that enables the Internet. Data from the first year of the CT4G program are presented to show the positive effects that this diverse introduction to CS is having on the students with respect to their attitudes toward CS. [ABSTRACT FROM PUBLISHER]

Engagement and retention are widely acknowledged problems in computer science and more general higher education. The need to develop programming skills is increasingly ubiquitous, but especially so in computer science where it is one of the core competencies. Learning to write code is a particularly challenging skill to master, which can make retention and success even more difficult. We attempt to address student engagement within an introductory programming module by attempting to motivate students using a gamified interactive programming tutor application that provides immediate feedback on the student's work. In this paper, we describe the design of the gamified programming tutor application, along with a related topology to characterize student engagement. We discuss the design of the software, the gamified elements, and the structured question design. We evaluate the engagement with the gamified programming tutor of two cohorts of students in the first year of a computer science programme, with over two hundred students taking part. We attempt to frame this engagement in terms of frequency, duration, and intensity of interactions, and compare these engagement metrics with module performance. Additionally, we present quantitative and qualitative data from a survey of students about their experience using the programming tutor application to demonstrate the efficacy of this approach. [ABSTRACT FROM AUTHOR]

Computational Social Science emerged as a highly technical and popular discipline in the last few years, owing to the substantial advances in communication technology and daily production of vast quantities of personal data. As per capita data production significantly increased in the last decade, both in terms of its size (bytes) as well as its detail (heartrate monitors, internet-connected appliances, smartphones), social scientists' ability to extract meaningful social, political and demographic information from digital data also increased. A vast methodological gap exists in 'computational international relations', which refers to the use of one or a combination of tools such as data mining, natural language processing, automated text analysis, web scraping, geospatial analysis and machine learning to provide larger and better organized data to test more advanced theories of IR. After providing an overview of the potentials of computational IR and how an IR scholar can establish technical proficiency in computer science (such as starting with Python, R, QGis, ArcGis or Github), this paper will focus on some of the author's works in providing an idea for IR students on how to think about computational IR. The paper argues that computational methods transcend the methodological schism between qualitative and quantitative approaches and form a solid foundation in building truly multi-method research design. [ABSTRACT FROM AUTHOR]

Traditional quantitative research methods of data collection in programming, such as questionnaires and interviews, are the most common approaches for researchers in this field. However, in recent years, eye-tracking has been on the rise as a new method of collecting evidence of visual attention and the cognitive process of programmers. Eye-tracking has been used by researchers in the field of programming to analyze and understand a variety of tasks such as comprehension and debugging. In this article, we will focus on reporting how experiments that used eye-trackers in programming research are conducted, and the information that can be collected from these experiments. In this mapping study, we identify and report on 63 studies, published between 1990 and June 2017, collected and gathered via manual search on digital libraries and databases related to computer science and computer engineering. Among the five main areas of research interest are program comprehension and debugging, which received an increased interest in recent years, non-code comprehension, collaborative programming, and requirements traceability research, which had the fewest number of publications due to possible limitations of the eye-tracking technology in this type of experiments. We find that most of the participants in these studies were students and faculty members from institutions of higher learning, and while they performed programming tasks on a range of programming languages and programming representations, we find Java language and Unified Modeling Language (UML) representation to be the most used materials. We also report on a range of eye-trackers and attention tracking tools that have been utilized, and find Tobii eye-trackers to be the most used devices by researchers. [ABSTRACT FROM AUTHOR]

Given a distributed computation and a global predicate, predicate detection involves determining whether there exists at least one consistent cut (or global state) of the computation that satisfies the predicate. On the other hand, computation slicing is concerned with computing the smallest subcomputation (with the least number of consistent cuts) that contains all consistent cuts of the computation satisfying the predicate. In this paper, we investigate the relationship between predicate detection and computation slicing and show that the two problems are actually equivalent. Specifically, given an algorithm to detect a predicate b in a computation C, we derive an algorithm to compute the slice of C with respect to b. The time complexity of the (derived) slicing algorithm is O(n∣E∣T), where n is the number of processes, E is the set of events, and O(T) is the time complexity of the detection algorithm. We discuss how the "equivalence" result of this paper can be utilized to derive a faster algorithm for solving the genera/predicate detection problem in many cases. Slicing algorithms described in our earlier papers are all offline in nature. In this paper, we also present two online algorithms for computing the slice. The first algorithm can be used to compute the slice for a general predicate. Its amortized time complexity is O(n(c+n)T) per event, where c is the average concurrency in the computation and O(T) is the time complexity of the detection algorithm. The second algorithm can be used to compute the slice for a regular predicate. Its amortized time complexity is only O(n2) per event. [ABSTRACT FROM AUTHOR]

Version control systems' usage is a highly demanded skill in information and communication technology professionals. Thus, their usage should be encouraged by educational institutions. This work demonstrates that it is possible to assess if a student can pass a computer science-related subject by monitoring its interaction with a version control system. This paper proposes a methodology that compares the performance of several machine learning models so as to select the appropriate predicting model for the assessment of the students' achievements. To fit predicting models, three subjects of the Degree in Computer Science at the University of León are considered to obtain the dataset: computer organization, computer programming, and operating systems extension. The common aspect of these subjects is their assignments, which are based on developing one or several programs with programming languages such as C or Java. To monitor the practical assignments and individual performance, a Git repository is employed allowing students to store source code, documentation, and supporting control versions. According to the presented experience, there is a huge correlation between the level of interaction for each student and the achieved grades. [ABSTRACT FROM AUTHOR]

The article provides an introduction to this special issue related to software maintenance and evolution. The topics discussed in this issue were developed from papers presented at the International Conference on Software Maintenance and Evolution (ICSM), which was held in Budapest, Hungary from September 26-29, 2005; the articles focus on software maintenance and change. Topics such as reverse engineering, documenting, and programming computer software are discussed.

In this paper we: 1) discuss the need for quantitatively reproducible experiments in the study of top-down design; 2) propose the design and writing of tutorial papers as a suitably general and in- expensive vehicle; 3) suggest the software science parameters as appropriate metrics; 4) report two experiments validating the use of these metrics on outlines and prose; and 5) demonstrate that the experiments tended toward the same optimal modularity. The last point appears to offer a quantitative approach to the estimation of the total length or volume (and the mental effort required to produce it) from an early stage of the top-down design process. If results of these experiments are validated elsewhere, then they will provide basic guidelines for the design process. [ABSTRACT FROM AUTHOR]

The issue of plagiarism is discussed in the context of university education in disciplines related to computing. The focus is therefore mainly on software plagiarism. First, however, a case is made for the claim that the most important reason that plagiarism cannot be tolerated lies in the essence of the concept of a university as it is rooted in the Western cultural tradition. The main contribution of this paper is in providing firsthand insight into students' views on some of the delicate questions related to student plagiarism. However, this paper presents views from both sides of the question, including the views of staff members. This paper is quite unique in that it is coauthored by students who provide independent comments and recommendations. [ABSTRACT FROM PUBLISHER]

Overlapping communication with computation is a well-known approach to improving performance. Previous research has focused on optimizations performed by the programmer. This paper presents a compiler algorithm that automatically determines the appropriate loop indices of a given nested loop and applies loop interchange and tiling in order to overlap communication with computation. The algorithm avoids generating redundant communication by providing a framework for combining information on data dependence, communication, and reuse. It also describes a method of generating messages to exchange data between processors for tiled loops on distributed memory machines. The algorithm has been implemented in our High Performance Fortran (HPF) compiler, and experimental results have shown its effectiveness on distributed memory machines, such as the RISC System/6000 Scalable POWERparallel System. This paper also discusses the architectural problems of efficient optimization. [ABSTRACT FROM AUTHOR]

Heinrich C. Mayr, for many years has been a leading proponent of the importance of modelling issues for computing, the GI and the EMISA. On occasion of his 70th. birthday, this paper sheds a light on a number of key modelling issues. [ABSTRACT FROM AUTHOR]

This paper explores the use of a constructivist 21st-century learning model to implement a week-long workshop, delivered as a “hackathon,” to encourage preuniversity teenagers to pursue careers in STEM, with a particular emphasis on computer science. For Irish preuniversity students, their experience of computing can vary from word processing to foundational programming, and while many schools are looking to introduce more ICT into the classroom, many students are left with a narrow view of what computer science is all about. Twenty-one students participated in the workshop and completed pre- and post-surveys, and a free word association exercise in the areas of computing and careers in computing. Analysis revealed that students’ motivation to learn about the design process, programming, inputs and outputs, and wearable technology (wearables)/Internet of Things (IoT) increased following participation. There were also increases in confidence in inputs and outputs and wearables/IoT following participation, as well as changes in the computing word associations, with students associating computing more with computer programming terms rather than general terms such as the Internet. The findings suggest that the combination of a hackathon event and a model for 21st century learning can be effective in motivating and increasing the self-efficacy of preuniversity teenagers in a number of emerging technological contexts such as IoT and wearables. [ABSTRACT FROM PUBLISHER]

In this paper, we present a programming and runtime framework that enables the autonomic management of complex application workflows on hybrid computing infrastructures. The framework is designed to address system and application heterogeneity and dynamics to ensure that application objectives and constraints are satisfied. The need for such autonomic system and application management is becoming critical as computing infrastructures become increasingly heterogeneous, integrating different classes of resources from high-end HPC systems to commodity clusters and clouds. For example, the framework presented in this paper can be used to provision the appropriate mix of resources based on application requirements and constraints. The framework also monitors the system/application state and adapts the application and/or resources to respond to changing requirements or environment. To demonstrate the operation of the framework and to evaluate its ability, we employ a workflow used to characterize an oil reservoir executing on a hybrid infrastructure composed of TeraGrid nodes and Amazon EC2 instances of various types. Specifically, we show how different applications objectives such as acceleration, conservation and resilience can be effectively achieved while satisfying deadline and budget constraints, using an appropriate mix of dynamically provisioned resources. Our evaluations also demonstrate that public clouds can be used to complement and reinforce the scheduling and usage of traditional high performance computing infrastructure. [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.

Generation Z members use their smart devices as part of their everyday routine. Teaching methods may need to be updated to make learning materials more interesting for this generation. This paper suggests gamifying computer science subjects to enhance the learning experience for this generation. Additionally, many students face difficulty in understanding computer science materials and algorithms. Gamifying computer science education is one of the suggested teaching methods to simplify topics and increase students' engagement. Moreover, the field of computer science is dominated by males. The use of gamification could increase women's interest in this field. This paper demonstrates different techniques that were developed by the researchers to employ gamification in teaching computer science topics. The data was collected at the end of the two different courses. Results show that students enjoyed the suggested teaching method and found it useful. This paper also demonstrates two tools and their gamification elements. These tools were developed by the researchers to help people learn computer programming and information security. [ABSTRACT FROM AUTHOR]

Most weak memory consistency models are incapable of supporting a solution to mutual exclusion using only read and write operations to shared variables. Processor Consistency-Goodman's version (PC-G) is an exception. Ahamad et al. showed that Peterson's mutual exclusion algorithm is correct for PC-G, but Lamport's bakery algorithm is not. This paper derives a lower bound on the number of and type of (single or multiwriter) variables that a mutual exclusion algorithm must use in order to be correct for PC-G. Specifically, any such solution for n processes must use at least one multiwriter variable and n single-writer variables. Peterson's algorithm for two processes uses one multiwriter and two single-writer variables, and therefore establishes that this bound is tight for two processes. This paper presents a new n-process algorithm for mutual exclusion that is correct for PC-G and achieves the bound for any n. While Peterson's algorithm is fair, this extension to arbitrary n is not fair. Six known algorithms that use the same number and type of variables are shown to fail to guarantee mutual exclusion when the memory consistency model is only PC-G, as opposed to the Sequential Consistency model for which they were designed. A corollary of our investigation is that, in contrast to Sequential Consistency, multiwriter variables cannot be implemented from single-writer variables in a PC-G system. [ABSTRACT FROM AUTHOR]

The paper deals with Knowledge‐based Information Systems (IS) engineering. The Enterprise management functions, processes and their interactions are considered as the major components of the domain knowledge. This is the peculiarity of this approach to Enterprise modelling for IS engineering. The resulting framework for Enterprise modelling and Knowledge‐based IS engineering – Enterprise meta‐model (EMM) – is developed and presented in this paper. The architecture of the advanced CASE system is also discussed in this paper. [ABSTRACT FROM AUTHOR]

Abstract Many metrics have been proposed to measure coupling—the degree of association between modules in a system. They have often been described in different ways, hindering comparison and research. Their definitions are often incomplete regarding language features in some languages, meaning that different tool developers may implement the same metric differently. This complicates comparing results from studies that use different tools. This paper therefore aims to define coupling metrics consistently and unambiguously. The paper describes a model of coupling that uses the reification of the concept of dependency as its fundamental unit. Based on this model, it defines a framework for defining coupling metrics. It shows how to define several well-known coupling metrics in the framework, and how defining different metrics based on the same model facilitates direct comparisons. It discusses how the framework resolves issues due to incomplete metric definitions, such as different language features. This formal framework is sufficiently simple that it can be implemented in such a way as to provide multiple metrics. [ABSTRACT FROM AUTHOR]

Design patterns have gained popularity as they provide strategies for solving specific problems. This paper explores two common design patterns in iOS development field: Model View Controller (MVC) and Model View ViewModel (MVVM) design patterns. The paper investigates the problems with MVC design pattern. Then, it introduces a validation model that detects MVC problems, and helps programmers make the decision to switch between MVC and MVVM design pattern. The proposed validation model consists of two phases: phase one is to detect MVC problems, and phase two is to validate the relation between MVVM objects. The model was then applied to a Cloudy app as a case study. As a result, the model was able to detect MVC problems. The relation between MVVM objects was also validated. Further, this research provided some recommended solutions to satisfy the relations between MVVM objects in the project. [ABSTRACT FROM AUTHOR]

Learning Object (LO) is one of the main research topics in the e-learning community in the recent years. In this context, granularity is a key factor for LO reuse. This paper presents a methodology to define the learning objects granularity in the computing area as well as a case study in software testing. We carried out five experiments to evaluate the learning potential from the produced learning objects, as well as to demonstrate the possibility of LO reuse. The results show that LOs promote the understanding and application of the concepts. In addition, the set of LOs identified through the proposed methodology allowed its reuse in different contexts. [ABSTRACT FROM AUTHOR]

In all engineering discipline in universities, introductory programming is an essential part of the curriculum. However, many students find great difficulty with the learning of programming without instructor assistance and it becomes a barrier to their further studies of computer science and other disciplines. Intelligent Programming Tutors (IPTs) assist students to overcome difficulties in solving programming exercises, when they don't know how to proceed or they unable to find an error in their current state. Such a student may benefit from hints, guiding her toward a more complete and/or more correct version and allowing her to continue working on her own (Aleven et al., 2016). However, traditional IPTs take much time to create the expert knowledge because in computer programming tasks, the space of possible solutions is too large (Piech et al., 2015b). New development methods have emerged in recent years, which provide hints without an expert model. These techniques are based on data-driven approaches and/or program repair techniques and provide hints in the form of edits (such as inserting or deleting a piece of code). Students can apply these hints in their current state to change it into a more correct and/or more complete state. This paper aims to provide a best understanding of these new techniques and presents a comparative study between different approaches of automatic hint generation by presenting the forces and weaknesses of each approach. [ABSTRACT FROM AUTHOR]