Task-Specific Programming Languages for Promoting Computing Integration

Domain-specific languages are often implemented by embedding them in general-purpose programming languages. The Kiama library used in this chapter for the Scala programming language contains a rewriting component that is an embedded implementation of the Stratego term rewriting language. The authors evaluate the trade-offs inherent in this approach and its practicality via a non-trivial case study. An existing Stratego implementation of a compiler for the Apply image processing language was translated into a Kiama implementation. The chapter examines the linguistic differences between the two versions of the Stratego domain-specific language, and compares the size, speed, and memory usage of the two Apply compiler implementations. The authors’ experience shows that the embedded language implementation inflicts constraints that mean a precise duplication of Stratego is impossible, but the main flavor of the language is preserved. The implementation approach allows for writing code of similar size, but imposes a performance penalty. Nevertheless, the performance is still at a practically useful level and scales for large inputs in the same way as the Stratego implementation.

Developing high-performance software is a difficult task that requires the use of low-level, architecture-specific programming models (e.g., OpenMP for CMPs, CUDA for GPUs, MPI for clusters). It is typically not possible to write a single application that can run efficiently in different environments, leading to multiple versions and increased complexity. Domain-Specific Languages (DSLs) are a promising avenue to enable programmers to use high-level abstractions and still achieve good performance on a variety of hardware. This is possible because DSLs have higher-level semantics and restrictions than general-purpose languages, so DSL compilers can perform higher-level optimization and translation. However, the cost of developing performance-oriented DSLs is a substantial roadblock to their development and adoption. In this article, we present an overview of the Delite compiler framework and the DSLs that have been developed with it. Delite simplifies the process of DSL development by providing common components, like parallel patterns, optimizations, and code generators, that can be reused in DSL implementations. Delite DSLs are embedded in Scala, a general-purpose programming language, but use metaprogramming to construct an Intermediate Representation (IR) of user programs and compile to multiple languages (including C++, CUDA, and OpenCL). DSL programs are automatically parallelized and different parts of the application can run simultaneously on CPUs and GPUs. We present Delite DSLs for machine learning, data querying, graph analysis, and scientific computing and show that they all achieve performance competitive to or exceeding C++ code.

Since Computer Science students are used to applying both General Purpose Programming Languages (GPPLs) and Domain-Specific Languages (DSLs), Generative Artificial Intelligence based on Language Models (LMs) can help them on automatic tasks, allowing them to focus on more creative tasks and higher skills. However, the teaching and evaluation of technical tasks in Computer Science can be inefficient and prone to errors. Thus, the main objective of this article is to explore the performance of LMs compared to that of undergraduate Computer Science students in a specific case study: designing and implementing RESTful APIs DSLs. This research aims to determine if LMs can enhance the efficiency and accuracy of these processes. Our case study involved 39 students and 5 different LMs that must use the two DSLs we also designed for their task assignment. To evaluate performance, we applied uniform criteria to student and LMs-generated solutions, enabling a comparative analysis of accuracy and effectiveness. With a case study comparing performance between students and LMs, this article contributes to checking to what extent LMs are able to carry out software development tasks involving the use of new DSLs specially designed for highly specific settings in a similar way as well-qualified Computer Science students are able to. The results underscore the importance of welldefined DSLs and effective prompting processes for optimal LM performance. Specifically, LMs demonstrated high variability in task execution, with two GPT-based LMs achieving similar grades to those scored by the best of the students for every task, obtaining 0.78 and 0.92 on a normalized scale [0, 1], with 0.23 and 0.14 Standard Deviation for ChatGPT-4 and ChatGPT-4o respectively. After the experience, we can conclude that a well-defined DSL and a proper prompting process, providing the LM with metadata, persistent prompts, and a good knowledge base, are crucial for good LM performance. When LMs receive the right prompts, both large and small LMs can achieve excellent results depending on the task.

The purpose of this study is to evaluate the 7th grade English curriculum developed in 2013 and revised in 2018 by considering the similarities and differences of the elements of a curriculum with the Eisner’s Educational Criticism Model, Within the scope of the research, semi-structured interviews were conducted with 8 teachers delivering 7th grade English lessons; 27 students, 19 parents and 3 school principals from three schools selected by considering different socio-economic level variation in Aydin city center. Besides, semi-structured observation form was developed to observe the curriculum implementation process of the English lesson. In addition to interview and observation data, document analysis was also applied. Document-based data were collected through the 2013 and updated 2018 English curriculum (primary and secondary school grades 2, 3, 4, 5, 6, 7 and 8) and both booklets curricula. Data were analyzed by descriptive analysis. As a result, the English teachers stated that the revision towards the whole curriculum was positive but it was very limited. Accordingly, it considers the reduction of learning outcomes in the renewed curriculum to be positive. Although teachers expect some additional arrangements to be made in some elements of the renewed curriculum, they find the curriculum generally well structured and feasible. In line with the data obtained from parents and students, it was emphasized that the chance to use English effectively in real environment was given to students and teachers. In addition, the fact that effective use of language is challenging in terms of four language skills is observed from the practices.

