Modern Programming Environments Research Articles

PxBLAT: an efficient python binding library for BLAT

BackgroundWith the surge in genomic data driven by advancements in sequencing technologies, the demand for efficient bioinformatics tools for sequence analysis has become paramount. BLAST-like alignment tool (BLAT), a sequence alignment tool, faces limitations in performance efficiency and integration with modern programming environments, particularly Python. This study introduces PxBLAT, a Python-based framework designed to enhance the capabilities of BLAT, focusing on usability, computational efficiency, and seamless integration within the Python ecosystem.ResultsPxBLAT demonstrates significant improvements over BLAT in execution speed and data handling, as evidenced by comprehensive benchmarks conducted across various sample groups ranging from 50 to 600 samples. These experiments highlight a notable speedup, reducing execution time compared to BLAT. The framework also introduces user-friendly features such as improved server management, data conversion utilities, and shell completion, enhancing the overall user experience. Additionally, the provision of extensive documentation and comprehensive testing supports community engagement and facilitates the adoption of PxBLAT.ConclusionsPxBLAT stands out as a robust alternative to BLAT, offering performance and user interaction enhancements. Its development underscores the potential for modern programming languages to improve bioinformatics tools, aligning with the needs of contemporary genomic research. By providing a more efficient, user-friendly tool, PxBLAT has the potential to impact genomic data analysis workflows, supporting faster and more accurate sequence analysis in a Python environment.

Total Type Error Localization and Recovery with Holes

Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e. the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.

GrowClust3D.jl: A Julia Package for the Relative Relocation of Earthquake Hypocenters Using 3D Velocity Models

Abstract Relative relocation techniques are widely used to improve the resolution of earthquake hypocenter positions. Here, we present GrowClust3D.jl—an open-source software package written in the programming language Julia that builds and improves upon the original GrowClust algorithm, an established relative relocation technique based on cluster analysis instead of a more traditional matrix inversion approach. The adoption of Julia’s modern programming environment allows for greater flexibility in GrowClust3D.jl’s algorithm design and its computational implementation. Notable additions to the GrowClust3D.jl package include (1) several parallel processing options to improve efficiency in uncertainty quantification routines, (2) incorporation of geographic map projections and station elevations during the relocation process, and (3) the ability to use travel-time tables derived from 3D velocity models. We demonstrate the new features of the software package on relocation problems of different scales in Nevada, California, Texas, and New Zealand, where in the latter two cases the use of a 3D velocity model helps resolve structures that remain obscure with earlier versions of GrowClust. We expect that the new GrowClust3D.jl software package will become a valuable public resource for the earthquake science community.

Systemic approach in the development of functional foods for various noncommunicable diseases

The article presents a hierarchy of requirements necessary for the successful design of food products with given composition and properties considering age restrictions and various diseases. The need for generalization and systematization of scientifically based principles, specific medical and biological requirements for food products, diets for the most common nutritional diseases in the knowledge base is shown. Using the k-means cluster analysis method, 1) meat raw materials were analyzed for inclusion in functional food for gerodietetic nutrition according to the most significant descriptors (protein, methionine + cystine amino acids, tryptophan), 2) spicy herbs and spices were analyzed for inclusion in the Muhammara recipe as natural antioxidant sources according to the descriptor of antioxidant properties. Using the example of the Muhammara recipe change, all stages of a systemic approach in the development of functional foods are shown. The first stage is related to obtaining information from the knowledge base about scientifically based nutritional principles and specific biomedical requirements for the given age group. At the second stage, the clustering of raw materials of animal and vegetable origin is carried out in order to reasonably include in the recipe of food product being developed. At the third stage, a system of balance linear algebraic equations for the chemical composition of the food product being developed (mass fraction of fat, protein, water, carbohydrates, vitamins, macro- and microelements, amino acids, etc.) is formed. The fourth stage is associated with the establishment of the target function (optimization criterion), and restrictions for recipe and balance. At the fifth stage, the problem is solved using a high-level language in a modern programming environment. At the final (sixth) stage, the nutritional value of the optimal balanced recipe is analyzed considering the target function and the given restrictions. As a result, we receive a modified Muhammara recipe with optimized protein: fat ratio. Mathematical simulation was carried out using the R Studio software with open-source lpSolve and lpSolveAPI libraries.

A Volunteer Computing Architecture for Computational Workflows on Decentralized Web

