Staging with class: a specification for typed template Haskell

Multi-stage programming using typed code quotation is an established technique for writing optimizing code generators with strong type-safety guarantees. Unfortunately, quotation in Haskell interacts poorly with type classes, making it difficult to write robust multi-stage programs. We study this unsound interaction and propose a resolution, staged type class constraints, which we formalize in a source calculus λ ⇒ that elaborates into an explicit core calculus F . We show type soundness of both calculi, establishing that well-typed, well-staged source programs always elaborate to well-typed, well-staged core programs, and prove beta and eta rules for code quotations. Our design allows programmers to incorporate type classes into multi-stage programs with confidence. Although motivated by Haskell, it is also suitable as a foundation for other languages that support both overloading and quotation.

Area-Efficient Universal Code Generator for GPS L1C and BDS B1C Signals

Recently, multi-frequency multi-constellation receivers have been actively studied, which are single receivers that process multiple global navigation satellite system (GNSS) signals for high accuracy and reliability. However, in order for a single receiver to process multiple GNSS signals, it requires as many code generators as the number of supported GNSS signals, and this is one of the problems that must be solved in implementing an efficient multi-frequency multi-constellation receiver. This paper proposes an area-efficient universal code generator that can support both GPS L1C signals and BDS B1C signals. The proposed architecture alleviates the area problem by sharing common hardware in a time-multiplex mode without degrading the overall system performance. According to the result of the synthesis using the CMOS 65 nm process, the proposed universal code generator has an area reduced by 98%, 93%, and 60% compared to the previous memory-based universal code generator (MB UCG), the Legendre-generation universal code generator (LG UCG), and the Weil-generation universal code generator (WG UCG), respectively. Furthermore, the proposed generator is applicable to all Legendre sequence-based codes.

Area-Efficient Universal Code Generator for Multi-GNSS Receivers

Although conventional global navigation satellite systems (GNSS) receivers were originally designed for single signals, studies on multi-signal receiver design have recently been actively conducted to achieve high accuracy, precision, and reliability. However, in order for a multi-signal receiver to support various codes, the receiver should support the generation of individual codes. Therefore, the resulting problem of increased complexity must be solved. This paper proposes a hardware structure for an area-efficient linear feedback shift register (LFSR)-based multi-frequency universal code generator. Whereas the existing universal code generators were configured so that feedback polynomials, output registers, and initial values can be selected by placing read-only memories (ROMs), multiplexers (MUXs), and exclusive ORs (XORs) by register bit, in the case of the proposed universal code generator; the circuit was implemented by applying the hardwiring technique to those register bits that have fixed values. According to the results of field programmable gate array (FPGA) implementation, the proposed LFSR-based universal code generator can improve look up table (LUT) by up to 37% and register by up to 78% when compared to conventional code generators, and LUT by up to 36% when compared to the previous universal code generator. Therefore, the proposed universal code generator is a good candidate for implementing multi-frequency receivers to achieve high precision and high reliability.

Applying MDD in the content management system domain

Content management systems (CMSs) such as Joomla and WordPress dominate today’s web. Enabled by standardized extensions, administrators can build powerful web applications for diverse customer demands. However, developing CMS extensions requires sophisticated technical knowledge, and the complex code structure of an extension gives rise to errors during typical development and migration scenarios. Model-driven development (MDD) seems to be a promising paradigm to address these challenges; however, it has not found adoption in the CMS domain yet. Systematic evidence of the benefit of applying MDD in this domain could facilitate its adoption; however, an empirical investigation of this benefit is currently lacking. In this paper, we present a mixed-method empirical investigation of applying MDD in the CMS domain, based on an interview suite, a controlled experiment, a field experiment, and case studies. During the experiments, we used JooMDD, an MDD infrastructure instantiation for CMS extensions. This infrastructure, which is also presented in this work, consists of a DSL with model editors, code generators, and reverse engineering facilities. We consider three scenarios of developing new (both independent and dependent) CMS extensions and of migrating existing ones to a new major platform version. The experienced developers in our interviews acknowledge the relevance of these scenarios and report on experiences that render them suitable candidates for a successful application of MDD. We found a particularly high relevance of the migration scenario. Our experiments largely confirm the potentials and limits of MDD as identified for other domains. In particular, we found a productivity increase up to factor 11.7 and a quality increase up to factor 2.4 during the development of CMS extensions. Furthermore, our observations highlight the importance of good tooling that seamlessly integrates with already used tool environments and processes.

Verification of Program Transformations with Inductive Refinement Types