The development of ubiquitous healthcare applications has proved to be significantly more complex than traditional healthcare applications. In software engineering research, there are two approaches of interest to us for handling the kind of complexity that emerges. The first is the use of domain-specific languages, which abstracts the low-level domain knowledge required when using general-purpose programming languages into more expressive domain-specific constructs. The second is advanced modularity techniques, such as aspect-oriented programming, that provide for modularisation of concerns that complicate code by cutting across a broad code base and tangling with other concerns. In this paper, we identify a set of ubiquitous healthcare concerns that complicate their software development. We use advanced modularity techniques to provide good separation of these concerns and encapsulate their behaviour within a new domain-specific language, ALPH that provides the application developer with a high level of abstraction. The result is a means to develop ubiquitous healthcare applications more easily and in a more timely fashion, while improving software quality by increasing modularity in the code.

A straightforward implementation of an algorithm in a general-purpose programming language does usually not deliver peak performance: Compilers often fail to automatically tune the code for certain hardware peculiarities like memory hierarchy or vector execution units. Manually tuning the code is firstly error-prone as well as time-consuming and secondly taints the code by exposing those peculiarities to the implementation. A popular method to avoid these problems is to implement the algorithm in a Domain-Specific Language (DSL). A DSL compiler can then automatically tune the code for the target platform. In this article we show how to embed a DSL for stencil codes in another language. In contrast to prior approaches we only use a single language for this task which offers explicit control over code refinement. This is used to specialize stencils for particular scenarios. Our results show that our specialized programs achieve competitive performance compared to hand-tuned CUDA programs while maintaining a convenient coding experience.

This paper discusses the expansion and proliferation of programming languages that have been developed for data science.The paper gives background information on the technological development that led to the growth and expansion of data science languages.It then explains the common features among these languages that distinguish them from general-purpose programming languages.The paper is intended for professionals experienced in working with general-purpose programming languages and may want to enhance their working knowledge of Data Science Programming Languages.The paper further explains the main features that Data Science programming language offers, which may not be readily available in earlier programming languages .

Domain specific languages (DSLs) offer the potential for using a small, specialized and highly expressive programming language to concisely represent solutions for a particular domain of problems. The DSL approach is in stark contrast to that of a general programming language that attempts to provide a means to represent solutions for a broad range of problems. DSLs may incorporate constructs and syntactical features that not only relate to the problem context, but also to the execution platform. DSLs thus provide a potential for reducing development time and thereby cutting business costs. At present this approach is likely more appropriate to prototyping and rapid experimental work; but as technologies to implement DSLs improve they may become more beneficial and cost effective for developing marketable products. In this paper we present a DSL, called OptiSDR, aimed to improve developer productivity for development of software defined radio (SDR) applications deployed on heterogeneous computing architectures (HCAs). OptiSDR is designed for HCAs that adhere to certain combinations of processing devices, namely FPGAs, graphics processing units, and multi-core general purpose processors. Our aim to improve developer productivity in multiple ways was achieved, with development cycles for parallel DSP routines for SDR reduced to few hours as opposed to days for CUDA-C development cycles. OptiSDR uses automatic code generation for structured parallel SDR patterns, and performs automatic profiling to generate faster execution kernels with speed-ups of more than 50× compared to other sequential implementations while reducing manual effort in porting and tuning code. Therefore this paper reports on a study confirming the potential to speed up when using OptiSDR for prototyping SDR applications.

This paper addresses the problem of supporting the software development process through the artificial intelligence. The expert systems could advise the domain engineer in programming without the detailed experience in programming languages. He will use and integrate, with the help of deductive database and domain knowledge, the previously developed software components to new complex functionalities. The service oriented architecture (SOA) and loosely coupled software allow to fulfill these requirements. The objective of this document is to provide the knowledge representation of atomic Web services which will be registered as the facts in the deductive database as well as the inferring techniques. Also, the use of domain specific language (DSL) for modeling domain engineerpsilas requests to the expert system will be considered within this document.

