Alicia Boya García

This is an information retrieval and visualization tool designed for fast exploration of High Energy Physics data set. It was developed as my master's degree final year project in collaboration with CERN.

In the backend, the application features an ElasticSearch index populated with data tables from all scholarly publishing from HEPData dating from 1960 to the present. New data can be added or updated incrementally in a few seconds.

In the frontend, a recursive filter interface allows querying data matching arbitrary expressions. The interface aims to be easy and efficient, featuring drag and drop controls and autocompletion.

This framework provides base architecture that eases the development of WebSocket servers for real-time applications. On top of that you use or extend services that provide functionality as RPC, PubSub or user chats.

The greatest feature of Snorky is its DataSync service that makes easy to synchronize data between a database server of any kind and a web client in a safe and efficient way.

Snorky can be used along with any other frameworks or languages, but shines specially when used in combination with the Django ORM for data access, Django REST Framework for data queries and AngularJS for frontend development.

This is my master's thesis, in which I detail how HEPData Explore (mentioned above) was created.

This is my bachelor's thesis, in which I describe how the development of Snorky was done.

This library generates TypeScript definitions that cover a set of Kotlin and Java classes using Kotlin reflection.

TypeScript definitions are useful when data classes are serialized to JSON and handled in a JavaScript or TypeScript web frontend as they enable context-aware type checking and autocompletion in a number of IDEs and editors.

Many features of these languages are supported and transpiled just fine, including Kotlin data classes, object inheritance, null-safe types, generic types, arrays and associative objects. A transformer API is provided in order to handle more complex scenarios where property names or types need to be modified during the transformation.

As a project for a subject on embedded systems I built a three node system with two Freescale Kinetis boards and a Raspberry Pi that streamed audio and video and played it in a small 128x64 monochrome OLED screen and a loudspeaker.

The audio and video was extracted from a standard h.264 video file with ffmpeg and transcoded to custom audio, video and muxing formats suitable for real time streaming over the constrained serial port channels available. A watermark protocol is implemented by every pair of nodes communicating to prevent both underruns and overruns.

It didn't really had a useful purpose but it was fun.

I was not happy with the existing backup tools available at the time — apparently I'm not the only one, so I tried to roll my own.

What makes Tormes different:

