Yannis Smaragdakis

Yannis Smaragdakis (also Ioannis Smaragdakis, Γιάννης Σμαραγδάκης)

Professor (35%-time, also at Dedaub)
Mailing address (shortened but valid): Dept. of Informatics, University of Athens, Ilisia, 15784, Greece
Phone: +30 210 7275311
Email: yannis@smaragd.org (or smaragd@di.uoa.gr)

Events:

Current Service: while part-time, I am less likely to accept service duties.
YouTube channel for my lab

Teaching:

Greece: Compilers (S11,S12,S13,S14,S15,S16,F17,S19,S20,S21,S22,S25); Analysis of Smart Contracts on Blockchain Platforms (S25); OO Languages and Systems/Advanced Programming Techniques (F10, F11, F12, F13, F14, F15, F17, F18, F19, F20, F21); Advanced Compilers and Static Analysis (S19, S20,S21,S22); Operating Systems (F17); Systems Programming (S14,S15,S16); SE (S11,S12,S13).
US: SE (S09); OO Languages and Systems (F09, S09, S08, S07, F05, F04, F03, F02, F01); Graduate Seminar (S07, F08); Distributed Systems (F06, F07); Intro OO (F05, S05); Advanced OS (S04, S03, S02, S01, S00); Memory Management (F00).

Research

Programming languages and software engineering:
- Program analysis (static analysis, test generation, invariant inference, symbolic execution)
- Language mechanisms for abstraction (declarative languages, program generation, DSLs, modules and components, generics, extensible languages, multi-paradigm programming)
- Languages and tools for systems (programming models for concurrency, language support for distributed computing, memory management and program locality)

Gratefully acknowledging funding by the ERC (Advanced grant, '24-'29), and the HFRI.
(Very outdated) CV

