Matco

Introduction

I do some development in my spare time. You will find below a list of little pieces of software or scripts I have written. Some projects are hosted directly on this server, while others are hosted on other cloud services. The source code of projects are mostly hosted on GitHub.

Most of the time, I write web-based applications because they are easy to set up. There are countless things you can do with HTML and JavaScript, from audio file analysis to 3D rendering with OpenGL. For most cases, you don't even have to use an HTTP server. Moreover, web apps are straightforward to share or deploy and can be run on plenty of devices. Anyway, I am convinced that whatever the language, it is the idea that is important.

Willing to buy a new flat during difficult times in Europe, I needed to watch the very volatile mortgage rates daily. I also wanted to keep a history of the rates to improve my understanding of what was happening. I decided to automate this process. Migroto is a quick and dirty Python script that retrieves the mortgage rate from the Migros Bank website and stores it in a Google spreadsheet. It can easily be deployed as a Google Cloud Function that can be run daily.

Despite being very specific, this script can easily be adapted to fetch any data from a website into a Google Spreadsheet.

The code is available on GitHub.

I really enjoyed the "survival" game Astroneer. In this game, you have to gather resources, combine them, and build objects. Like I did for SimCity BuildIt Helper, I created a small website that will help you with these tasks.

No Neo4J or Java this time. I used a flat JSON file as a database and the combo TypeScript/webpack to build the website. TypeScript is now mature, and I think it is the language you should use to code a reliable JavaScript application. Typed programming is the key.

The code is available on GitHub and the application is available here.

I created this application to test the typical web development stack (aka the famous "full stack," as in "developer full stack"). I chose to use Jersey (JAX-RS) and Angular. The application allows you to create lists of locations that you'd like to save for later. It's a simple application, but it contains the classic challenges you have to deal with when you're doing web development.

It's nice to watch the improvements made to the tools year after year. Both Jersey and Angular are easy to use with minimal setup. The JavaScript environment is now really mature. A special mention to ESLint that checks your code amazingly well.

The code is available here (for the API) and here (for the front-end) and the application is available here.

I am closely following the news around IOT and home automation. I've watched many projects dedicated to the management of different sensors and devices, but I've always been repelled by their complexity or their lack of quality (no name here). Then I discovered Mozilla Things Gateway which seems to offer a good user experience and the support of plenty of devices, especially Zigbee-enabled stuff.

One of my coworkers owns a Raspberry Pi and a BMP280 (a small temperature and humidity sensor that can be attached to the Pi GPIOs). What a perfect opportunity to test Things Gateway and to develop my own add-on (BMP280 was not natively supported)! I found an excellent JavaScript library for the BMP280, so I just had to write the code for the adapter that allows the Things Gateway and the sensor to communicate. The result is quite simple, but it was difficult to write because of the poor quality of the documentation. I submitted the add-on to Mozilla, and they accepted it, so it can now be installed directly from your instance of Things Gateway.

Mozilla Things Gateway is far from finished and is missing numerous features. However, it's a good start. I'm now thinking about buying a Zigbee USB key and some sensors to continue experimenting with home automation.

The code is available on GitHub and the add-on is directly available in Things Gateway.

As part of my job, I've heard a lot about DICOM, a standard for the communication and management of medical imaging information and related data. To understand the DICOM file format, I decided to write a web application that extracts and displays the attributes contained in a DICOM file. Parsing the file to look for textual attributes was an easy task once I built the dictionary that lists the types of data usually found in a DICOM file. However, I didn't even try to display the images because they are often stored in formats that are not natively supported by web browsers and require a library to be rendered on a canvas. Finally, I added the possibility to clean up the attributes that contain personal information.

This was a good opportunity to manipulate binary data in JavaScript and to use a web worker. I think the DICOM file format would benefit from a new architecture based on a zip file containing an XML file for textual data beside images in their own files.

The code is available on GitHub and the application is available here.

After some time playing with the Futuro Cube, I wished to develop my own game. I chose to adapt the famous Mastermind game. Futuro Cube programs are written in Pawn, a simple language that looks like C. Pawn is poor in terms of features compared to the languages I usually work with, and it was interesting to be reminded how modern languages hide complexity.

The Futuro Cube SDK works very well. The documentation, however, is poor and is missing use cases and examples. The most difficult challenge in developing this game was finding a good design to make Mastermind playable on a cube.

The code is available on GitHub.

Since everybody is talking about Go, I thought I had to give it at least a small try. It's also one of the languages available in the Google App Engine "standard" environment (compared to the "flexible" environment), which means you have a comfortable free quota to run your scripts. Besides, we're big fans of Kaamelott at work and heavy users of the Kaamelott Soundboard. And we're also using Slack. Perfect match for a Slack command that can add links to sounds from Kaamelott Soundboard in our Slack channels.

