the jakarta tool suite n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
The Jakarta Tool Suite PowerPoint Presentation
Download Presentation
The Jakarta Tool Suite

Loading in 2 Seconds...

play fullscreen
1 / 58

The Jakarta Tool Suite - PowerPoint PPT Presentation


  • 75 Views
  • Uploaded on

The Jakarta Tool Suite. Don Batory Department of Computer Sciences University of Texas at Austin . Introduction. Central problems in Software Engineering stem from one fact: Complaints about the lack of: quality, performance, reliability, maintainability, evolvability.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'The Jakarta Tool Suite' - maitland


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
the jakarta tool suite

The Jakarta Tool Suite

Don Batory

Department of Computer Sciences

University of Texas at Austin

introduction
Introduction
  • Central problems in Software Engineering stem from one fact:
  • Complaints about the lack of:
    • quality, performance, reliability, maintainability, evolvability

software is written by hand

quality of software
Quality of Software
  • Function of:
    • basic design
      • “build it several times to get it right”
      • designs improved with experience
    • programming staff
  • How can we do better?
    • to exploit previous experiences?
    • to improve quality of programmers?
future of software engineering
Future of Software Engineering
  • Automated production of rote software
      • major improvements in: performance, reliability, quality…
  • Domain-specific component technologies
      • engineering approach that standardizes:
        • designs (programming problems)
        • implementations (programming solutions)
generators
Generators
  • Generators are tools that:
    • transform component compositions into code
    • validate compositions automatically
    • automatic customizations and optimizations
  • Software quality improved
    • use good designs, expert programmers
    • expect good performance & reliability, easier maintenance, extensibility
what are generators
What are Generators?
  • Generators are compilers for:
    • domain-specific languages
    • general-purpose programming languages with domain-specific extensions
  • Problem:
    • generators are hard to build
    • programming infrastructure is lacking
    • 60% of effort focuses on infrastructure
the jakarta tool suite jts
The Jakarta Tool Suite (JTS)
  • for building component technologies and generators in Java
    • based on experiences in building multiple generators
    • compiler tools (POPART, Dialect, TXL), MS’s IP
  • for language extensibility
    • creates preprocessors for domain-specific languages (DSLs) or embedded DSLs
  • for architectural optimizations needed for self-adaptive software
language extensibility isn t new
Language Extensibility isn’t new...
  • LISP macros & CLOS meta-object protocols
  • Language extensibility of JTS based on different packaging architectural extensibility
    • same techniques used in avionics, network protocols, database systems were applied to programming languages
    • unit of extensibility is a “layer” or “building block” of a family of programming languages
this presentation
This Presentation...
  • Jak Language
      • open, extensible version of Java
      • its basic features
  • Bali Generator
      • of customized dialects of Jak
      • (product-line of dialects of Java)
  • Adaptive Software
      • demo
  • Status Report and Conclusions
the jak language

The Jak Language

open, extensible superset of Java

examine “base” extension

support for metaprogramming
Support for Metaprogramming
  • Extends Java with:
    • AST constructors
      • represent and manipulate programs as data
      • adds LISP quote/unquote to Java
    • AST traversals, manipulation
      • arbitrary program transformations
    • Generation scoping
      • variant of hygienic macros
ast constructors
AST Constructors
  • Added constructors for code fragments of different types (expression, statement, …)
      • similar to LISP quote

AST_Exp e = exp{ 7 + x*8 }exp;

AST_Stm s = stm{ if (y>4) return r; }stm;

e.unparse( ); // outputs “7 + x*8”

s.unparse( ); // outputs “if (y>4) return r;”

parameterization and composition of code fragments
Parameterization and Composition of Code Fragments
  • Explicit escapes
      • LISP unquote

AST_Exp e = exp{ 7 + x*8 }exp;

AST_Exp s = stm{ if (($exp(e))>4)

return r; }stm;

s.unparse( ): // outputs:

“ if ((7+x*8)>4) return r; ”

ast constructors continued
AST Constructors (Continued)
  • Focusing on AST constructors for Java (or extended Java)
  • Add AST constructors for other languages
    • CORBA IDL
    • Embedded SQL
    • (subsets of) C, C++
    • ...
the binding problem

int temp = 5;

macro(temp);

Application Code

int temp = 5;

{ int temp = 2*temp;

… }

int temp = 5;

{ int temp = 2*temp;

… }

Bogus Generated

Code

Hygienic, lexically scoped macros (HLSM)

The Binding Problem

macro(x) {

int temp = 2*x;

… }

Macro Definition