High-level transformation languages like Rascal include expressive features for manipulating large abstract syntax trees: first-class traversals, expressive pattern matching, backtracking, and generalized iterators. We present the design and implementation of an abstract interpretation tool, Rabit, for verifying inductive type and shape properties for transformations written in such languages. We describe how to perform abstract interpretation based on operational semantics, specifically focusing on the challenges arising when analyzing the expressive traversals and pattern matching. Finally, we evaluate Rabit on a series of transformations (normalization, desugaring, refactoring, code generators, type inference, etc.) showing that we can effectively verify stated properties.

One-relation languages and code generators

We investigate the open problem to characterize whether the infinite power of a given language is generated by an ω-code. In case the given language is a code (i.e. zero-relation language), the problem was solved. In this work, we solve the problem for the class of one-relation languages.

Using Code Generators when Creating Ready-Made Templates for Application Development

Code generation is basically about writing programs that write programs. Given today’s complex code-intensive frameworks, such as Java 2 Enterprise Edition (J2EE), Microsoft’s. NET and Microsoft Foundation Classes (MFC), it is becoming increasingly important that we use our skills to create programs which aid us in developing our applications. Generally speaking, the more complex the framework is, the more appealing you will find a code generation solution. Many object-oriented programming (OOP) languages lack reusability and flexibility, and require a similar code to be written repeatedly. This paper reviews the code generators that are most useful for implementation in applications for automatic code generations, their pros and cons, where they are most widely used nowadays, as well as their versatility. In Visual Studio we use the term “scaffolding” when we want to generate identities automatically. When we start a new ASP.NET project, it genrates a template where we start from.

Integrating formal specifications into applications: the ProB Java API

The common formal methods workflow consists of formalising a model followed by applying model checking and proof techniques. Once an appropriate level of certainty is reached, code generators are used in order to gain executable code. In this paper, we propose a different approach: instead of generating code from formal models, it is also possible to embed a model checker or animator into applications in order to use the formal models themselves at runtime. We present a Java API to the ProB animator and model checker. We describe several case studies that use this API as enabling technology to interact with a formal specification at runtime.

TreeGen: A Tree-Based Transformer Architecture for Code Generation

A code generation system generates programming language code based on an input natural language description. State-of-the-art approaches rely on neural networks for code generation. However, these code generators suffer from two problems. One is the long dependency problem, where a code element often depends on another far-away code element. A variable reference, for example, depends on its definition, which may appear quite a few lines before. The other problem is structure modeling, as programs contain rich structural information. In this paper, we propose a novel tree-based neural architecture, TreeGen, for code generation. TreeGen uses the attention mechanism of Transformers to alleviate the long-dependency problem, and introduces a novel AST reader (encoder) to incorporate grammar rules and AST structures into the network. We evaluated TreeGen on a Python benchmark, HearthStone, and two semantic parsing benchmarks, ATIS and GEO. TreeGen outperformed the previous state-of-the-art approach by 4.5 percentage points on HearthStone, and achieved the best accuracy among neural network-based approaches on ATIS (89.1%) and GEO (89.6%). We also conducted an ablation test to better understand each component of our model.

A Bag of Wiki Stories, Attribute Oriented Programming with XDoclet, Rx ++ and GS collections.

The Wiki Story an essential documentation as javadoc is added to GS collections as a mutable data structure, added to collections like the Bag, leading to self modifiable programs with attribute oriented programming inspired by work in LISP and AIML, and the Self language of BotLibre. In this paper we integrate Open FaaS to Java 8 and RxJava, for Green Coding and the generalization to reusable components in remote functions on the edge or the cloud.Keywords: GS collections, Eclipse collections, XDoclet, Code Generators, Open FaaS, Bayou Framework.What:The GS Collections has a new data structure candidate, the Wiki Story WS, WS inherits from the User Stories of the Agile process, with documentation embedded in it as comments, amenable directly to OOPS programming. A WS data structure is defined by the this property and reflects a uniform xml, JSON and html5 DOM structure. X Doclet is introduced as attribute oriented programming with a set of attributes , both for Beans, Streams, and Rx Operators and data structures. How:Attributes define Rx and Rx ++ programming with code generators from XDoclet 2 library.Custom objects allow for the integration of Rx Stream objects, both sensor streams, event streams, kinesis streams and dynamoDB streams and many more streams. OpenFaaS is also integrated by a query based function integration as remote method or cloud based method integration with attributes, called green coding similar to the method, queryCodeGenerator()(Bheemaiah, n.d.)Bayou but extended to FaaS, services as attributes.(“How to Use Bayou – Bayou: Program Synthesis Powered by Bayesian Machine Learning” n.d.)Why:We have added wiki’s to the user stories provided as agile, attributes are added allowing for a query based tool for FaaS and XDoclet based code generation analogous to the neural sketch learning of Bayou. Code generation as amplification is now so fashionable that gangster like coders can also contribute really well generated code, an evolution of compiler backend code.Applications:Uniform high quality code, optimized to score high on Sonar, Code Generators for amplification and Green Coding.