My Ph.D. students: Anastasis Antoniadis.. Sifis Lagouvardos.. Panagiotis Diamantakis.
Ph.D. alumni: Brian McNamara, Eli Tilevich, Christoph Csallner, Shan Shan Huang, John Altidor, Kaituo Li, Aggelos Biboudis, George Balatsouras, George Kastrinis.
Sample older B.Sc. and M.Sc. theses
Latest work:
Project areas, each with representative publications and links:
- Static analysis of smart contracts: work that led to Dedaub and to the best decompiler for Ethereum VM smart contracts.
- - "Symbolic Value-Flow Static Analysis: Deep, Precise, Complete Modeling of Ethereum Smart Contracts" (OOPSLA'21)
  - "Precise Static Modeling of Ethereum 'Memory'" (OOPSLA'20)
  - "MadMax: Analyzing the Out-of-Gas World of Smart Contracts" (CACM Oct'20)
    - Condensed, updated "research highlight" over "MadMax: Surviving Out-of-Gas Conditions in Ethereum Smart Contracts" (OOPSLA'18)
  - "Ethainter: A Smart Contract Security Analyzer for Composite Vulnerabilities" (PLDI'20)
  - "Gigahorse: Thorough, Declarative Decompilation of Smart Contracts" (ICSE'19)
- General Static Program Analysis (esp. pointer analysis): we express a rich set of static analyses completely declaratively (in the Datalog language).
- Program generators, generics in PL, extensibility: MorphJ is a language for safe "morphing", i.e., creating classes by iterating over members of other classes. This work also includes a generalization of the concept of "variance" in generics/templates: a way to marry parametric and subtype polymorphism. In the 90s, I also worked (as an intern and a funded Ph.D. student) on the Intentional Programming (IP) project at Microsoft.
- - "Stream Fusion, to Completeness" (POPL'17)
  - "Structured Program Generation Techniques" (GTTSE--Grand Timely Topics in SE)
  - "Automating Ad hoc Data Representation Transformations" (OOPSLA'15)
  - "Foo: A Minimal Modern OO Calculus" (FTfJP'15)
  - "jUCM: Universal Class Morphing" (MASPEGHI'15)
  - "Streams a la carte: Extensible Pipelines with Object Algebras" (ECOOP'15). Closely related to earlier performance analysis study: "Clash of the Lambdas" (ICOOOLPS'14)
  - "Refactoring Java Generics by Inferring Wildcards, In Practice" (OOPSLA'14)
  - "Forsaking Inheritance: Supercharged Delegation in DelphJ" (OOPSLA'13)
  - "Reified Type Parameters Using Java Annotations" (GPCE'13)
  - "Java Wildcards Meet Definition-Site Variance" (ECOOP'12)
  - "Morphing: Structurally Shaping a Class by Reflecting on Others": a comprehensive article (ACM TOPLAS, sans appendix)
    - "Expressive and Safe Static Reflection with MorphJ" (PLDI'08)
    - "Morphing: Safely Shaping a Class in the Image of Others" (ECOOP'07)
    - "Morphing Software for Easier Evolution" (RAM-SE'07)
  - "Statically Safe Program Generation with SafeGen" (SCP) shows a language that can certify a generator under all possible inputs to assert that it will only produce well-formed programs.
    - conference version at GPCE'05
  - "Taming the Wildcards: Combining Definition- and Use-Site Variance" (PLDI'11)
  - Meta-AspectJ (MAJ) is a state-of-the-art meta-programming tool for Java and AspectJ
    - "Domain-Specific Languages and Program Generation with Meta-AspectJ" (ACM TOSEM). Expands "Generating AspectJ Programs with Meta-AspectJ" (GPCE'04) and "Easy Language Extension with Meta-AspectJ" (ICSE'06 Emerging Results)
  - "cJ: Enhancing Java with Safe Type Conditions" (AOSD'07)
  - "Program Generators and the Tools to Make Them" (PEPM'04)
  - "A Personal Outlook on Generator Research" (Domain-Specific Program Generation)
  - "Application Generators": survey article in the Encyclopedia of Electrical and Electronics Engineering, (John Wiley and Sons)
  - "JTS: Tools for Implementing Domain-Specific Languages" (ICSR'98)
  - "Scoping Constructs for Program Generators" (GCSE'99)
  - "DiSTiL: a Transformation Library for Data Structures" in the Domain-Specific Languages conference (DSL)'97.
- Declarative languages: I am a late convert to declarative programming. An interesting direction is bounded, special-purpose declarative languages (e.g., for parallelism, or for GC-time computation).
- Program analysis and test generation for bug detection: the most recent work includes Residual Investigation: an approach that enhances static bug warnings with predictive dynamic analyses. My original work includes JCrasher and its followups, CnC and DSD-Crasher. JCrasher is a system for random testing of Java programs. CnC combines static checking (the ESC/Java system) with automatic test case generation. DSD-Crasher adds a dynamic invariant detection step to CnC. Finally, the ORM- modeling formalism allows efficient satisfiability checking and test data generation.
- Languages and language-inspired tools for distributed and concurrent computing: My work includes the causally-precedes relation for sound, predictive race detection, and adaptive locks: a model for switching between mutex locks and transactions dynamically (either for performance or for correctness). See also the TIC model for transactional memory.
  Past work includes J-Orchestra: an automatic partitioning system for Java programs. It manages to enable distributed execution over a network, as if the program was running on a single VM, using only rewrite techniques over standard runtimes. See also NRMI: Java middleware offering a programming model for distributed computing that resembles single-machine programming.
- - "Sound Predictive Race Detection in Polynomial Time" (POPL'12)
  - "Adaptive Locks: Combining Transactions and Locks for Efficient Concurrency" (JPDC)
    - conference version at PACT'09, earlier version at TRANSACT'09, position paper at MSPC'08.
  - "Transactions with Isolation and Cooperation" (OOPSLA'07)
  - "NRMI: Natural and Efficient Middleware" (IEEE TPDS)
    - conference version at ICDCS'03
  - "J-Orchestra: Enhancing Java Programs with Distribution Capabilities": a comprehensive article (ACM TOSEM)
    - "J-Orchestra: Automatic Java Application Partitioning": the original J-Orchestra paper from ECOOP'02. Extended version 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" (IEEE Pervasive Computing)
    - "Automatic Application Partitioning: The J-Orchestra approach" (position paper from the 8th ECOOP workshop on Mobile Object systems)
  - "Transparent Program Transformations in the Presence of Opaque Code" (GPCE'06)
  - "Binary Refactoring: Improving Code Behind the Scenes" (ICSE'05): a refactoring-for-optimization technique that does not pollute the source code
  - "Aspectizing Server-Side Distribution": a description of GOTECH, (ASE'03)
- Memory management: I have worked on adaptive memory management algorithms, i.e., ways to combine two policies and get the best of both, with theoretical guarantees. In the past, I proposed the EELRU replacement algorithm for virtual memory systems, which consistently outperforms LRU. Additionally, I have worked on techniques for compressed virtual memory and for the reduction (i.e., simulation-specific compression) of program reference traces.
- - "Adaptive Caching: Effective Shaping of Cache Behavior to Workloads" (MICRO'06)
  - "General Adaptive Replacement Policies" (ISMM'04)
  - "The EELRU adaptive replacement algorithm" (Performance Evaluation--Elsevier)
  - - "EELRU: Simple and Effective Adaptive Page Replacement" (SIGMETRICS'99): the original EELRU paper
  - "Flexible Reference Trace Reduction for VM Simulations" (ACM TOMACS)
  - - "Trace Reduction for Virtual Memory Simulations" (SIGMETRICS'99): the original trace reduction paper
  - "The Case for Compressed Caching in Virtual Memory Systems", at the 1999 USENIX Annual Technical Conference
  - "Performing Replacement in Modem Pools" (USENIX'00): an algorithm for managing modem pools efficiently. Directly related to replacement algorithms in virtual memory!
  - - Some pointers to supplementary material.
- Multiparadigm Programming: 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. LC++ is its small sibling.
- - "Functional Programming with the FC++ library" (Journal of Functional Programming)
  - - "Functional Programming in C++" (ICFP'00): the original FC++ paper
  - "FC++: Functional Tools for OO Tasks" (Software Practice & Experience) shows how common OO programming tasks benefit from FC++
  - The FC++ Web page contains pointers to more FC++ publications and information
  - Also related: "Static Interfaces in C++" (2000 C++ Template Programming Workshop): How can we enforce interface requirements in C++?
- Object-Oriented components: My Ph.D. proposed the concept of "mixin layers". A mixin layer is a static component encapsulating fragments of several different classes (mixins) so that all fragments are composed consistently. Mixin layers are an elegant implementation technique for layered designs.
- - "Implementing Layered Designs with Mixin Layers": the original mixin layers paper from ECOOP'98
  - "Implementing Large-Scale Object-Oriented Components" (Ph.D. Dissertation)
  - "Mixin Layers: An Object-Oriented Implementation Technique for Refinements and Collaboration-Based Designs" (ACM TOSEM)
  - "Mixin-Based Programming in C++" (GCSE'00)
  - "Layered Development with (Unix) Dynamic Libraries" (ICSR'02): Unix dynamic libraries (shared objects) offer great support for layered programming
  - - source code

Non-Technical:

"Effectiveness of Anonymization in Double-Blind Review" (CACM, Jun'18)
Why do a Ph.D. and how to pick an area (update of older "Ph.D. Rants and Raves")
Yannis's law: Programmer Productivity Doubles Every 6 Years. (Yes, I'm only half serious, but half is enough.)
My (favorite) academic humor