generation scoping
Generation Scoping
  • Generalization of HLSM for generators
      • Y. Smaragdakis added to Microsoft’s IP
      • validated with DiSTiL
      • convenient solution to “binding problem”
  • Different than HLSM
      • generators are not reflective, macro-based
      • GS allows you to maintain the name-space of the generated program
      • generator language different than generated language
ast traversals
AST Traversals
  • Package/classes for depth-first searches, manipulations
      • support arbitrary program transformations

AstCursor c = new AstCursor( );

Ast_Node root = // root of AST to search

for (c.First(root); c.More( ); c.PlusPlus( ) )

if (c.node instanceof AstInterface)

c.Delete( );

ssts versus asts
SSTs versus ASTs
  • Surface syntax tree (SST) is a syntactically correct parse tree
      • tree constructors, modifiers guarantee syntactic correctness
      • SSTs may not be semantically correct
  • Abstract syntax tree (AST) is a type-checked SST
      • with annotations to symbol table
      • invoked by typecheck( ) method to root of SST
extensibility of sst asts
Extensibility of SST/ASTs
  • “Intentions”
    • add AST nodes with domain-specific semantics
      • P3 adds cursor, container types to Java
    • at reduction time, intention nodes are replaced with their Java (or host language) implementations
      • P3 replaces cursor, container AST nodes with their concrete Java implementations
jakarta follows dsl paradigm

domain

specific

program

Written in Jak

lexer

and

parser

AST

transform

program

Java

program

Jak

Jakarta Follows DSL Paradigm
more detail processing in phases

Parser creates SST of

a domain-specific program

Jak type checks SST

to convert to AST

Jak replaces intentions

with SSTs

If necessary, SSTs can be

type checked to form ASTs

intentions

More Detail: Processing in Phases
big picture
Big Picture
  • JTS/Jak is technology marriage of:
    • Java
    • metaprogramming concepts
      • quote, unquote, generation scoping (HLSM)
    • intention-based programming andtransformation systems
  • Inherently “open” compiler
how to
How to...
  • Produce lexers and parsers?
  • Produce transform program?
  • Where does GenVoca fit in?answers in remainder of talk...
slide25

Bali

GenVoca Generator of

Precompilers of Java Dialects

family languages
Family Languages
  • Jak is a family of related languages
      • versions with/without constructors
      • with/without P3 extensions
      • with/without CORBA IDL extensions…
  • Classic library scalability problem
      • n optional, largely orthogonal features
      • 2n different possible combinations of features
      • cannot build all 2n combinations by hand
      • can generate them
bali is a genvoca generator
Bali is a GenVoca Generator
  • Bali assembles variants of Jak from components
  • Components encapsulate primitive extensions
      • generation scoping
      • domain-specific generators like P3
      • CORBA IDL
  • Compositions of components specifies particular variant
two aspects
Two Aspects
  • Tool for writing compilers for Domain-Specific Languages(DSL)
    • looks similar to other DSL-compiler tools
    • specify syntax of DSL or language extension
    • annotated, extended BNF grammars
  • GenVoca generator
    • software component technology
    • architectural, extensibility aspects
bali grammars
Bali Grammars
  • Extended BNF grammar
      • extended to handle repetitions
      • e.g., POPART

StatementList : ( Statement )+

;

ArgumentList : Argument ( ‘,’ Argument )*

;

bali grammars1

constructors: IfStm( token, token, ASTexp, token, ASTstm )

SwitchStm( token, token, ASTexp, token, ASTblk )

Bali Grammars
  • Annotated
      • by class to instantiate when production is recognized
      • POPART, DIALECT, common OO design techniques

SelectionStmt

: IF ‘(’ Expr ‘)’ Statement :: IfStm

| SWITCH ‘(’ Expr ‘)’ Block :: SwitchStm

;

inheritance hierarchies

Rule1

C1

Rule2

C2

C3

Inheritance Hierarchies
  • is deduced from DSL grammar

Rule1 : pattern1 :: C1

| Rule2

;

Rule2 : pattern2 :: C2

| pattern3 :: C3

;

bali specifications
Bali Specifications
  • Jak grammar
    • 170 tokens
    • 400 productions
    • 800 lines
  • Bali grammar
    • 15 tokens
    • 20 productions
    • 73 lines

// bali spec

lexical patterns

%%

grammar rules

what can be generated
What can be generated...
  • Lexical analyzer
      • Jlex (java version of lex)
      • Bernie Lofaso (Jakarta Team Member)
  • Parser
      • Java_Cup (java version of yacc)
      • Scott Hudson@Georgia Tech
  • Inheritance hierarchy and AST classes
      • constructors, unparsing, editing methods

Now moving

to JavaCC

what can t be generated

AstNode

JTS kernel class

Bali-generated classes

IfStm’

SwitchStm’

IfStm

SwitchStm