The amount of accessible computational devices over the Internet offers an enormous but latent computational power. Nonetheless, the complexity of orchestrating and managing such devices requires dedicated architectures and tools and hinders the exploitation of this vast processing capacity. Over the last years, the paradigm of (Browser-based) Volunteer Computing emerged as a unique approach to harnessing such computational capabilities, leveraging the idea of voluntarily offering resources. This article proposes VFuse, a groundbreaking architecture to exploit the Browser-based Volunteer Computing paradigm via a ready-to-access volunteer network. VFuse offers a modern multi-language programming environment for developing scientific workflows usingWebAssembly technology without requiring the user any local installation or configuration. We equipped our architecture with a secure and transparent rewarding mechanism based on blockchain technology (Ethereum) and distributed P2P file system (IPFS). Further, the use of Non-Fungible Tokens provides a unique, secure, and transparent methodology for recognizing the users’ participation in the network.We developed a prototype of the proposed architecture and four example applications implemented with our system. All code and examples are publicly available on GitHub.

Improving the success rate of applying the extract method refactoring

• A technique to improve the success rate of applying the extract method refactoring. • An empirical study about usability and refactoring tools. • A tool that proposes alternative text selection for source code refactoring. • An empirical evaluation of the proposed tool. Context: Most modern programming environments support refactorings. Although refactorings are relevant to improve the quality of software source code, they unfortunately suffer from severe usability issues. In particular, the extract method refactoring, one of the most prominent refactorings, has a failure rate of 49% when users attempt to use it. Objective: Our main objective is to improve the success rate of applying the extract method refactoring. Methods: First, to understand the cause of refactoring failure, we conducted a partial replication of Vakilian's ICSE '14 study about usability issues of refactoring using IntelliJ IDEA. Second, we designed and implemented TOAD, a tool that proposes alternative text selection for source code refactoring for the Pharo programming language. Third, we evaluated TOAD using a controlled experiment against the standard Pharo code refactoring tool. Seven professional software engineers complemented with three undergrad students participated in our experiments. Conclusion: The causes we identified of failed extract method refactoring attempts match Vakilian's work. TOAD significantly reduces the number of failed attempts to run the extract method refactoring at a lower cognitive load cost.

Making Programming Accessible to Learners with Visual Impairments: A Literature Review

Programming can be challenging to learn and for visually impaired (VI) learners there are numerous additional barriers to the learning process. Many modern programming environments are inaccessible to VI learners, being difficult or impossible to interface with using a screen reader. A review of the literature has identified a number of strategies that have been employed in the quest to make learning to program accessible to VI learners. These can be broadly divided into the following categories; auditory and haptic feedback, making text-based langauges (TBLs) accessible, making block-based languages (BBLs) accessible and physical artefacts.A common theme among the literature is the difficulty VI learners have in gaining an understanding of the overall structure of their code. Much of the research carried out in this space to date focuses on the evaluation of interventions aimed at VI high-school and undergraduate students, with limited attention given to the learning processes of VI learners. Additionally, the majority of the research deals with (TBLs), this is despite the fact that most introductory programming courses for primary learners use (BBLs). Therefore, further research is urgently needed to investigate potential strategies for introducing VI children in primary education to programming and the learning processes involved.

Concurrent Drainage Network Rendering for Automated Pen‐and‐ink Style Landscape Illustration

AbstractPen‐and‐ink style geomorphological illustrations render landscape elements critical to the understanding of surface processes within a viewshed and, at their highest levels of execution, represent works of art, being both practical and beautiful. The execution of a pen‐and‐ink composition, however, requires inordinate amounts of time and skill. This article will introduce an algorithm for rendering creases – linework representing visually significant morphological features – at animation speeds, made possible with recent advances in graphics processing unit (GPU) architectures and rendering APIs. Beginning with a preprocessed high‐resolution drainage network model, creases are rendered from selected stream segments if their weighted criteria (slope, flow accumulation, and surface illumination), attenuated by perspective distance from the viewpoint, exceed a threshold. The algorithm thus provides a methodology for crease representation at continuous levels of detail down to the highest resolution of the preprocessed drainage model over a range of surface orientation and illumination conditions. The article also presents an implementation of the crease algorithm with frame rates exceeding those necessary to support animation, supporting the proposition that parallel processing techniques exposed through modern GPU programming environments provide cartographers with a new and inexpensive toolkit for constructing alternative and attractive real‐time animated landscape visualizations for spatial analysis.

Æminium

