Yannis Smaragdakis Assistant Professor,  College of Computing, Georgia Tech  Ph.D. Department of Computer Sciences, University of Texas at Austin, December 1999.  See my older web page at Texas.  Office: CCB 215  Mailing Address: College of Computing, Georgia Tech, Atlanta, GA, 30332, USA  Phone: +1 404 385 1491  Fax: +1 404 894 9846  Email: yannis@cc.gatech.edu

• Current:
• ICSE'06 Emerging Results.  AOSD'06. OOPS'06.  GPCE'06.  FSE'06.  ISMM'06.
• Past edited proceedings:
• GPCE'03: I was program co-chair. See the proceedings from the ACM DL and from Springer-Verlag
• MPOOL (MPOOL'01 and MPOOL'02 proceedings). Workshop on C++ Template Programming (top-quality outlet for C++ work)

Non-Technical

• My PhD rants-and-raves (after popular request)
• Yannis's law: Programmer Productivity Doubles Every 6 Years. (Yes, I'm only half serious, but half is enough.)
  

Teaching:

• This semester, I teach the undergraduate CS 1322: Object-Oriented Programming, which I also taught in Spring'05
• I also teach a graduate course CS 6246: Object-Oriented Systems and Languages. (Fall 2004,Fall 2003,Fall 2002,Fall 2001)
• In Spring'04 I taught  CS 4210: Advanced Operating Systems. I taught the same course in the Spring 2003,  Spring 2002, Spring 2001 and the Spring 2000  semesters
• In Fall 2000, I taught CS 8803: Memory Hierarchies and Program Locality

Research

• My research interests are on the systems and languages side of software engineering:
• object-oriented language design and implementation (esp. multiparadigm programming, OO components, distributed programming in OO languages)
• advanced tools to facilitate program construction (esp. program generators, domain-specific languages, component-based systems, extensible language tools, automatic testing)
• memory management (esp. virtual memory systems).


• A fairly complete list of my publications in BibTeX format
• My Ph.D. students: Christoph Csallner, Shan Shan Huang, Eli Tilevich, David Zook
• Ph.D. alumni: Brian McNamara 
• My CV (in the funky Georgia Tech format)
  

 
• Projects, each with representative publications:
 
• J-Orchestra, NRMI, and GOTECH are language tools for distributed computing. J-Orchestra is an automatic partitioning system for Java programs. It is unique because you can put any regular application object on any machine, but guarantee that the semantics of the original program will be preserved. NRMI is Java middleware that makes distributed computing more like local computing. The GOTECH framework uses generative and Aspect-Oriented techniques to add distributed capabilities to existing programs.
  
