Search

This article proposes the development of agile programming languages intended for specific domains. The authors share their work on creating Tyl, a programming language for enterprise resource planning applications utilizing Scrum as the agile process and Neverlang as the language workbench. Topics include the detailed process of Scrum including sprints, completion of product backlog items, and addressing challenges encountered for development of a domain-specific programming language.

This article offers clarity of the concept of low-code programming by exploring visual programming languages, programming by demonstration, and programming by natural language. Artificial intelligence, domain-specific languages, and model-view-controller pattern in low-code programming are also discussed.

Optimizing programs to run efficiently on modern parallel hardware is hard but crucial for many applications. The predominantly used imperative languages force the programmer to intertwine the code describing functionality and optimizations. This results in a portability nightmare that is particularly problematic given the accelerating trend toward specialized hardware devices to further increase efficiency. Many emerging domain-specific languages (DSLs) used in performance-demanding domains such as deep learning attempt to simplify or even fully automate the optimization process. Using a high-level--often functional--language, programmers focus on describing functionality in a declarative way. In some systems such as Halide or TVM, a separate schedule specifies how the program should be optimized. Unfortunately, these schedules are not written in well-defined programming languages. Instead, they are implemented as a set of ad hoc predefined APIs that the compiler writers have exposed. In this paper, we show how to employ functional programming techniques to solve this challenge with elegance. We present two functional languages that work together--each addressing a separate concern. RISE is a functional language for expressing computations using well-known data-parallel patterns. ELEVATE is a functional language for describing optimization strategies. A high-level RISE program is transformed into a low-level form using optimization strategies written in ELEVATE. From the rewritten low-level program, high-performance parallel code is automatically generated. In contrast to existing high-performance domain-specific systems with scheduling APIs, in our approach programmers are not restricted to a set of built-in operations and optimizations but freely define their own computational patterns in RISE and optimization strategies in ELEVATE in a composable and reusable way. We show how our holistic functional approach achieves competitive performance with the state-of-the-art imperative systems such as Halide and TVM. [ABSTRACT FROM AUTHOR]

This article reports on how to improve transparent governance of Free and Open Source Software (FOSS). The article presents the current state of FOSS governance using data from Github and builds a roadmap for transparency detailing workflow and decision-making. Topics include the establishment of a governance file located in the root folder of any open source project, the use of a domain-specific language, and the sharing of predefined templates to aid in widespread incorporation of transparency.

The article looks at the introduction of computer programming into high school classes other than mathematics or computer science classes, focusing on the authors' project of creating Task-Specific Programming (TSP) languages, also called teaspoon languages, that teachers and students in classes such as history can learn quickly and then use for tasks related to their subject. They note that TSP languages are a type of domain-specific programming languages (DSLs).

This paper introduces BioScript, a domain-specific language (DSL) for programmable biochemistry that executes on emerging microfluidic platforms. The goal of this research is to provide a simple, intuitive, and type-safe DSL that is accessible to life science practitioners. The novel feature of the language is its syntax, which aims to optimize human readability; the technical contribution of the paper is the BioScript type system. The type system ensures that certain types of errors, specific to biochemistry, do not occur, such as the interaction of chemicals that may be unsafe. Results are obtained using a custom-built compiler that implements the BioScript language and type system. [ABSTRACT FROM AUTHOR]

The article discusses hardware computing engines known as domain-specific accelerators (DSAs). It discusses Moore's Law, the design of the DSA, and various sources of acceleration for DSAs. It also discusses algorithms, total cost of ownership (TCO), and memory in the accelerators.

The authors discuss the development of the Racket programming language. They mention the use of embedded domain-specific languages (eDSLs), the need to develop a language that can easily create these eDSLs, and the long-range prospects and problems of language-oriented programming (LOP).

The industry is in the mood for programmable networks, where an operator can dynamically deploy network functions on network devices, akin to how one deploys virtual machines on physical machines in a cloud environment. Such flexibility brings along the threat of unpredictable behavior and performance. What are the minimum restrictions that we need to impose on network functionality such that we are able to verify that a network device behaves and performs as expected, for example, does not crash or enter an infinite loop? We present the result of working iteratively on two tasks: designing a domain-specific verification tool for packet-processing software, while trying to identify a minimal set of restrictions that packet-processing software must satisfy in order to be verification-friendly. Our main insight is that packet-processing software is a good candidate for domain-specific verification, for example, because it typically consists of distinct pieces of code that share limited mutable state; we can leverage this and other properties to sidestep fundamental verification challenges. We apply our ideas on Click packet-processing software; we perform complete and sound verification of an IP router and two simple middleboxes within tens of minutes, whereas a state-of-the-art general-purpose tool fails to complete the same task within several hours. [ABSTRACT FROM AUTHOR]

