This repository is an index for the projects I developed during my masters. It describes them and details what parts I developed (in the cases where there was a team effort)
- Network Protocol Definition
- Network Protocol Implementation
- Network Simulator
- Java-- compiler
- Distributed Systems
- Custom Chess game in Java
- Arduino window manager
- Atduino JTAG bitbang
Repository: GitHub Link
Description:
The whole project was a full end-to-end solution for wind sensing nodes that could connect ad hoc.
My responsibility was to define a custom protocol standard for this purpose, and implement it.
Main protocol functionality:
- Time Division Multiple Access (Medium Access)
- Clock synchronization
- Distance-Vector based routing
- Non-byzantine fault resistance
- Application packet multiplexing
The latest protocol definition (RFC style) can be found here
My Role:
- Protocol designer
- Fully design the protocol
- Coordinate with antennas team to define minimum bandwidth necessary and acceptable error amounts
- Coordinate with sensor team to define amount of data per second that could be transmitted
Note: There are many other repos that belong to the project as a whole, but as they were not my main focus I do not include them here.
Repository: GitHub Link
Implementation of the protocol specified above
Extra implementation specific functionality:
- Protocol implementation unit tests
- Reproducibility
- The implementation generate or consume random values
- Logging
- Also dumps binary packets for improved debugging
My Role:
- Lead developer
- Responsible for delineating tasks and coordinating with other teams
- Creator of the protocol definition linked above
- Main developer (developed all functionalities above)
- Other team members performed packet [de]serialization and small maintenance tasks
Note: There are other repos that belong to the project as a whole, but as they were not my main focus I do not include them here.
Repository: GitHub Link
Description:
A network simulator written in C, used to test the protocol above. Functionality description:
- UDP port based connections
- Errors supported:
- Random bit flip
- Packet loss
- Extreme packet delay
- Use distance maps to calculate appropriate delay in delivering packets between devices
- Generate/Consume probability files for packet transmission to accurately recreate and debug failure scenarios
- Ability to Mute/Deafen/Shutdown a specific node for a specific time
My Role:
- Main developer
- Other team members performed small maintenance tasks
Note: There are many other repos that belong to the project as a whole, but as they were not my main focus I do not include them here.
Repository: GitHub Link
Description:
In this project, I developed a compiler for a subset of the Java language (nicknamed Java--), using Java. Besides supporting the Java-- language, it features basic optimizations such as:
- Liveliness analysis for register allocation
- Constant propagation
- Constant folding
- Smaller optimizations
- Utilize less expensive comparisons by reorganizing the inputs
- Constant push instructions optimized based on the size of the constant
- Precise stack calculation
- Array of size 1 as variables
- ...
My Role:
- Single developer
Repository: GitHub Link
Description:
Implement paxos and bully leader election algorithms to create a fault tolerant node for a distributed system, which can automatically appoint a leader and begin transmitting messages between nodes
My Role:
- Network simulation
- Bully protocol leader election implementation
Repository: GitHub Link
Description:
In this game of chess, each piece is described by its' movement pattern and image. Using a visual interface (or the txt file representations), it is possible to generate new pieces with custom movement patterns, and assemble them into custom boards. These boards can then be sent to another peer in the same LAN network, for a custom PvP game.
My Role:
- Single developer
Repository: GitHub Link
Description:
This window manager was one of the first projects of my career. It supports 7 concurrent windows, that can be dragged and overlap, and support basic character sets, or direct bitmap manipulation. Due to the refresh rate constraints of the LCD used, I had to implement an optimized refresh, where only the pixels that were altered would update (whenever it was possible to infer this)
The second part of the project was created by @rycostinha, and involved using these windows to run the pong and snake games.
My Role:
- Create underlying resource management
- Create windowing system
Repository: GitHub Link
Description:
Simple Arduino implementation of JTAG via bitbanging
My Role:
- Single developer