I enjoyed writing these few lines of Go. It's like a mix of old and new programming concepts. However, I was a bit disappointed by the lack of native features.

The code is available on GitHub. If you would like to use it in your own Slack workspace, check the instructions in the readme file.

I heard recently that a more or less standard API for browser extensions has been created and is supported by Google Chrome and Mozilla Firefox. I would like to give it a try. I created Wheeltab, a browser extension that allows you to navigate through your open tabs using your mouse wheel.

I am disappointed that the API does not allow me to use native components of browsers. It is very limited in some way.

The code is available on GitHub and the extension is available here for Firefox and here for Chrome.

Last year, I discovered the game SimCity BuildIt on the Google Play Store. A part of the game consists of the creation of small objects. These objects depend on each other, creating a kind of tree. It was a good use case for a graph database, so I decided to import the game data into Neo4j. I have then created a small website that will help you build these objects by displaying their dependencies and the buildings where you must build them.

I really like how easy it is to write queries for Neo4j using their query language, "Cypher". However, I am a bit disappointed by their REST API. Currently, it is not possible to configure users' access to the database.

The code is available on GitHub and the application is available here.

After I bought my Garmin Fenix 3, I decided to test Connect IQ, which is Garmin's platform to create applications for their products. As I practice badminton and always forget my score, I developed this small application to keep track of the score during a badminton match.

It was nice to think of a UI for such a tiny device and to use the Garmin SDK. Connect IQ works quite well, given that it is only the beginning of their platform. I wished to continue the development of the app and try to detect how many strokes you make during a match, but it seems the SDK does not allow access to raw data from the accelerometer. I hope this will be improved soon.

The code is available on GitHub and the application can be downloaded from Garmin Connect IQ store.

March, 2021 I decided to replace Google Datastore with a standard SQL database to avoid vendor lock-in. The application can still be easily installed on Google App Engine with Google Cloud SQL, but I decided to host my own instance on a virtual server.

I decided to test Google App Engine for real. I chose Python to build this small application, which has basically 3 features: configure some websites you want to watch and how you'll be warned in case of failure; check these websites and display a dashboard to show their current status and recorded downtimes. I must say that Python and App Engine work very well. Google Datastore is impressive because of its simplicity.

I use this little project to monitor this website. It emails me if a specified text is not found on the home page.

The code is available on GitHub and the application is available here.

November, 2022 Heroku discontinued its free tier, so I decided to host the project with Render. It's very similar to Heroku (same services, even the website looks the same), and the migration was very easy (and I got free HTTPS!).

I've been watching WebRTC for a long time. I have tried to use it before, but browser support was too bad to build something reliable. But I think this technology is now ready for great applications, so I wrote a small proof of concept that allows you to chat and send files to your buddies inside a browser in peer-to-peer mode.

I also took the opportunity to test Heroku for the small Node.js script server side. I'm pretty amazed by how easy it is to deploy applications with these new providers: a git push and you're ready to go. And you can roll back to a previous version or boost your server with a click. This is crazy. In the case of Heroku, I'm a bit disappointed by the management console, which is super slow.

The code is available on GitHub and the application is available on Render.

Next development steps:

• Reliability across modern browsers
• It would be nice to add audio and video

A friend of mine would like to learn how to develop an Android application. We decided to build a chess game because we couldn't find a decent one on the Play Store. This is my first pet project in cooperation, and it is very interesting.

Chess is a very interesting game to program. It may look basic at the beginning, but moves like castling, promotion, or "en passant" capture can kill your implementation if you don't take them into consideration at the beginning. This is particularly true for "en passant" capture, which prevents you from analyzing the chessboard statically because you can't say what movements are available if you don't know the moves' history.

We planned to rely as much as possible on the Google API to build a fully multiplayer game and to synchronize your games across all your devices.

The code is available on GitHub and the application will hopefully be released soon on the Google Play Store.

A friend of mine bought a Philips Hue kit. As soon as I learned there was an open API, I tried to build an app.

The API is pretty easy to use, except for setting light colors! The fact is that lights take their color in a special color space, and Philips does not provide documentation about how to transform a simple RGB color into this color space. Many smart people found the right way to do so, but I found that lights do not behave as expected according to the documentation for colors that are out of the color space. That irritated me a little bit. What is the purpose of an API if it is not well documented?

Anyway, I'll finish what I started and put it here.

August, 2013 Unfortunately (again), Google closed the Latitude API. The application no longer works.

I wanted to test Google APIs for a long time, particularly OAuth. It's now done with this application, written entirely in JavaScript. Yeah, once more, JavaScript, but it's a key language nowadays.
This application helps you manage your Google Latitude history. I'm not happy with the official one because it cannot delete more than one record at once; it's very frustrating. It can also show you some nice stats. Feel free to use this application with your data.