Object oriented (OO) is the most accepted object modeling languages nowadays. Although OO languages are successful in modeling real world entities, nevertheless, there is little to no support for modeling state of object precisely in code. To overcome this problem, a new general purpose programming language is proposed that is built on two paradigms which are typestate-oriented and permission-based. One of the most vital factor for every language to be accepted and effective for users is having an enhanced standard library and clearly one of the most important parts is Input and Output (I/O) Application Programming Interface (API). One of a new programming language is Plaid language. Since the Plaid is at its early stage of development, I/O features provided by the Plaid standard library are very basic and limited. This paper presents I/O API that we have developed for the Plaid based on the features provided by Java I/O API. For the evaluation we used two metrics which are the number of features provided by I/O API, and the number of exceptions eliminated by using Plaid and typestate-oriented programming language.

Rule-based languages such as Kappa excel in their support for handling the combinatorial complexities prevalent in many biological systems, including signalling pathways. But Kappa provides little structure for organising rules, and large models can therefore be hard to read and maintain. This paper introduces a high-level, modular extension of Kappa called LBS-κ. We demonstrate the constructs of the language through examples and three case studies: a chemotaxis switch ring, a MAPK cascade, and an insulin signalling pathway. We then provide a formal definition of LBS-κ through an abstract syntax and a translation to plain Kappa. The translation is implemented in a compiler tool which is available as a web application. We finally demonstrate how to increase the expressivity of LBS-κ through embedded scripts in a general-purpose programming language, a technique which we view as generally applicable to other domain specific languages.

BackgroundAlthough gambling disorder is traditionally considered an adult phenomenon, the behavior usually begins in childhood or adolescence.ObjectiveThe aim of this study was to explore the frequency of problem gambling among Swedish adolescents and the suspected associated factors.MethodsThis study was based on data collected through a public health survey distributed in 2016 to pupils in ninth grade of primary school and in second grade of secondary school in Sweden. Bayesian binomial regression models, with weakly informative priors, were used to examine whether the frequency of the associated factors differed between those with and without problem gambling.ResultsApproximately 11.7% (469/4002) of the boys in ninth grade of primary school and 13.9% (472/3407) of the boys in second grade of secondary school were classified as problem gamblers. For girls, the corresponding frequencies were 1.2% (48/4167) and 0.7% (27/3634), respectively. The overall response rate was 77% (9143/11,868) among ninth grade pupils and 73.4% (7949/10,832) among second grade pupils, resulting in a total of 17,092 responses. Problem gambling was associated with poor sleep and having tried smoking, alcohol, and other substances among both boys and girls in ninth grade of primary school and boys in second grade of secondary school. Problem gambling among girls in second grade of secondary school was associated with an increased prevalence of having tried smoking and other substances and an increased prevalence of poor sleep.ConclusionsUsing a large representative sample of Swedish adolescents, we found that problem gambling was robustly associated with a substantially increased prevalence of poor sleep and having tried smoking, alcohol, and other substances among both boys and girls in ninth grade of primary school as well as among boys in second grade of secondary school. Our study adds important information for policy makers pointing at vulnerable groups to be considered in their work to prevent problem gambling.

What experts want from programming languages

This comparative study explores the similarities and differences between two widely-used programming languages: C++ and C#. While both languages are integral to modern software development, they cater to different development environments and paradigms. C++, a general-purpose programming language, is known for its performance efficiency and low-level memory management, making it ideal for system software, embedded systems, and performance-critical applications. In contrast, C#, a high-level language developed by Microsoft, is primarily used in the .NET ecosystem for building Windows applications, web services, and enterprise solutions. This study examines various aspects of both languages, including syntax, memory management, performance, ease of use, and application domains. By analyzing these parameters, the paper aims to provide a comprehensive comparison that highlights the strengths and weaknesses of C++ and C# in different programming contexts. Additionally, the study discusses the role of both languages in modern development environments and their suitability for various types of projects. The findings suggest that while C++ remains the preferred choice for performance-sensitive applications, C# offers a more user-friendly environment for rapid application development, particularly in enterprise and web-based applications.

The Programming Languages (PL) Track provides researchers and practitioners with a forum to present their ideas and experience in designing new programming concepts and implementing programming languages. It includes the topics of Compiling Techniques, Domain-Specific Languages, Formal Semantics and Syntax, Garbage Collection, Language Design and Implementation, Languages for Modeling, Model-Driven Development and Model Transformation, New Programming Language Ideas and Concepts, New Programming Paradigms, Practical Experiences with Programming Languages, Program Analysis and Verification, Program Generation and Transformation, Programming Languages from All Paradigms (Agent-Oriented, Aspect-Oriented, Functional, Logic, Object-Oriented, etc.), and Visual Programming Languages.