The aim of ÆMINIUM is to study the implications of having a concurrent-by-default programming language. This includes language design, runtime system, performance and software engineering considerations. We conduct our study through the design of the concurrent-by-default ÆMINIUM programming language. ÆMINIUM leverages the permission flow of object and group permissions through the program to validate the program's correctness and to automatically infer a possible parallelization strategy via a dataflow graph. ÆMINIUM supports not only fork-join parallelism but more general dataflow patterns of parallelism. In this paper we present a formal system, called μÆMINIUM, modeling the core concepts of ÆMINIUM. μÆMINIUM's static type system is based on Featherweight Java with ÆMINIUM-specific extensions. Besides checking for correctness ÆMINIUM's type system it also uses the permission flow to compute a potential parallel execution strategy for the program. μÆMINIUM's dynamic semantics use a concurrent-by-default evaluation approach. Along with the formal system we present its soundness proof. We provide a full description of the implementation along with the description of various optimization techniques we used. We implemented ÆMINIUM as an extension of the Plaid programming language, which has first-class support for permissions built-in. The ÆMINIUM implementation and all case studies are publicly available under the General Public License. We use various case studies to evaluate ÆMINIUM's applicability and to demonstrate that ÆMINIUM parallelized code has performance improvements compared to its sequential counterpart. We chose to use case studies from common domains or problems that are known to benefit from parallelization, to show that ÆMINIUM is powerful enough to encode them. We demonstrate through a webserver application, which evaluates ÆMINIUM's impact on latency-bound applications, that ÆMINIUM can achieve a 70% performance improvement over the sequential counterpart. In another case study we chose to implement a dictionary function to evaluate ÆMINIUM's capabilities to express essential data structures. Our evaluation demonstrates that ÆMINIUM can be used to express parallelism in such data-structures and that the performance benefits scale with the amount of annotation effort which is put into the implementation. We chose an integral computationally example to evaluate pure functional programming and computational intensive use cases. Our experiments show that ÆMINIUM is capable of extracting parallelism from functional code and achieving performance improvements up to the limits of Plaid's inherent performance bounds. Overall, we hope that the work helps to advance concurrent programming in modern programming environments.

Abstracting runtime heaps for program understanding

Modern programming environments provide extensive support for inspecting, analyzing, and testing programs based on the algorithmic structure of a program. Unfortunately, support for inspecting and understanding runtime data structures during execution is typically much more limited. This paper provides a general purpose technique for abstracting and summarizing entire runtime heaps. We describe the abstract heap model and the associated algorithms for transforming a concrete heap dump into the corresponding abstract model as well as algorithms for merging, comparing, and computing changes between abstract models. The abstract model is designed to emphasize high-level concepts about heap-based data structures, such as shape and size, as well as relationships between heap structures, such as sharing and connectivity. We demonstrate the utility and computational tractability of the abstract heap model by building a memory profiler. We use this tool to identify, pinpoint, and correct sources of memory bloat for programs from DaCapo.

How Programmers Debug, Revisited: An Information Foraging Theory Perspective

Many theories of human debugging rely on complex mental constructs that offer little practical advice to builders of software engineering tools. Although hypotheses are important in debugging, a theory of navigation adds more practical value to our understanding of how programmers debug. Therefore, in this paper, we reconsider how people go about debugging in large collections of source code using a modern programming environment. We present an information foraging theory of debugging that treats programmer navigation during debugging as being analogous to a predator following scent to find prey in the wild. The theory proposes that constructs of scent and topology provide enough information to describe and predict programmer navigation during debugging, without reference to mental states such as hypotheses. We investigate the scope of our theory through an empirical study of 10 professional programmers debugging a real-world open source program. We found that the programmers' verbalizations far more often concerned scent-following than hypotheses. To evaluate the predictiveness of our theory, we created an executable model that predicted programmer navigation behavior more accurately than comparable models that did not consider information scent. Finally, we discuss the implications of our results for enhancing software engineering tools.

The Dawn of Haiku - How a volunteer crew brought a crack OS back

It was the summer of 2001, and computer programmer Michael Phipps had a problem: His favorite operating system, BeOS, was about to go extinct. Having an emotional attachment to a piece of software may strike you as odd, but to Phipps and many others (including me), BeOS deserved it. It ran amazingly fast on the hardware of its day; it had a clean, intuitive user interface; and it offered a rich, fun, and modern programming environment. In short, we found it vastly superior to every other computer operating system available. But the company that had created BeOS couldn't cut it in the marketplace, and its assets, including BeOS, were being sold to a competitor.