Although this application won't mess up your data, be kind and don't try exotic actions. There are many asynchronous operations, and I didn't handle errors that may occur.

The code is available on GitHub. The application is no longer available as it is no longer working.

After a failure with my previous Android application, I decided to build another one. I started to build a small universe simulator using Canvas. After some hours spent and some disillusionment with native applications, I realized that I could do the same application in HTML/JavaScript.

To make it more difficult, I chose to use 3D with WebGL. Unfortunately, after some more hours and one or two headaches trying to debug the code, I realized that my old GeForce 7800GT does not support OpenGL ES 2.0. I gave up, leaving everything unfinished.

As always, when you don't have any direction, I gave up both projects.

September, 2012 I give up. OVH does not even answer my emails. They've found the right way to disgust a developer.

January, 2012 Unfortunately, the application has been removed from the Android market by OVH due to a trademark violation. I'm currently in discussion with the legal department at OVH to find a solution, but it really makes me sick to see how they acted. They asked Google to remove the application without any warning, and Google approved the request without any check. The application was obviously free and developed in my spare time. What a waste!

I've owned an Android phone for a while, and I couldn't resist developing an application. I also have an OVH (a big computing company that offers countless services) account that allows me to send SMS from the Internet and avoid roaming fees when I'm traveling. So I thought this was the perfect opportunity for my first Android app.

I had to use the OVH SOAP API, which is really a pain because there is no native support for XML and WSDL in Android. After I decided to write the XML manually, I worked hard to handle the network calls. Building a robust application that relies entirely on network services on a mobile device where the connectivity is not reliable is really difficult. And it's even worse when you know that Android apps can be paused or resumed at any time. Anyway, after spending some hours researching how to use the unpublished Android SMS API, I managed to make it work pretty well.

The code is available on GitHub.

September, 2013 I have lost all my faith in PHP. I believed they could build a real language with PHP 6, but I now know this will never happen. The ubiquity of PHP on the web is decreasing as old hosting providers are replaced by new ones that use languages like Python, Java, or Node.js. I think this is the beginning of the end of the PHP era.

Inspired by the Apache Tapestry Java web framework, I'm working on a tiny MVC framework in PHP. I would like to show what you can do in PHP. I think there is still a market for this language, as it can be used by everyone to quickly create a website that can be hosted almost everywhere.
The purpose of this project is to allow the rapid creation of prototypes thanks to MVC. Separation in layers is a good idea to keep a project clean, specifically with PHP. The framework is totally component-based and manages data binding. It strongly relies on the PHP DOM API.

I never released Pastry as a stand-alone package. Instead, I wrote this demo website called Tracks that uses the framework and data generated from my other project, Scanlan. This web application allows a logged-in user to search for a track among a catalog of music files, then listen to and review the track.

The code is available on GitHub and the application is available here.

Next development steps:

• Make Pastry a standalone package
• Allow to build playlists
• Share favorites tracks with other users

January, 2012 You all know what happened to Wave: killed and buried. Anyway, it was a nice try with the Google App Engine API.

As an early adopter of Google Wave, I've created a tiny robot. He's counting every user message in waves where he has been invited. You can invoke him with the command "!stats" and reset data with "!reset". Try him!

Just add matthieu-corageoud@appspot.com in your wave.

I've also created a tic-tac-toe gadget.

Install this gadget from http://matthieu-corageoud.appspot.com/_wave/3tinstaller.xml by clicking on the "New extension installer" button while writing a new blip.

In 2009, I was tired of people saying that JavaScript was boring, cabbalistic and difficult to use. That's why I decided to start this project as a sandbox to prove that JavaScript is interesting and has some nice concepts.
The goal of the project is to emulate a desktop environment in a browser. It has been developed from scratch using vanilla JavaScript. At that time, it was using bleeding-edge syntax and APIs, so you were required to use the latest version of Gecko or WebKit to use it.

My roadmap was the following:

• Use Google JavaScript APIs for Google applications instead of iframes. Google scripts load a ton of other scripts that destroy the application when they are loaded. Neither normal APIs nor AJAX APIs are currently working.
• Add more settings in the configuration panel, such as color theme and background image, using the new file API (HTML5).

The code is available on GitHub and the application is available here.

Written in Perl, Scanlan is a collection of scripts used to scan the files shared by the computers on a local network. Every detail of every file that has been discovered is stored in a database. Scanlan can detect similar files.
The goal was to use these scripts during a LAN party to index all the files shared by the LANers. Once indexed, it would be much easier to search for files and download them. If you have already been to a LAN party (when file sharing was a thing), you must know how difficult it is to manually browse the different shared folders on every computer.

Unfortunately, I never finished the part required to discover the computers on the network. However, I'm still using the script that indexes files locally to build the list of files used in my other project, Tracks.

The code is available on GitHub.