Never Reprogram AgainTM
Software Generators, LLC provides consulting, training and tools for automating the process of designing and generating software implementations. The focus of the company is Domain Specific program generation.
Software generators are programs that build other programs. This site focuses on the topic in general and the Domain Specific Language Generator (DSLGenTM) in particular. (Patents 8060857, 8225277, 8327321 and patent pending.) DSLGenTM is a system for translation of Domain Specific Languages (DSLs) into efficient code that exploits the high capability features (e.g., parallelism) of the target execution machine. More generally, DSLGenTM is also a platform plus toolbox on which arbitrary DSL translators can be developed for arbitrary domain languages and arbitrary execution platforms.
The motto Never Reprogram AgainTM means that a software specification need only define "what" a computation is intended to do without any hint of "how" the implementation accomplishes that "what". The implication is that no matter how computing machine architectures change and whatever new opportunities they provide, the implementation code our tools generate will be able to take advantage of those opportunities. Today, architectures offer opportunities for simple Von Neumann machines, multicore parallelism and instruction level parallelism among others, and our tools can exploit those opportunities. Who knows what tomorrow will bring but whatever it is, we aim to deliver technology and tools that will generate implementation code that takes full advantage of the new architectural opportunities without the necessity of reprogramming the applications for those new architectural platforms.
A Preview of DSLGenTM is provided in an invited paper given at the DReMeR '13 workshop held in conjunction with 13th International Conference on Software Reuse. It gives gives a peek at the forthcoming technology. The slides used to present this paper, which have been enhanced with additional slides and speaker's notes for unaided reading, are available here as Powerpoint (pptx) file or as a PDF file. The slides for the supplementaryTools Demo given at the main conference, whch have been enhanced with additional slides and speaker's notes for unaided reading, are here as a Powerpoint (pptx) file or as a PDF file. A short description of DSLGenTM and the technology is given in "Never Reprogram AgainTM " and a more complete description is given in "Automated Optimization of a Computation for Different Architectures". More extensive descriptions await release of the system.
The Publications page includes some of the early directions of our program generation efforts (Anticipatory Optimization Generator or AOG) along with overview documentation and links to key documents and presentations describing DSLGenTM. While much of the older work referenced on that page has been replaced by the machinery of DSLGenTM, it is nevertheless a good place to explore some of the background notions that led to DSLGenTM.
The Key Point: DSLGenTM and the technology underlying it make a fundamental representational change that completely distinguishes it from previous work (i.e., from MDE, Refactoring, Aspect Oriented Programming, other synthesis work, etc.). That change rejects Programming Language (PL) Abstractions in the computational specification and even in the generator's early design process. In the initial specification of the computation and even in the initial representation of the generator's design of the implementation, there are no classes, methods, functions, scopes, or other abstractions that fall into the Programming Language Domain (PFD). Instead, the generator begins in the problem domain by using a fundamentally new abstraction -- an Associative Programming Constraint (APC). APCs factor out or isolate singular (possibly global) design features and thereby partially and provisionally specify each singular design feature in the eventual generated program. Only when a set of interrelated APCs are combined to form a Logical Architecture (LA) do they fully define how to map a domain specific expression of the computation into a generated program expressed in the PL domain (e.g., expressed in the C language). In the course of that overall generation process, the LA is evolved and reorganized by addition of so-called synthetic APCs that introduce desired elective features (e.g., multicore parallelism and/or instruction level parallelism) into the final program. The mapping of the LA to final code additionally exploits design frameworks (a formalization of the "gang of four's" design patterns) to provide
- Global architectural frameworks to house cloned and specialized elements of the computation specification (e.g., frameworks might include interrelated thread routine skeletons and global synchronization patterns) and
- Low level coding cliches (e.g., portions of those frameworks might include thread cliches and individual synchronization steps).
The slides from the invited paper and the tools demos talks (referenced above) provide a sense of what an APC is, how it is used, what a tools-eye view of the LA internal structures look like (i.e., what a domain engineer extending DSLGenTM might see) and what the code generated by DSLGenTM looks like.
Additionally, this fundamental representational change leads to a
fundamental operational change. Reprogramming is
not required to take advantage of new execution platform
architectures and their specialized facilities. Only DSLGenTM
needs a one time update with a new generator backend that tailors
the generation process to the new execution platform.