This project was born after finding myself reviewing my research papers time after time. At some point I thought: I'd rather review someone else's work and have that person review mine.
This is a perfect match for a crowd-sourced platform, as you ask for another user's time and expertise (hopefully, orthogonal to yours), and you give back your own knowledge and time by reviewing others' work.
So many types of documents out there in the world would be improved by having a fresh pair of eyes look at them. DocRev is meant to provide that for free.
Online voting is still deemed with disregard by most people. Yet, we already know how to do it, thanks to years of research in academica.
This prototype assembles most of the needed machinery to deploy an online voting platform while ensuring: integrity of the votes, their confidentiality, uniqueness of the votes, anonymity of the voters, audibility of an election, and non coercion for the voters.
I built this web-based application to manage the related work of my M.Sc. thesis. My objective was to be able to search across a set of papers, find who cited who among them, and what each author said when citing another paper.
As a result, whenever I needed to cite a paper, I could quickly find the portions of other papers that had already cited that paper.
The Fenix Framework provides a transactional and persistent domain model for web-based applications. Think of it as an ORM where persistence is handled transparently (in contrast with, let's say Hibernate). It is used in FenixEdu across several universities.
During my Ph.D. I contributed with pluggable Abstract Data Types (code), efficient retrieval from collections via Indexes (code), and an Object Cache to speed up accesses in distributed deployments (code).
The STI-BT is a highly scalable, transactional index for Distributed Key-Value stores.
STI-BT is organized as a distributed B+Tree and adopts an innovative design that allows to achieve high efficiency in large-scale, elastic DKV stores.
It is meant to act as a secondary index for such stores where the primary interface is a simple key-value access.
Distributed Serializable transactions typically abort (and restart) if part of its read-set is modified concurrently by another transaction.
However, although sufficient for serializability, it is not necessary to do so.
In this implementation, in the GMU protocol in Infinispan, the transactions use the notion of time-warp to abort only in stricter conditions that are still sufficient to ensure serializability.
As a result, transactions abort less than they would normally.
The recent trend of multi-core CPUs forces developers to embrace concurrency to chase high performance.
Although locks are widely used, they are not necessarily the best choice. This benchmark study provides several Transactional Memory implementations (in Software, Hardware and Hybrid) to compare with other lock-based schemes in various applications.
It allows to measure efficiency both from a performance as well as power consumed point of views.
TPC-C is a widely used application to benchmark database management systems.
To a large extent, its focus is on stressing the concurrency control of such systems. As a result, it is also a good candidate to evaluate similar concerns for in-memory shared data, namely for systems that use Transactional Memory.
As such, this is a rough porting of TPC-C that targets the JVSTM API.
In Transactional Memory code is speculatively executed in parallel with safety checks in place (and possible roll-backs) when correctness cannot be guaranteed (i.e., the execution would not be equivalent to a serial one).
However, in some cases running more concurrent transactions may harm performance.
Parallel Nested Transactions allow to explore the parallelism within a transaction, thus allowing to run less transactions at a time, but with each one taking up several cores. As such, the end result is that we may still explore all the hardware parallelism but we get less aborts and roll-backs.
The JVSTM implementation provided lock-free transactions and Per-Tx Boxes (an abstraction for code that would never abort a transaction, despite running transactionally).
For a long time the Per-Tx Boxes were disabled in the lock-free version, because of the antagonistic nature of a lock-free transactional commit (that may be repeated in face of concurrent progress) and that of abort-free Per-Tx Boxes.
To solve this, I contributed with a design that allows for lock-free speculative execution of the Per-Tx Boxes: think of it as mini-transactions inside the commit of a transaction.
The availability of Transactional Memory in commodity Intel processors is a remarkable feat for the evolution of concurrent programming.
Yet, during my research I concluded that the current (and forseeable) implementations of Hardware Transactional Memory (such as Intel RTM) are prone to being sub-optimal and requiring extensive manual tuning.
In this work I explore simple reinforcement learning techniques to self-tune the Transactional Memory implementation and provide close to optimal performance. I am also working to have this patched into the next release of GCC.
There are many designs and implementations of Transactional Memory, and that is not a coincidence: different ones perform best on different workloads.
One cannot expect the developer to be aware of such concerns, as it is even contradictory with the simplicity advocated by the use of the transactional abstraction.
With ProteusTM, the developer writes transactions (using the C++ construct), and the underlying implementation (inside the GCC) uses Recommendation Systems techniques to automatically change Transactional Memory algorithms, parallelism degree, and others.
Programming is becoming an ubiquitous skill that most people should learn. Ideally, kids should even start learning it back in school.
Naturally, for such early ages, it becomes much more appealing to learn something by playing a game.
That was exactly the idea here: to develop a puzzle game where the user is actually building a program to solve the challenge.
At the time we proposed this as the first smartphone application of the kind.
Understanding chords and musical notes from a recording is a tough job. However, it is really appealing to just grab your guitar and play without connecting it to any special device that will parse the vibrations and correctly understand everything.
This Android app does exactly the opposite: it uses the smartphone microphone and parses the chords and notes from the audio alone.
As a result, it can challenge users to play a song and then evaluate the accuracy with which it was played.
Ever had the problem of parking your car and then forgetting to go back and place coins in the meter to avoid fines?
Well, everyone has that problem. The idea of this prototype is to have a consolidated infrastructure where mobile (and web) users may report their car parking location as well as that of authorities within the area. As a result, we may notify users to remember them to legalize their parking situation.
This encompasses an Android app where users subscribe their parking location and notify the presence of possible workers about to fine a car.
Also a web-based application that replicates all that behaviour and a backend exposing a REST API that is used by both web and Android-based apps.
The idea of this project is to expose a transactional construct in Java that is implemented inside the virtual machine. As such, programmers would only need to annotate pieces of code as atomic, and the JVM would take care of the rest, providing serializable executions despite transactions running in the application concurrently.
The execution of this idea extends the open-source JVM called JamVM so that it interprets such pieces of code correctly and relies on a Software Transactional Memory (called TinySTM) to synchronize the transactions.
The JamVM interpreter is highly optimized with inline-threading and stack-caching. It was thus a challenge on par with a simple JIT. In retrospective it would have been simpler to do this in Jikes, for instance.
Allows to extract the references from an article in PDF format.
Provides the context of the citation, i.e., the body of the text where the reference is used.
I have used this in personal projects to create a graph of citations among the related work of my research. This way, I could easily fetch, for instance, what other authors said when they cited some paper that I also wanted to cite now.