Hand-coded subclasses

What can’t be generated...
  • Type checking, reduction, optimization methods
    • AST node specific
    • hand code as subclasses to Bali-generated class
big picture1
Big Picture
  • Traditional approach to building compilers for domain-specific languages
        • clean model of proven technology
  • Problem: don’t want to hand-code and hand-assemble each variant
        • too expensive
  • Solution: GenVoca component technology
        • components encapsulate primitive extensions
        • compose components to form variants of Jak
genvoca
GenVoca
  • Model of parameterized programming
    • addresses the architectural aspects of software
    • building blocks of domains are refinements of fundamental domain abstractions
    • components are implementations of refinements
    • components composed by parameter instantiation
  • visualize component composition as stacking layers
quick tutorial

X

Z[ ]

Y [ ]

Z

Y

X

Quick Tutorial
  • Components define algebraic operators
  • Software system is typeequation

System:

System =

Question: what is relationship

of components to classes?

oo realizations of refinements

class

subclassing relationship

subclass

OO Realizations of Refinements
  • A small-scale refinement adds new data members, methods, and/or overrides existing methods to a class
large scale refinement

class

class

class

subclass

subclass

subclass

Large Scale Refinement
  • Adds new data members and methods simultaneously to several classes
relationship to genvoca

application classes

Relationship to GenVoca
  • GenVoca components are large scale
    • consistent refinements of multiple classes
relationship to jts

Guard

With

Java

Kernel

Application Classes

Relationship to JTS

AstNode

to scale not to scale

Guard

With

Java

Kernel

To Scale, Not to Scale...

AstNode

>500 classes

J1 = Guard[ With[ Java[ Kernel ] ] ];

express components as mixin layers

Component

x

y

z

w

Express Components as Mixin Layers
  • Mixins are classes whose superclass is specified via a parameter
  • Components are expressed as a mixin (whose superclass is the “lower layer”)
    • inner classes themselves are mixins
mixin layer construction

Guard

With

Java

Kernel

Mixin-Layer Construction

Elegant model of component-based software construction

big picture2
Big Picture
  • Bali is marriage of:
    • DSL compiler technology
    • GenVoca generator technology
  • Bali synthesizes versions of Jak thru component composition
    • automatic synthesis of lexer, parser, transform engine
    • can synthesize variants of other languages, too
current jts language

Compose

Component Definition and Composition

LayerDef

Macros

Embedded DSL

GenVoca Generator

for Containers

P3

SymTab

Match

Metaprogramming

AST Constructors

Hygienic Macros

GScope

AST

Java1.1

Base Language

Java1.0

Current JTS Language

Legend

1998

1997

current status
Current Status
  • Jakarta now supports:
      • AST constructors and escapes
      • generation scoping
      • parameterized inheritance (mixin layers)
      • P3 generator of container data structures
  • Add type checking to AST nodes
      • needed for semantics-based transformations
  • FSATS
      • Fire Support Automated Test System
self adaptive software

A

B

C

Self-Adaptive Software
  • JTS represents applications as equations
  • Users need help:
    • selecting components
    • knowing combinations that satisfy requirements

S =

S = A[ B[ C ] ];

express such knowledge as algebraic rewrite rules

design wizard
Design Wizard
  • Applies rewrite rules to optimize equations
  • Space of all implementations = space of all type equations
  • Rank “goodness” of a Teqn by generating cost functions that estimate performance
  • Walk space (heuristically) to locate Teqn with cheapest cost
simple application using p3
Simple Application using P3
  • Spelling checker
      • two containers, 1 for dictionary, another for document
      • initially are simple lists, optimally are hash or rbtrees with hash comparison optimizations

Cont = list[transient]

Code = rbtree[word, ... ]

self adaptivity

Self-Adaptive Cycle

Design Wizard

updated

requirements,

actual

workloads

regenerated

application

Application

Self-Adaptivity
  • Let application monitor its workload
  • Design Wizard deduces better implementation
  • Jak regenerates application
self adaptivity1
Self-Adaptivity
  • Concept of rewriting type equations is domain-independent
  • Interesting problem when there are lots of components that implement the same functionality in different ways
      • this is where optimization problems arise
  • Matter of analyzing additional domains and applying this technology
conclusions
Conclusions
  • JTS integrates of different technologies:
      • metaprogramming
      • domain-specific language compiler tools
      • architectural view: components/generators
  • Yields a powerful set of tools for creating
      • component technologies and their generators
  • Embody useful advance
      • generator infrastructure
      • automating software development
timings
Timings
  • How Jak works -14min
  • Bali - 4min
  • up to GenVoca - 9 min
  • up to current status - 10 min
  • current status - 11 min
  • Total: 48 min.