• Tormes is designed to store backups on cloud storage or remote file systems (it's not designed for magnetic tapes nor attempts to use them as a metaphor of anything).

• An optional master server can be set up to aggregate backup metadata from different servers, but the backup data is sent directly to the cloud.

• Every backup file is signed and encrypted, by default. Each backup gets its own key, derived from a master key, only known to the master server. Your cloud does not store your keys.

• No intermediate copies are performed, ever. You won't need several times 50 GiB in order to send 50 GiB to the cloud. Indeed, you will only need space in your storage service. Each step of the process (archiving, encryption and storage) is performed concurrently. That is what makes it the streaming backup system!

• It's managed by simple console commands, e.g. tormes-catalog shows a list of the backups stored in the system, accepting filters by machine and resource.

• Archiver programs can be written to make backups not only of directories or file systems but any other data source, like SQL dumps or application-specific database formats.

• Writing storage modules is a matter of coding two Node.js streams, one for reading and other for writing. The S3 storage module is just 100 lines.

• The system is flexible. Writing new storage modules or archive programs does not require touching the core codebase at all. A node can restore a backup made in other node or use a different unarchiver without issue.

• It has been built with security on mind. A ticket system is used such that nodes can only restore and decrypt backups they have been explicitly authorized.

watchd is a simple tool to waste less time switching windows when developing software.

It consists of two programs. watchd-monitor launches whatever command is passed as arguments and whenever it receives a reload signal it will terminate the current process and relaunch it. watchd-notify sends a reload signal to any monitors available.

It easy to bind watchd-notify to any text editor with a save event so that after changes to a file are written to disk you get to see the new output of the program. This method is more robust than file system monitors that are often prone to race conditions depending on how the editor works internally.

This is a small utility to move the focus between windows in a desktop environment following a cardinal direction. For instance, right-window -f right will focus the window next to the right. Available directions are left, right, up and down.

The directions correspond to the actual position of the other windows relative to the currently focused window.

I use this small utility in order to quickly navigate between windows in my tiling window manager (bspwm) without using the mouse. The algorithms are generic and they can also work in non-tiling window managers.

I've developed and contributed upstream a number of patches for the HTML5 port of Cocos2D-x, adding features and bugfixes. For instance:

• Fixed a long time bug with text rendering in the WebGL backend.

• Fixed a very subtle bug that blurred large areas of the screen.

• Improved text wrapping for a number of languages.

• Added support for high definition text in high density screens.

Originally made years ago for my own use in a few hours, it more than paid over the effort, being a tool I used to use in a daily basis, back when chat applications had a lack of reliable file sharing functions.

This little service allowed you to host files and get a temporary URL that links to them. No wrappers, no dangerous ads, no need to register, no waiting periods, no file type limitations... It could even stream video and audio.

It has since been discontinued since in the current ecosystem of chat applications it's no longer necessary.

This desktop application allows users to share files with Lasaña without launching the browser. It can also be scripted easily to use with screenshots, which are one of the most common use cases for Lasaña.

I found often wanted to share photos from my phone with Lasaña, so I made an app for that. You can either pick a photo from the application or you can use the Share functionality built on Android.

It's more awesome if used in conjunction with a clipboard sharing application, so you can actually take a photo in your phone, tap Share and paste the link in your computer with Ctrl+V.

In multiple occasions at ACM USAL, we needed a way to provide a fast internet connection to a number of guests in a room with only one Ethernet socket and very limited WiFi access. The connection would need to be used to download big software packages.

Using only a laptop, an external Ethernet USB card and a small Ethernet switch I was able to share an Internet connection by means of NAT through both a WiFi access point exposed through the laptop wireless card and the Ethernet switch.

In order to minimize the impact of the big file downloads on the host network, a HTTP cache proxy is introduced with Squid, so they are served from the laptop disk or RAM instead. The proxy contains a custom rewriter that is able to catch request of Ubuntu packages from mirrors, avoiding downloading the same data from different mirrors.

A pair of Ansible playbooks are provided to replicate (and later tear down) with minimal user interaction.

Made as a class assignment, this interactive application explains the basics of the proportional representation systems such as the D'Hondt method and allows the user to view and experiment its effect as both the votes cast and the number of available seats vary.

The application is usable from desktop and tablets.

This site was made for an assignment on Search Engine Optimization.

It features a small site explaining math useful for game development. It includes code, graphics and interactive demonstrations.

The entire site was made static and highly compressed to offer minimal load time. Goal tracking was set in Google Analytics. The design was carefully crafted from scratch for maximal legibility on a number of platforms.

This parser is able to evaluate mathematical expressions from user provided strings, like 1 + cos(2 * pi * x) / 2. It is able to signal errors on malformed expressions and is safe and robust enough to be used in end user facing applications.

It has been used as a calculator and as part of a function plotting software. A C API is provided to ease integration with other languages.

The code makes extensive use of classes and smart pointers. Indeed, it passes valgrind memcheck with zero leaks even though there is not a single delete in the codebase.

If you have ever written a parser you may have felt many times puzzled by a crash where you get a traceback but have no idea what code actually produced it.

I found myself in that situation often enough to warrant inventing something to track errors better, so here it is. This simple module gives the programmer a context object to set information on what is being processed, like line numbers or file names and shows them in the event of a crash.

I gave a talk about deploying a search engine built on Solr, an open source search platform based on Lucene.

In it I described how it is set up, how documents can structured for Solr, the mechanisms it provides to convert raw textual information in indexable word stems, how indexes are created, how documents are fed to the system and how search is performed.

As a demonstration application I create Localpedia: I download a dump of all the abstracts of Spanish wikipedia — they are publicly available on dumps.wikimedia.org, parse them with Python and feed them to Solr. Then I build simple Flask web application that serves as frontend, allowing the user to look for articles.

In this paper explain the basics of stream ciphers and RC4, one of the most popular stream ciphers that are in mainstream. The algorithm, implementation caveats and existing attacks are described.

Until version 4.8.6, Qt had a bug where dead keys (e.g. those used to write diacritics like á in Spanish keyboards) were ignored on Microsoft Windows if the user typed fast.

I fixed it.

You can advance your character with W key or step back with S. Use your mouse to set your direction. Enemies spawn from outside the screen. Left click shoots a ray, right click tries to convert an enemy or heals a converted bunny (as in Age of Empires).

Made for an assignment. That was a fun night.

As part of ACM USAL I organized a workshop where I explained how to build an AngularJS application from the ground up.

Javascript, HTML and CSS basics were covered first; then the AngularJS framework was introduced. Features like the module system, dependency injection, the URL router, controllers, filters and the HTTP API were explained.

During the workshop, the catalog of a fictitious shop is created as a single page web application.

This application offers an efficient user interface for defining graphs on top of map images.

First, the user loads an image file. Then, in the node drawing mode, the user clicks every where they want to create a node; then edges are drawn in the edge drawing mode. At any point nodes may be moved and edges removed. This process is even quickier if a graphics tablet is used instead of a mouse.

The program generates a easy to parse XML file describing the graph with nodes having the coordinates relative to the image. That file can be used in external applications or loaded in the map editor to edit it later.

The software also comes with built-in path finding functionality that allows the user to query the shortest path between two arbitrary nodes, using the A* algorithm.

Alternatively, since this was made as part of an assignment, it can also use a backtrack algorithm written in Prolog. A Prolog interpreter with user facing console is also included in the software.

This little thing was the first mobile application I did, since before that I did not own a smartphone.

This tool lets you use your phone as a remote controller for slideshows. You start a server in your computer, either through the command line or from the graphical user interface, then you type the address in your phone's browser and you are done. Optionally you can set a password.

The application works at least on Windows and Linux.

This is a tool to streamline the deployment of distributed applications during development. First the master server software (malote) is run in the computer of the programmer. Then a client software (minion) is packed, configured with the IP of the master server and other security parameters. The minion software is manually launched on every computer the software is wanted to run on.

From a web interface, the programmer can set the path of the software they are developing and specify different templates that may execute pieces of this software. Each node running the minion software can be assigned one or more command templates.

Pressing the Deploy button the software directory is compressed and sent to every minion. After that, each node executes the associated commands. If there were processes from a previous deployment, they are automatically killed before any further action.

The communication between Malote and minions is authenticated and encrypted with a local TLS certification authority and the use of client certificates, so that nobody without the keys that are bundled with the minion configuration package can alter the software or fraudulently join the network.

The software works in both UNIX and Windows systems.

This page you are seeing was coded from scratch in a weekend.

On development, an express server is run that reads a series of YAML files containing all the prose and compiles a Jade template that morphs them into the HTML you are seeing. As a development plus, thanks to tiny-lr the browser always updates the data when any of the data files or the template are modified. The theme and and interactive features like the slideshow are created from scratch.

On production, it compiles to a simple static web site that can be uploaded anywhere with zero maintenance... those are the best!