Introduction
Consolidation
Exploration Integration
Conclusion
(dynamic (programming paradigms))
;; performance and expressivity
e Habilitation Defense E
Didier Verna
July 10 2020
Robert Strandh University of Bordeaux, France reporter
Nicolas Neuß FAU, Erlangen-Nürnberg, Germany reporter
Manuel Serrano INRIA, Sophia Antipolis, France reporter
Marco Antoniotti University of Milano-Bicocca, Italy examiner
Ralf Möller University of Lübeck, Germany examiner
Gérard Assayag IRCAM, Paris, France examiner
Introduction
Consolidation
Exploration Integration
Conclusion
Context
I
Multi-Paradigm Landscape Today
I
Mostly heterogeneous
Historic reasons
Bad for software evolution and maintainability
I
Special Interests
I
Homogeneousness, dynamicity & interaction
I
OO, FP, Extensibility, reexivity, meta-programming
I
Challenges
I
Expressivity in homogeneous multi-paradigm environments
Orthogonality / SoC is of the essence
I
Performance in dynamic environments
Impact, negative or positive
I
Experimentation Platform: Lisp
I
Subjectively: core minimalism, homoiconicity, pragmatic dialect
I
Objectively: paradigms “on steroids”, ocial industrial standard
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 2/42
Lisp, Jazz, Aikido
Verna, D., The Art, Science and
Engineering of Programming
Journal, 2018.
Introduction
Consolidation
Exploration Integration
Conclusion
Timeline
2010 2020
Consolidation
Exploration
Integration
1. Consolidation
I
Assert performance and expressivity
I
Fill in the academic bibliographic gap (cf. ELS)
2. Exploration
I
Paradigm application, extension, or design
I
Performance and/or expressivity in mind
3. Integration
I
Comparative assessment, paradigm junction
I
Inward / outward propagation
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 3/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Performance: Optional Type Annotations
Expressivity: Multiple Dispatch, Generic Functions, and the MOP
Exploration
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 4/42
Introduction
Consolidation
Exploration Integration
Conclusion
Performance: Static vs. Dynamic
I
Lisp static type annotations (weak)
I
Gradual typing (Siek 2006, strong)
Beating C in Scientic
Computing Applications
Verna, D., European Lisp
Workshop, 2006.
CLOS Eciency:
Instantiation
Verna, D., International Lisp
Conference, 2009.
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 5/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Performance: Optional Type Annotations
Expressivity: Multiple Dispatch, Generic Functions, and the MOP
Exploration
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 6/42
Introduction
Consolidation
Exploration Integration
Conclusion
Expressivity: Multi-Methods and GF’s
I
Multi-Methods
I
method (cls1 this, cls2 that, ...) {};
I
Generic Functions
I
Methods external to classes
I
Reied set of congruent & eponymous (multi-)methods
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 7/42
Introduction
Consolidation
Exploration Integration
Conclusion
SoC: Multi-Methods and GF’s
class
state
behavior
class
state
behavior
subclass
state
behavior
subclass
state
behavior
subclass
state
behavior
subclass
state
behavior
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 8/42
Introduction
Consolidation
Exploration Integration
Conclusion
SoC: Multi-Methods and GF’s
class
state
class
state
subclass
state
subclass
state
subclass
state
subclass
state
generic function
multi-methods
generic function
multi-methods
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 9/42
Introduction
Consolidation
Exploration Integration
Conclusion
Binary Methods / Functions
Classical OO
rgb
red, green, blue
= (rgb)
rgba
alpha
= (rgba)
With generic functions
rgb
red, green, blue
rgba
alpha
=
(rgb, rgb)
(rgba, rgba)
I
Cf. Bruce (1995), Castagna (1995, 2018), etc.
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 10/42
Introduction
Consolidation
Exploration Integration
Conclusion
Expressivity: the MOP
I
Safety: Protect Against Non-Conformance
I
Binary function usage
No bogus call (2 arguments, same class)
I
Binary function implementation
No bogus method (2 arguments, same class)
No missing method
I
Tools
I
Introspection (reasonable requirement: dynamic + functional)
I
Meta-Object Protocol (cherry on the cake)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 11/42
Introduction
Consolidation
Exploration Integration
Conclusion
SoC: the MOP
=
= behavior
no bogus call
no bogus method
no missing method
binary function 1
behavior 1
no bogus call
no bogus method
no missing method
binary function 2
behavior 2
no bogus call
no bogus method
no missing method
The object layer is implemented in itself
I
State = classes & instances ⇒ hierarchies extension
I
Behavior = generic functions ⇒ methods specialization
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 12/42
Introduction
Consolidation
Exploration Integration
Conclusion
SoC: the MOP
generic functions class
binary functions class
=
= behavior
binary function 1
behavior 1
binary function 2
behavior 2
generic calls
no bogus call
add methods
no bogus method
get applicable ones
no missing method
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 13/42
Introduction
Consolidation
Exploration Integration
Conclusion
Expressivity
I
Multi-paradigm & extended OO for SoC
Binary Methods
Programming: the CLOS
Perspective
Verna, D., Journal of
Universal Computer
Science, 2008.
Revisiting the Visitor: the
Just Do It Pattern
Verna, D., Journal of
Universal Computer
Science, 2010.
Extensible Languages:
Blurring the Distinction
between DSLs and GPLs
Verna, D., Formal and
Practical Aspects of
Domain Specic Languages:
Recent Developments,
chapter 1, 2012.
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 14/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Exploration
Paradigm Application: Context-Oriented Optimization
Paradigm Extension: Method Combinators
Paradigm Design: Rational Type Expressions
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 15/42
Introduction
Consolidation
Exploration Integration
Conclusion
Motivation
I
Expressivity
1. One thing, many dierent forms
2. One form, many dierent things
I
Genericity: case #2
I
E.g. write algorithms once, structural & behavioral details omitted
I
Note: intensional polymorphism
I
Problem: Genericity vs. Classical OO Design
I
Object model cluttering (class / method proliferation)
I
Missed optimization opportunities (cross-cutting)
I
Performance degradation (dynamic dispatch)
I
Solution: Generative Meta-Programming
4 Eciency (fully-dedicated code)
8 Maintainability (w/o code)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 16/42
Introduction
Consolidation
Exploration Integration
Conclusion
Motivation
I
Expressivity
1. One thing, many dierent forms
2. One form, many dierent things
I
Genericity: case #2
I
E.g. write algorithms once, structural & behavioral details omitted
I
Note: intensional polymorphism
I
Problem: Genericity vs. Classical OO Design
I
Object model cluttering (class / method proliferation)
I
Missed optimization opportunities (cross-cutting)
I
Performance degradation (dynamic dispatch)
I
Solution: Generative Meta-Programming
4 Eciency (fully-dedicated code)
8 Maintainability (w/o code)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 17/42
template <template <class> class M, typename T, typename V>
struct ch_value_ <M <tag::value_<T>>, V>
{ typedef M<V> ret; };
template <template <class> class M, typename I, typename V>
struct ch_value_ <M <tag::image_<I>>, V>
{ typedef M <mln_ch_value(I, V)> ret; };
template <template <class, class> class M, typename T,
typename I, typename V>
struct ch_value_ <M <tag::value_<T>, tag::image_<I>>, V>
{ typedef mln_ch_value(I, V) ret; };
template <template <class, class> class M, typename P,
typename T, typename V>
struct ch_value_ <M <tag::psite_<P>, tag::value_<T>>, V>
{ typedef M<P, V> ret; };
Introduction
Consolidation
Exploration Integration
Conclusion
Motivation
I
Expressivity
1. One thing, many dierent forms
2. One form, many dierent things
I
Genericity: case #2
I
E.g. write algorithms once, structural & behavioral details omitted
I
Note: intensional polymorphism
I
Problem: Genericity vs. Classical OO Design
I
Object model cluttering (class / method proliferation)
I
Missed optimization opportunities (cross-cutting)
I
Performance degradation (dynamic dispatch)
I
Solution: Generative Meta-Programming
4 Eciency (fully-dedicated code)
8 Maintainability (w/o code)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 18/42
(BLOCK NIL
(LET ((I 0))
(DECLARE (TYPE (AND FIXNUM REAL) I))
(LET ((J 1))
(DECLARE (TYPE FIXNUM J))
(SB-LOOP::WITH-SUM-COUNT #S(SB-LOOP::LOOP-COLLECTOR ...)
(TAGBODY
(WHEN (>= I '10) (GO SB-LOOP::END-LOOP))
SB-LOOP::NEXT-LOOP
(SETQ #:LOOP-SUM-578 (+ #:LOOP-SUM-578 (* I J)))
(SB-LOOP::LOOP-DESETQ I (1+ I))
(WHEN (>= I '10) (GO SB-LOOP::END-LOOP))
(SB-LOOP::LOOP-DESETQ J (1+ J))
(GO SB-LOOP::NEXT-LOOP)
SB-LOOP::END-LOOP
(RETURN-FROM NIL #:LOOP-SUM-578))))))
Introduction
Consolidation
Exploration Integration
Conclusion
Motivation
I
Expressivity
1. One thing, many dierent forms
2. One form, many dierent things
I
Genericity: case #2
I
E.g. write algorithms once, structural & behavioral details omitted
I
Note: intensional polymorphism
I
Problem: Genericity vs. Classical OO Design
I
Object model cluttering (class / method proliferation)
I
Missed optimization opportunities (cross-cutting)
I
Performance degradation (dynamic dispatch)
I
Solution: Generative Meta-Programming
4 Eciency (fully-dedicated code)
8 Maintainability (w/o code)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 19/42
Can we be both generic and ecient within a classical
OO design, without cluttering the model, and without
missing cross-cutting optimization opportunities?
Introduction
Consolidation
Exploration Integration
Conclusion
Context-Oriented Programming
Denition
“[…] abstractions and mechanisms to concisely represent behavioral
variations that depend on execution context”
I
Behavioral variation
I
New / removed / modied behavior or structure
I
Partial denitions for software components
I
Layers
I
Gather related context-dependent variations
I
First class citizens
I
Context
I
Reied by sets of simultaneously active layers
I
Dynamic, late, run-time (de-)activation
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 20/42
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Static type annotations
rgb
red
green
blue
to-grayscale
(rgb)
(int-rgb)
(float-rgb)
int-rgb
red: int
green: int
blue: int
oat-rgb
red: oat
green: oat
blue: oat
I
Dynamic types ⇒ polymorphic operations (slow)
I
Subclassing ⇒ class proliferation & not cross-cutting (bad)
=⇒ Value types as contextual information
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 21/42
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Value type layers
rgb (default layer)
red
green
blue
to-grayscale (default layer)
(rgb)
rgb (int layer)
red: int
green: int
blue: int
to-grayscale (int layer)
(rgb)
rgb (oat layer)
red: oat
green: oat
blue: oat
to-grayscale (oat layer)
(rgb)
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 22/42
Introduction
Consolidation
Exploration Integration
Conclusion
Context-Oriented Optimization
I
COP “perversion”
I
Originally meant for pervasive and ubiquitous computing
I
Opposite of “type erasure”
Generic Image
Processing with Climb
Senta, L., Chedeau, C., and
Verna, D., European Lisp
Symposium, 2012.
Context-Oriented
Image Processing
Verna, D. and Ripault, F,
Context-Oriented Programming
Workshop, 2015.
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 23/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Exploration
Paradigm Application: Context-Oriented Optimization
Paradigm Extension: Method Combinators
Paradigm Design: Rational Type Expressions
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 24/42
Introduction
Consolidation
Exploration Integration
Conclusion
Method Combinations
Classical dispatch
Hierarchy
method 4
method 3
method 2
method 1
Applicable
method 4
method 2
method 1
l
call
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 25/42
Introduction
Consolidation
Exploration Integration
Conclusion
Method Combinations
Combined dispatch
Hierarchy
method 4
method 3
method 2
method 1
Applicable
method 4
method 2
method 1
l
call
I
Built-in & programmable
I
Method categories (qualiers)
I
Selection & execution order
I
Participation in the nal result
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 26/42
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Classical dispatch
class1
class2
class3
= (class1, class1)
= (class2, class2)
= (class3, class3)
and call next
and call next
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 27/42
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Combined dispatch
class1
class2
class3
(= class1 class1)
(= class2 class2)
(= class3 class3)
and
count
list
I
SoC: methods code / ad-hoc dispatch code
I
Combinator SoC: generic function / method combination
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 28/42
Introduction
Consolidation
Exploration Integration
Conclusion
Method Combination Problems
I
Loose Specication
I
Lack of orthogonality (notably short forms)
I
Lack of structure (no ocial meta-objects)
I
Unclear, inconsistent or contradictory (meta-object) protocols
I
Improvement
I
SoC: method combinations as truly global objects
I
Generic function / method combination consistency w.r.t.
redenitions
I
Extension: alternative combinations
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 29/42
Method Combinators
Verna, D., European Lisp Symposium,
2018.
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Combined dispatch
class1
class2
class3
(= class1 class1)
(= class2 class2)
(= class3 class3)
and
count
list
I
SoC: methods code / ad-hoc dispatch code
I
Combinator SoC: generic function / method combination
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 30/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Exploration
Paradigm Application: Context-Oriented Optimization
Paradigm Extension: Method Combinators
Paradigm Design: Rational Type Expressions
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 31/42
Introduction
Consolidation
Exploration Integration
Conclusion
Heterogeneous Sequences Type Checking
I
History
I
2009
;; #### NOTE: this is where I would like a more
;; expressive dispatch in CLOS. There's in fact
;; two cases below, depending on HELP-SPEC's CAR.
(:method (sheet (help-spec list))
I
2016: Jim Newton’s Ph.D.
I
Problem
I
Dynamic typing allows heterogeneous sequences
I
Optimization for homogeneous sequences
I
What about heterogeneous yet regular sequences?
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 32/42
Introduction
Consolidation
Exploration Integration
Conclusion
Principle
1. Express type regularities as rational expressions
I
(string . symbol* . number) ⇐ ("foo" bar baz 42)
2. Provide a concrete denotation
I
(:. string (:* symbol) number)
3. Plug it into the type system
I
(typep value (and list (rte (:. string (:* symbol) number))))
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 33/42
Introduction
Consolidation
Exploration Integration
Conclusion
Example
Ad-hoc destructuring
(typecase elt1
(type1 (typecase elt2
(type1 ...)
(type2 ...)
...))
(type2 (typecase elt2
(type1 ...)
(type2 ...)
...))
...)
RTE destructuring
(rte-case whole-sequence
(rte-type-1 ...)
(rte-type-2 ...)
...)
I
SoC: sequence
pattern-matching code vs.
contents processing
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 34/42
Introduction
Consolidation
Exploration Integration
Conclusion
Rational Type Expressions
Type Checking of
Heterogeneous
Sequences in
Common Lisp
Newton, J.E.,
Demaille, A., and
Verna, D., European
Lisp Symposium,
2016.
Programmatic
Manipulation of
Common Lisp Type
Speciers
Newton, J.E.,
Verna, D., and
Colange, M.,
European Lisp
Symposium, 2017.
Strategies for
Typecase
Optimization
Newton, J.E., and
Verna, D., European
Lisp Symposium,
2018.
Recognizing
Hetergeneous
Sequences by
Rational Type
Expression
Newton, J.E., and
Verna, D.,
Workshop on
Meta-Programming
and Reection,
2018.
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 35/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Exploration
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 36/42
Introduction
Consolidation
Exploration Integration
Conclusion
Comparative Assessment
The case of Context-Oriented Optimization
I
Expressivity: Related Paradigms
I
Aspect-Oriented Programming (Kiczales et al., 1997)
I
Mixin Layers (Smaragdakis and Batory, 2001)
I
Performance: Related Solutions
I
Generative Meta-Programming
I
JIT Compilation / Hotspot Detection
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 37/42
Introduction
Consolidation
Exploration Integration
Conclusion
Paradigm Junction
The case of RTE
Dynamic dispatch
method (arg0, arg1, arg2, ...);
class
eql
rte
predicates
lters
Nominal & structural types
Aggregate
string
symbol
number
+
Ordering
↓
= (rte (:. string (:* symbol) number))
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 38/42
Introduction
Consolidation
Exploration Integration
Conclusion
Blue Sky Territory OO Integration
I
Specialization on optional / keyword arguments
I
Coexistence of prototypes & classes
I
Types vs. classes separation (cf. POOL, Cecil, Diesel)
Implementing Baker’s SUBTYPEP Decision Procedure
Valais, L., Newton, J.E., and Verna, D., European Lisp Symposium,
2019.
2010 2020
Consolidation
Exploration
Integration
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 39/42
Introduction
Consolidation
Exploration Integration
Conclusion
Outline
Introduction
Consolidation
Exploration
Integration
Conclusion
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 40/42
Introduction
Consolidation
Exploration Integration
Conclusion
Wrap Up
Type annotations
rgb
red: int
green: int
blue: int
Context
rgba
alpha: int
MOP
generic functions
binary functions
Multiple dispatch
=
(rgb, rgb)
(rgba, rgba)
rgb (oat layer)
red: oat
green: oat
blue: oat
rgba (oat layer)
alpha: oat
= (oat layer)
(rgb, rgb)
(rgba, rgba)
Combinations
and
Regular type epxressions
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 41/42
Introduction
Consolidation
Exploration Integration
Conclusion
Conclusion
I
An overview of 14 years of work (9 years full-time equivalent)
I
One book chapter, 4 journal papers, 24 conference papers, >30
other presentations
I
One completed Ph.D., 5 Masters internships, >10 undergraduates
Thank you!
(dynamic (programming paradigms)) ;; performance and expressivity / Habilitation Defense – Didier Verna 42/42