• The rewriting engine of J-Orchestra and some applications are described in "J-Orchestra: Automatic Java Application Partitioning", which appeared in ECOOP 2002. An extended version is in CoC Tech Report 02-17. 
• "Appletizing: Running Legacy Java Code Remotely From a Web Browser" (ICSM'05) uses J-Orchestra to convert a regular Java application into an applet-server combination.
  
• "Portable and Efficient Distributed Threads for Java" (ACM Middleware'04) explains the distributed synchronization in J-Orchestra.
  
• "Automatic Partitioning: A Promising Approach to Prototyping Ubiquitous Computing Applications" is a preprint of an article from IEEE Pervasive Computing. Shows how J-Orchestra can be applied to the Ubiquitous Computing domain.
• A high-level description of the idea of application partitioning. From a paper in the 8th ECOOP workshop on Mobile Object systems.
• "NRMI: Natural and Efficient Middleware" contains a description of NRMI (appeared in ICDCS'03).
• "Aspectizing Server-Side Distribution", a description of GOTECH, appeared in the Automated Software Engineering (ASE)'03 conference.
• The J-Orchestra Web page contains more documentation and a downloadable version.
  

 
• Meta-AspectJ (MAJ) is a state-of-the-art meta-programming tool for Java and AspectJ. In the area of software generators and transformation systems, I have also worked on domain-specific languages (such as DiSTiL, for high-level data structure programming) and on program transformation systems (JTS at UTexas and Intentional Programming (IP) at Microsoft).
• "Statically Safe Program Generation with SafeGen" (in GPCE'05) shows a language that can certify a generator under all possible inputs to assert that it will only produce well-formed programs.
• "Program Generators and the Tools to Make Them" in PEPM'04.
  
• "Generating AspectJ Programs with Meta-AspectJ" describes MAJ. Won the Best Paper Award in GPCE'04!
• "A Personal Outlook on Generator Research" summarizes my past work and views for the future of the area. In the upcoming Domain-Specific Program Generation book.
  
• "Application Generators": a pre-print of a survey article in the Encyclopedia of Electrical and Electronics Engineering, (John Wiley and Sons).
• "JTS: Tools for Implementing Domain-Specific Languages" is a paper from ICSR 98.
• "Scoping Constructs for Program Generators" appeared at GCSE'99 (GCSE was the predecessor of GPCE).
• DiSTiL is described in the paper "DiSTiL: a Transformation Library for Data Structures" in the Domain-Specific Languages conference (DSL)'97.
  
  
  
• In the area of automatic testing I have worked on JCrasher and its followup system, CnC.
• CnC combines static checking (the ESC/Java system) with automatic test case generation. The paper "CnC: Combining Static Checking and Testing" appeared in ICSE'05.
  
• JCrasher is a system for random testing of Java programs. The paper "JCrasher: an Automatic Robustness Tester for Java" appeared in Software: Practice and Experience.
  
  
  
• FC++ is a really cool library for programming functionally in C++. It is the first library to fully combine higher-order and polymorphic functions, by neatly exploiting C++ type inference:
  
• Described in the paper: "Functional Programming with the  FC++ library". This is a pre-print of the article to appear in the Journal of Functional Programming. See also the original FC++ paper (Functional Programming in C++ from ICFP'00).
• "FC++: Functional Tools for OO Tasks" is a pre-print of a paper that appeared in Software Practice & Experience. It shows how some common OO programming tasks benefit from FC++.
• The FC++ Web page contains pointers to more FC++ publications and information.

 
• In Object-Oriented design, I have proposed the concept of a "mixin layer". A mixin layer is a static component encapsulating fragments of several different classes (mixins) so that all fragments are composed consistently. Mixin layers are a good implementation technique for layered designs.
• "Implementing Large-Scale Object-Oriented Components": my Ph.D. Dissertation. A revised version of part of the dissertation material appeared in an ACM TOSEM article (Mixin Layers: An Object-Oriented Implementation Technique for Refinements and Collaboration-Based Designs).
• "Implementing Layered Designs with Mixin Layers" is the original mixin layers paper from ECOOP 98.
  
  
  
• In the area of virtual memory management, I have proposed the EELRU replacement algorithm for virtual memory systems, which consistently outperforms LRU and offers good theoretical guarantees. Additionally, I have worked on techniques for compressed virtual memory and for the reduction (i.e., simulation-specific compression) of program reference traces.
• "General Adaptive Replacement Policies" is the (slightly) extended version of an ISMM'04 paper. It shows how to combine any two replacement policies and get the best of both.
  
• "The EELRU adaptive replacement algorithm" is an article that appeared in Performance Evaluation (Elsevier). This supersedes the older "EELRU: Simple and Effective Adaptive Page Replacement" paper in SIGMETRICS'99.
• "Flexible Reference Trace Reduction for VM Simulations" is a pre-print of an article in ACM TOMACS. Includes a lot more material than the older "Trace Reduction for Virtual Memory Simulations", presented in SIGMETRICS'99.
• "The Case for Compressed Caching in Virtual Memory Systems", won an "outstanding paper" award at the 1999 USENIX Annual Technical Conference. 

   
• Miscellaneous:
• Binary Refactoring is a refactoring-for-optimization technique that does not pollute the source code of an application. The paper "Binary Refactoring: Improving Code Behind the Scenes" was presented at ICSE'05.
  
• Unix dynamic libraries (shared objects) offer great support for layered programming. See the paper "Layered Development with (Unix) Dynamic Libraries" (presented at ICSR 2002) and the associated source code.
• How can we enforce interface requirements in C++? A quick-and-dirty solution is easy, but what is the best way to do it? A proposal is in "Static Interfaces in C++", which was presented in the 2000 C++ Template Programming Workshop.
• An algorithm for managing modem pools efficiently:
• Described in the paper: "Performing Replacement in Modem Pools", from USENIX 2000.
• Some pointers to supplementary material.