PyNeb: a new software for the analysis of emission lines

AbstractWe describe an ongoing project to migrate the emission-line analysis package nebular from its current environment, IRAF, to a modern programming environment where it can be used from command line, a local GUI, or the web. We are also updating the supporting atomic data where they have been superseded by superior calculations or measurements.

Programming theorems on enumerator

This paper deals with the examination of the programming patterns best known by programmers: the programming theorems. It is a significant issue that in what way these patterns can be formulated in order to solve a relatively broad spectrum of problems using a small number of patterns. In this paper, the well known programming theorems are applied to the processing of enumerators. To this end, the robustness of patterns gained this way will be presented, and it will be also pointed out how the programs thus constructed can be implemented in the modern object-oriented programming environments: in language C++, Java and C#.

Guest Editors' Introduction: Mining Software Archives

Modern programming environments automatically collect lots of data on software development, notably changes and defects. The field of mining software archives is concerned with the automated extraction, collection, and abstraction of information from this data. This is the introduction to a special issue of IEEE Software presenting a selection of the exciting research that is taking place in the field.

Course management with TrucStudio

Ever growing expectations from students, university management and other stakeholders make course preparation increasingly time-consuming. Setting up a course from scratch requires producing many supporting documents such as syllabi, schedules, and course web sites listing the concepts being taught. This can be a considerable effort, taking time away from tasks with a more immediate pedagogical value, such as answering student questions and refining the concepts themselves. The TrucStudio course development framework supports a systematic approach to these necessary but arduous tasks. TrucStudio is organized like a modern programming environment, but its elements of discourse, rather than software modules, are units of knowledge such as notions, Trucs and clusters . In addition to course development, applications of TrucStudio include checking sound coverage of topics and comparing courses on an objective basis. This presentation focuses on two novel features of TrucStudio: version management of knowledge units and course information; and generation of output documents in various formats from knowledge units and other material managed by TrucStudio.

Designing human-computer interfaces for quadriplegic people

The need for participation in an emerging Information Society has led to several research efforts for designing accessibility solutions for disabled people. In this paper we present a method for developing Human-Computer Interfaces (HCIs) for quadriplegic people in modern programming environments. The presented method accommodates the design of scanning interfaces with modern programming tools, leading to flexible interfaces with improved appearance and it is based on the use of specially designed software objects called " wifsids " (Widgets For Single-switch Input Devices). The wifsid structure is demonstrated and 4 types of wifsids are analyzed. Developed software applications are to be operated by single-switch activations that are captured through the wifsids, with the employment of several modes of the scanning technique. We also demonstrate the "Autonomia" software application, that has been developed according to the specific methodology. The basic snapshots of this application are analyzed, in order to demonstrate how the wifsids cooperate with the scanning process in a user-friendly environment that enables a quadriplegic person to access an ordinary computer system.

Designing human-computer interfaces for quadriplegic people

Computer and system manufacturers often say that designing applications for users with disabilities is not cost-effective. Most computer systems are designed for users who are not disabled; therefore, systems that address disabled users need special interfaces in order to be accessible. In this paper we present a method for developing human-computer interfaces for quadriplegic people in modern programming environments, provided that they can perform single-switch signals. Using a scanning technique, "single-switch" users can sequentially highlight items that are laid out spatially on screen and then select an item by activating a switch when the target item is highlighted.

Client/Server based Statistical Computing

We propose a client server architecture for statistical computing. The main feature of our approach is the possibility to connect various client programs via a TCP/IP connection to a powerful statistical engine. This offers the opportunity to include the statistical engine into a number of software packages and to empower the user of these packages to access a modern statistical programming environment. It also allows for the development of specialized client programs for particular tasks. TCP/IP permits a client/server connection with the client and server running on different hosts (remote host) as well as running both applications on the same computer (local host). To have a large flexibility we suggest adding a middleware program managing the communication between Server and Client. This avoids the need to implement TCP/IP communication methods on the server side. The paper provides an overview of the desired environment and illustrates the general structure by the implementation of the XploRe Quantlet Client and XploRe Quantlet Server.

Runtime tags aren't necessary

Many modern programming environments use tag bits at runtime to distinguish objects of different types. This is particularly common in systems with garbage collection, since the garbage collector must be able to distinguish pointers from non-pointers, and to learn the length of records pointed to.