Since its always interesting to see how ideas develop, this page contains a reconstruction of the development of StrategoLanguage and its implementation. 

*March 1997*

At a visit to INRIA in Nancy the ideas of RewritingStrategies in Transform.ELAN are explained. This looks like an interesting mechanism for dealing with some of the problems encountered in Transform.ASFandSDF specification.

*Summer 1997*

Development of strategy combinators with Transform.BasLuttik.  The combinators are a mixture of process algebra (sequential programming) and modal logic (for term traversal). In contrast to Transform.ELAN no full backtracking operators are provided. New are combinators for GenericTermTraversal. The combinators are implemented in Transform.ASFandSDF.

	* SpecificationOfRewritingStrategies

*Fall 1997*

At the Transform.OregonGraduateInstitute Transform.AndrewTolmach is interested in a high-level language for specifying optimizations. An interpreter for the strategy combinators is implemented in Transform.MetaML.

*Winter 1998*

Since the implementation of Transform.MetaML is not up to speed the implementation of the interpreter is continued in Transform.SML.
The interpreter parses modules written in a dedicated language for specifying RewriteRules and RewritingStrategies.

While attending POPL'98 in San Diego it becomes clear that ContextualRules (inspired by the paper Transform.ShrinkingLambdaExpressionsInLinearTime by Transform.AndrewAppel and Transform.TrevorJim) can be implemented elegantly when match can share its variable scope with the context. A contextual rule can be implemented by means of a local traversal that performs a transformation that shares bindings from the context.

*Spring 1998*

Since interpretation is very slow implementation of compiler is begun with Transform.ZinoBenaissa. 

http://www.cs.uu.nl/~visser/pictures/portland-board-22-04-1998.jpg 

(See also this CompilerWritingPicture)

The compiler is written in SML based on the front-end for the intepreter. The compiler implements full backtracking. Strategy definitions are interpreted as macros and are completely expanded at compile time. The compiler reduces a specification to one huge strategy expression which is compiled to a single C function.

	* Visit to Transform.MaudeLanguage group at SRI

	* BuildingOptimizersWithRewritingStrategies

At a talk at FMCS Transform.EugenioMoggi observes that the operational semantics does not require full backtracking. It turns out that an implementation without full backtracking is desirable, i.e., much more efficient.

	* ACoreLanguageForRewriting: implement traditional rewriting with strategies, allows easy extension with features such conditional and default rules

*Summer 1998*

As a test case for the language, i.e., to get material to compile and to get a feeling for programming in the language, a compiler
for the strategies language is written in itself.

*September 1998*

The first bootstrap is completed just before attending Transform.ICFP'98.

As Transform.JanHeering had already suggested it suddenly becomes clear that the language should be called Stratego.

*Fall 1998*

	* StrategicPatternMatching: overlays, ContextualRules, RecursivePattern

*Winter 1999*

The first application other than the toy RML compiler and the StrategoCompiler itself is the implementation of the WarmFusion algorithm with Transform.PatriciaJohann. This later turns into the HSX package.

	* WarmFusionInStratego

	* OttoSkroveBagge from Bergen visits Utrecht to learn Stratego and to work on the implementation of CodeBoost, a transformation engine for C++ programs.

*Summer 1999*

	* First public release (0.4.1) in August

*Fall 1999*

	* Architecture of the XT bundle of transformation tools
		* Tools.ImplodeAsFix: using Tools.SDF parsers
		* pretty-printing: connecting the Tools.GenericPrettyPrinting package

*Winter 2000*
 
	* OttoSkroveBagge from Bergen visits for 3 months to work on the implementation of CodeBoost.

	* KarinaOlmos starts DSP transformation project at Philips Research Laboratories

	* FirstStrategoUsersDay

	* Program Optimization Seminar
		* simple optimizations

*Spring 2000*

	* LanguageIndependentTraverals
		* GenericTermDeConstruction

	* First course on SoftwareGeneration
		* MondrianOptimizer

*Summer 2000*

Implementation of compiler for Hpc.TigerLanguage

*Fall 2000*

	* First Hpc.HighPerformanceCompilersCourse
		* Hpc.TigerInStratego

	* XTaBundleOfTransformationTools

*Winter 2001*

	* Visit PatriciaJohann
		* FusingLogicAndControlWithLocalTransformations

	* Visit to Nancy: interpreter for Transform.RhoCalculus

	* StrategoScript: an interpreter for Stratego

	* SecondStrategoUsersDay

	* ASurveyOfStrategiesInProgramTransformation

	* Master's Projects
		* RhoStratego: generalizing the case construct
		* CobolX: PreserveLayout 
		* PanOptimizer: InliningStrategies

*Spring 2001*

Teaching

	* Second course on SoftwareGeneration
		* new slides on Stratego

Language extension

	* ScopedDynamicRewriteRules: generation of context-sensive rules
		* TigerInterpreter
		* TigerTypeChecker
		* TigerInliner

*Summer 2001*

	* StrategoRelease06

	* New compilation scheme using setjmp/longjmp to implement failure and nested functions (a gcc extension) to implement higher-order strategy arguments. 

*Fall 2001*

	* Third course on SoftwareGeneration
		* more [[StrategoDocumentation][slides]] on Stratego
		* assignments on: Transform.ProgramSimplification, Transform.SoftwareVisualization, Transform.ProgramInstrumentation

	* Implementation of optimizations with DynamicRules by Transform.KarinaOlmos

	* Third course on [[Hpc.WebHome][High-Performance Compilers]]
		* Improved implementation of the Hpc.TigerCompiler
		* Bottomup-rewriting for code generation using dynamic rules by Transform.MartinBravenboer

	* [[StrategoRelease063][Stratego 0.6.3]] introduces TermWrap and TermProject

*Fall 2002*

	* [[StrategoDownload08][Stratego 0.8]] introduces support for program transformation with concrete object syntax

*Winter 2003*

	* [[http://www.stratego-language.org/Stratego/StrategoRelease09][StrategoXT 0.9]] merges Stratego and the XT toolset.

	* XTC tool composition for creating complete transformation systems in Stratego.

*Spring 2004*

	* [[http://www.stratego-language.org/Stratego/StrategoRelease010][StrategoXT 0.10]]: major redesign of dynamic rules.