@misc{, author = "Bruno C. d. S. Oliveira, Tom Schrijvers and William R. Cook", month = "July", note = "Draft Paper. Technical report of the POPL submission.", title = "EffectiveAdvice: Disciplined Advice with Explicit Effects", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/techreport.pdf", year = "2009", } @inproceedings{, author = "Meng Wang and Bruno C. d. S. Oliveira", booktitle = "Proceedings of the ACM SIGPLAN Workshop on Generic Programming (WGP'09)", editor = "Patrik Jansson", journal = "Workshop on Generic Programming (WGP'09)", month = "August", title = "What does Aspect-Oriented Programming mean for Functional Programmers?", year = "2009", } @misc{, author = "Bruno C. d. S. Oliveira", note = "Draft Paper. Last Update: 04/03/2009. Submitted to ICFP 2009.", title = "The Different Aspects of Monads and Mixins", year = "2009", } @inproceedings{, author = "Bruno C. d. S. Oliveira", booktitle = "23rd European Conference on Object Oriented Programming (ECOOP)", editor = "Sophia Drossopoulou", journal = "23rd European Conference on Object Oriented Programming (ECOOP)", location = "Genova, Italy", month = "July", title = "Modular Visitor Components: A Practical Solution to the Expression Families Problem", year = "2009", } @article{gibbons09essence, abstract = "The ITERATOR pattern gives a clean interface for element-by-element access to a collection, in- dependent of the collection's shape. Imperative iterations using the pattern have two simultaneous aspects: mapping and accumulating. Various existing functional models of iteration capture one or other of these aspects, but not both simultaneously. We argue that McBride and Paterson's applicative functors, and in particular the corresponding traverse operator, do exactly this, and therefore capture the essence of the ITERATOR pattern. Moreover, they do so in a way that nicely supports modular programming. We present some axioms for traversal, discuss modularity concerns, and illustrate with a simple example, the wordcount problem.", author = "Jeremy Gibbons and Bruno C. d. S. Oliveira", editor = "Conor McBride and Tarmo Uustalo", issn = "3-4", journal = "Journal of Functional Programming", month = "July", pages = "377-402", title = "The Essence of The Iterator Pattern", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/iterator-jfp.pdf", volume = "19", year = "2009", } @inproceedings{, abstract = "Datatype-generic programming involves parametrization by the shape of data, in the form of type constructors such as `list of'. Most approaches to datatype-generic programming are developed in the lazy functional programming language Haskell. We argue that the functional object-oriented language Scala is in many ways a better setting. Not only does Scala provide equivalents of all the necessary functional programming features (such parametric polymorphism, higher-order functions, higher-kinded type operations, and type- and constructor-classes), but it also provides the most useful features of object-oriented languages (such as subtyping, overriding, traditional single inheritance, and multiple inheritance in the form of traits). We show how this combination of features benefits datatype-generic programming, using three different approaches as illustrations.", author = "Bruno C. d. S. Oliveira and Jeremy Gibbons", booktitle = "Proceedings of the ACM SIGPLAN Workshop on Generic Programming (WGP'08)", editor = "Ralf Hinze", journal = "Workshop in Generic Programming", month = "September", title = "Scala for Generic Programmers", url = "http://web.comlab.ox.ac.uk/people/Bruno.Oliveira/ScalaGeneric.pdf", year = "2008", } @unpublished{, author = "Bruno C. d. S. Oliveira and Martin Sulzmann", month = "April", note = "Submitted to ICFP 2008", title = "Objects to Unify Type Classes and GADTs", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/objects.pdf", year = "2008", } @inproceedings{, author = "Alexey Rodriguez, Johan Jeuring, Patrik Jansson, Alex Gerdes, Oleg Kiselyov, Bruno C. d. S. Oliveira", booktitle = "ACM SIGPLAN Haskell Symposium", editor = "Andy Gill", month = "April", title = "Comparing Libraries For Generic Programming In Haskell", url = "http://www.cs.uu.nl/wiki/pub/Alexey/ComparingLibrariesForGenericProgrammingInHaskell/paper.pdf", year = "2008", } @inproceedings{oliveira08visitor, abstract = "The VISITOR design pattern shows how to separate the structure of an object hierarchy from the behaviour of traversals over that hierarchy. The pattern is very flexible; this very flexibility makes it difficult to capture the pattern as anything more formal than prose, pictures and prototypes. We show how to capture the essence of the VISITOR pattern as a reusable software library, by using advanced type system features appearing in modern object-oriented languages such as Scala. We preserve type-safety statically: no reflection or similar mechanisms are used. The library is generic, in two senses: not only is it parametrised by both the return type and the shape of the object hierarchy, but also it allows a number of implementation choices (internal versus external control, imperative versus functional behaviour, orthogonal aspects such as tracing and memoisation) to be specified by parameters rather than fixed in early design decisions. Finally, we propose a generalised datatype-like notation, on top of our visitor library: this provides a convenient functional decomposition style in object-oriented languages.", author = "Bruno C. d. S. Oliveira, Meng Wang, and Jeremy Gibbons", booktitle = "Proceedings of the 23rd Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)", editor = "Gregor Kiczales", journal = "Proceedings of the 23rd Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications", location = "Nashville, Tennessee, US", month = "October", title = "The Visitor Pattern as a Reusable, Generic, Type-Safe Component", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/Visitor.pdf", year = "2008", } @inproceedings{, abstract = "A generic function is a function that is defined on the structure of data types: with a single definition, we obtain a function that works for many data types. In contrast, an ad-hoc polymorphic function requires a separate implementation for each data type. Previous work by Hinze on lightweight generic programming has introduced techniques that allow the definition of generic functions directly in Haskell. A severe drawback of these approaches is that generic functions, once defined, cannot be extended with ad-hoc behaviour for new data types, precluding the design of an extensible and modular generic programming library based on these techniques. In this paper, we present a revised version of Hinze's Generics for the masses approach that overcomes this limitation. Using our new technique, writing an extensible and modular generic programming library in Haskell 98 is possible.", author = "Bruno C. d. S. Oliveira, Ralf Hinze, and Andres Loeh", booktitle = "Trends in Functional Programming (TFP 2006)", editor = "Henrik Nilsson", location = "University of Nottingham, UK", month = "April", note = "best student paper award", title = "Extensible and Modular Generics for the Masses", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/extensibleGM.pdf", year = "2007", } @conference{gibbons07generic, abstract = "The EPSRC-funded Generic and Indexed Programming project will explore the inter- action between datatype-generic programming (DGP) --- programs parametrized by the shape of their data --- and indexed programming (IP) --- lightweight dependently- typed programming, with programs indexed by type-level representations of proper- ties. Integrating these two notions will provide new ways for programmers to capture abstractions. The project builds on insights from our recent work in DGP, which has investi- gated both programming techniques (including reasoning about generic programs, and using them to capture design patterns precisely), and language mechanisms (particularly lightweight approaches: patterns for simulating highly-expressive tech- niques in familiar but apparently less-expressive languages). Firstly, these lightweight techniques, which we have been embedding in Haskell's still relatively expressive type system, are in fact applicable to even less expressive but more popular main- stream languages such as Java and C#. Secondly, the techniques are more applicable than we first thought; in particular, they offer a solution to the so-called "expression problem": safe combination of independent extensions along multiple dimensions. Thirdly, there is a synergy between DGP and IP: DGP makes IP more appealing, because the effort of stating properties can be amortized over more programs; IP provides a mechanism for DGP, because the indices can be representations of data?s shape. ", author = "Jeremy Gibbons, Meng Wang and Bruno C. d. S. Oliveira", booktitle = "Trends in Functional Programming (TFP 2007)", editor = "Marco T. Morazan and Henrik Nilsson", location = "New York, USA", month = "April", title = "Generic and Indexed Programming", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/gip.pdf", year = "2007", } @conference{zhang07scalable, abstract = "Problem localization is a critical part of providing crucial system management capabilities to modern distributed environments. One key open challenge is for problem localization solutions to scale for systems containing hundreds or even thousands of nodes, whilst still remaining fast enough to respond to rapid environment changes and sufficiently cost-effective to avoid overloading any manage- ment or application component. This paper meets the challenge by introducing two scalable frameworks applicable to a wide range of existing problem localization solutions: one based on a summary- driven, narrow-down procedure, the other through decomposing and decentralizing the problem localization process. Both frame- works, at their best, are able to achieve O(logN ) problem local- ization time and O(1) per node communication load. The contrast- ing natures of both frameworks provide them with complimentary strengths that make them suitable for different scenarios in prac- tice. We demonstrate our approaches in simulation settings and two real-world environments and show promising scalability bene- fits that can make a difference in system management operations.", author = "Rui Zhang, Bruno C. d. S. Oliveira, Alan Bivens, Steve McKeever", booktitle = "ACM International Conference Proceedings of the Second International Conference on Scalable Information Systems (Infoscale'07)", institution = "ACM", journal = "ACM International Conference Proceedings of the Second International Conference on Scalable Information Systems (Infoscale'07)", location = "Suzhou, China", month = "June", title = "Scalable Problem Localization for Distributed Systems: Principles and Practices", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/infoscale.pdf", year = "2007", } Warning - the bibtex entry below may be invalid: Missing 'school' field @phdthesis{oliveira07genericity, author = "Bruno C. d. S. Oliveira", title = "Genericity, extensibility and type-safety in the Visitor pattern", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/Thesis.pdf", year = "2007", } @inproceedings{, abstract = "A generic function is a function that is defined on the structure of data types: with a single definition, we obtain a function that works for many data types. In contrast, an ad-hoc polymorphic function requires a separate implementation for each data type. Previous work by Hinze on lightweight generic programming has introduced techniques that allow the definition of generic functions directly in Haskell. A severe drawback of these approaches is that generic functions, once defined, cannot be extended with ad-hoc behaviour for new data types, precluding the design of an extensible and modular generic programming library based on these techniques. In this paper, we present a revised version of Hinze's Generics for the masses approach that overcomes this limitation. Using our new technique, writing an extensible and modular generic programming library in Haskell 98 is possible.", author = "Bruno C. d. S. Oliveira, Ralf Hinze, and Andres Loeh", booktitle = "Trends in Functional Programming (TFP 2006)", editor = "Henrik Nilsson", location = "University of Nottingham, UK", month = "April", note = "Draft Proceedings", title = "Generics as a Library", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/Generics.pdf", year = "2006", } @inproceedings{, abstract = "The paper "Scrap your boilerplate" (SYB) introduces a combinator library for generic programming that offers generic traversals and queries. Classically, support for generic programming consists of two essential ingredients: a way to write (type-)overloaded functions, and independently, a way to access the structure of data types. SYB seems to lack the second. As a consequence, it is difficult to compare with other approaches such as PolyP or Generic Haskell. In this paper we reveal the structural view that SYB builds upon. This allows us to define the combinators as generic functions in the classical sense. We explain the SYB approach in this changed setting from ground up, and use the understanding gained to relate it to other generic programming approaches. Furthermore, we show that the SYB view is applicable to a very large class of data types, including generalized algebraic data types. ", author = "Ralf Hinze, Andres Loeh, and Bruno C. d. S. Oliveira", booktitle = "Functional and Logic Programming (FLOPS 2006)", editor = "Philip Wadler and Masami Hagiya", location = "Fuji Susono, Japan", month = "April", title = ""Scrap Your Boilerplate" Reloaded", url = "http://people.cs.uu.nl/andres/SYB0.html", year = "2006", } @conference{gibbons06essence, author = "Jeremy Gibbons and Bruno C. d. S. Oliveira", booktitle = "Workshop on Mathematically Structured Functional Programming (MSFP 2006)", editor = "Conor McBride and Tarmo Uustalu", location = "Kuressaare, Estonia", month = "July", title = "The Essence of The Iterator Pattern", url = "http://www.comlab.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf", year = "2006", } @inproceedings{, abstract = "A type-indexed function is a function that is defined for each member of some family of types. Haskell's type class mechanism provides collections of open type-indexed functions, in which the indexing family can be extended by defining a new type class instance but the collection of functions is fixed. The purpose of this paper is to present TypeCase: a design pattern that allows the definition of closed type-indexed functions, in which the index family is fixed but the collection of functions is extensible. It is inspired by Cheney and Hinze's work on lightweight approaches to generic programming. We generalise their techniques as a design pat- tern. Furthermore, we show that type-indexed functions with type- indexed types, and consequently generic functions with generic types, can also be encoded in a lightweight manner, thereby overcoming one of the main limitations of the lightweight approaches. ", author = "Bruno C. d. S. Oliveira and Jeremy Gibbons", booktitle = "ACM SIGPLAN Haskell Workshop (HW'05)", editor = "Daan Leijen", location = "Tallinn, Estonia", month = "September", title = "TypeCase: A Design Pattern for Type-Indexed Functions", url = "http://www.comlab.ox.ac.uk/people/Bruno.Oliveira/typecase.pdf", year = "2005", }