The article discusses the redevelopment of desktop application in JavaScript, the official programming language of the Web. Topics discussed include the support for the language by consumer hardware devices through the integration of a Web browser application, devices' support of Web views as part of the operating system user interface (UI), Netflix's development of highly complex UIs, testing on the Netflix website which adds features to enhance the control experience and asynchronous module definition (AMD) libraries.

This article demonstrates how high-level embedded DSLs (EDSLs) really can alleviate low-level programming with no contradiction. Topics discussed also include the need for software engineers not to be hesitant when it comes to writing computer programs that generate programs, an EDSL used to generate code that can provide safety guarantees in the generated code if structured properly, deferred-array data as an example of encapsulating code-generation tactics with a nice application programming interface.

The article discusses domain-specific languages and code synthesis using Haskell, which is said to be the premier pure functional programming language. Topics discussed include types in Haskell like those in other languages as constraining summaries of structural values, the influence of an embedded domain specific language (EDSL) on the cost of developing and maintaining a domain specific language when the facilities and tools of the host language are reused, and the additional functionality of the QuickCheck EDSL.

Millions of computer end users need to perform tasks over large spreadsheet data, yet lack the programming knowledge to do such tasks automatically. We present a programming by example methodology that allows end users to automate such repetitive tasks. Our methodology involves designing a domain-specific language and developing a synthesis algorithm that can learn programs in that language from user-provided examples. We present instantiations of this methodology for particular domains of tasks: (a) syntactic transformations of strings using restricted forms of regular expressions, conditionals, and loops, (b) semantic transformations of strings involving lookup in relational tables, and (c) layout transformations on spreadsheet tables. We have implemented this technology as an add-in for the Microsoft Excel Spreadsheet system and have evaluated it successfully over several benchmarks picked from various Excel help forums. [ABSTRACT FROM AUTHOR]

Good software engineering practice demands generalization and abstraction, whereas high performance demands specialization and concretization. These goals are at odds, and compilers can only rarely translate expressive high-level programs to modern hardware platforms in a way that makes best use of the available resources. Generative programming is a promising alternative to fully automatic translation. Instead of writing down the target program directly, developers write a program generator, which produces the target program as its output. The generator can be written in a high-level, generic style and can still produce efficient, specialized target programs. In practice, however, developing high-quality program generators requires a very large effort that is often hard to amortize. We present lightweight modular staging (LMS), a generative programming approach that lowers this effort significantly. LMS seamlessly combines program generator logic with the generated code in a single program, using only types to distinguish the two stages of execution. Through extensive use of component technology, LMS makes a reusable and extensible compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process, with common generic optimizations provided by the framework. LMS is well suited to develop embedded domain-specific languages (DSLs) and has been used to develop powerful performance-oriented DSLs for demanding domains such as machine learning, with code generation for heterogeneous platforms including GPUs. LMS has also been used to generate SQL for embedded database queries and JavaScript for web applications. [ABSTRACT FROM AUTHOR]

The article discusses domain-specific programming languages (DSLs) and how they can smooth communications in a software project between those developing the software and the eventual business users. Topics covered include fundamentals of domain modeling, designing a DSL, the benefits and disadvantages of using a DSL, how a DLS is structured, and how an embedded DSL can be developed. Throughout the author illustrates his exposition with DSL examples tailored for an application involving securities trading.

Flash is a widely used storage device in portable mobile devices such as smart phones, digital cameras, and MP3 players. It provides high density and low power, properties that are appealing for other computing domains. In this paper, we examine its use in the server domain. Wear-out has the potential to limit the use of Flash in this domain. To seriously consider Flash in the server domain, architectural support must exist to address this lack of reliability. This paper first provides a survey of current and potential Flash usage models in a data center. We then advocate using Flash as an extended system memory usage model—OS managed disk cache—and describe the necessary architectural changes. Specifically we propose two key changes. The first improves performance and reliability by splitting Flash-based disk caches into separate read and write regions. The second improves reliability by employing a programmable Flash memory controller. It changes the error code strength (number of correctable bits) and the number of bits that a memory cell can store (cell density) in response to the demands of the application. [ABSTRACT FROM AUTHOR]

The article discusses the teaching of computer programming languages and their basic principles in colleges and universities. The authors argue that since new programming languages are continuously being developed, it is critical to teach students foundational language principles. These include garbage collection and structured programming. Other topics include domain-specific languages (DSLs), formal design languages, and general-purpose languages.

The article discusses a paper that investigated the creation of a programmable convolution engine, focusing on the need for application-domain-specific components with some programmability due to demand for increasing functionality on less energy, as a way to conserve battery life. Topics include energy efficiency gains; the specialization of processors through the tuning of data storage structures to the data-flow and data-locality requirements of an algorithm; and a discussion of the breakdown of Dennard scaling and Moore's Law.