The Very First Post
Tags: opensource, osd600, senecacollege
Published: 2021-09-10 14:33:41

Welcome. My name is Gerardo, but you can address me as Jerry, for short.

I am a Computer Programming student in Seneca College at the department of Software Development and Data Science. I am currently taking a course called Open Source Development (OSD600), which discusses about the main objective of the Open Source Initiative, as well as the topics around it, such as projects, licenses, and such. Fortunately, I am working from Toronto at the moment, so I do not have any time zone conflicts.

## Reasons to Join the Course

I have several reasons to join this course, and all of them are related to the Open Source Initiative:
* Freedom: probably the most important one, freedom to read and write code on a project that does something of value is a really important thing for someone who likes to learn from examples. Whether it be code style, code practices, code organization, or even things that are only noticeable by reading the project's history (mailing list, GitHub issues,  etc.) such as collaboration, one can learn a lot from projects written from all skill levels. This reason is so important, in fact, that I would like to elaborate more about this in future posts.
* Interests Matter the Most: working on open source requires, most of the time, voluntary involvement. As such, I am not forced to work on projects that I may not be completely interested on. I can work on anything that interests me as long as I have enough competency to contribute. This might not entail a contribution accepted by the maintainers, though!
* Self-Improvement: reading and writing code is really important for a programmer, but I also feel that collaboration is crucial, and one cannot improve such a skill if working on only single-person projects. If I want to contribute, I need to learn how to collaborate well. Thus, I improve on my own volition.

There are even more reasons I could mention, but I feel these are the most elaborate and concise ones I can mention. Indeed, I think the reason on freedom might be the one that encompasses almost every other reason I could mention.

## Objectives

I plan to accomplish several things, but I will be satisfied if I can accomplish at least one of them.

My plans include:
* making a contribution to a project I care about. It does not have to be accepted; if I made a pull request that is worthwhile, then I would consider it to be an accomplishment.
* getting a contribution approved. I hope that my contributions have enough value to be accepted into the project, but this may require more practice and discipline.
* start an open source project that does not include a project from my course.

These plans may change and get expanded depending on the lessons I will learn over these 4 months.

## Forks

I found several projects that I decided to fork so I could keep a copy of it on my own GitHub profile. I will use these projects to try out stuff on my own, and getting used to building projects, too.

I can categorize the projects as follows:
* Programming Languages
* Databases
* Game Emulation & Reverse Engineering
* Game Development
* Text Editors
* Program Verification

### Programming Languages
I have included three programming language forks that I am mostly interested:

* [The Rust Programming Language](https://github.com/rust-lang/rust): Rust, a programming language focused on memory safety without sacrificing speed.

* [The Nim Programming Language](https://github.com/nim-lang/Nim): Nim, a programming language that offers several features from languages like Python, Ada, and Modula, while also retaining the speed of languages like C and C++. One of the most interesting features of Nim is the capability of metaprogramming, since it lets you modify the [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a program, a feature that is more powerful than C's preprocessor.

* [The F# Programming Language](https://github.com/dotnet/fsharp): I consider F# as the functional-oriented sibling of C#. This language offers a nice introduction to statically-typed functional programming. It offers a really nice [ML-like](https://en.wikipedia.org/wiki/ML_(programming_language)) syntax, as well as some features like [type providers](https://docs.microsoft.com/en-us/dotnet/fsharp/tutorials/type-providers/) (a way to define a schema for data such as a database table, JSON file, etc.).

### Databases

* [SQLite](https://github.com/sqlite/sqlite): SQLite is an SQL implementation of an embeddable database; to be more clear, instead of having a database running as a program on a computer that listens for connections, queries, and the like, it is instead a database that can be part of the application itself. Thus, a program that stores data can make use of SQLite to deal with the management of such data, while still being lightweight since it doesn't have all of the baggage that a normal [RDBMS](https://en.wikipedia.org/wiki/Relational_database) has. I like the way the SQLite team puts it:

> Think of SQLite not as a replacement for Oracle but as a replacement for fopen().

### Game Emulation & Reverse Engineering

This section is a rather interesting one, since it does not necessarily directly correlate to the nature of open source. After all, reverse engineering is mostly done on proprietary software, as way to replicate the original software by more than just copying the external behaviour of the machine. Either way, the projects themselves are open source, so I believe this section still fits.

The projects that I had researched and forked are:

* [The Legend of Zelda: Ocarina of Time decompilation](https://github.com/zeldaret/oot): this project gets the machine code found in the original cartridge of the game and translates it to C code. While it does not involve the heavy process that software development has, it is an entertaining process if one enjoys retro gaming.

* [Citra: Nintendo 3DS emulator](https://github.com/citra-emu/citra): An emulator that tries to replicate the capabilities of the [Nintendo 3DS console](https://en.wikipedia.org/wiki/Nintendo_3DS).

* [Project64: Nintendo 64 emulator](https://github.com/project64/project64): An emulator that tries to replicate the capabilities of the [Nintendo 64 console](https://en.wikipedia.org/wiki/Nintendo_64).

### Game Development

* [Simple Directmedia Layer](https://github.com/libsdl-org/SDL): a library that offers low-level access to resources like audio, video graphics, joystick, keyboard, mouse. It is mainly used for the development of video games ([Stepmania](https://www.stepmania.com/) and Valve's games such as [Counter Strike: Source](https://en.wikipedia.org/wiki/Counter-Strike:_Source), as some examples).

### Text Editors

* [Emacs](https://github.com/emacs-mirror/emacs): Emacs, the text editor that can work as an operating system, also caught my interest after I started to use and learn about it. Emacs' philosophy to be as extendable as possible is what inspired me first to get more involved in open source and customize what I had access to. Keep in mind that this is not the original repository.

### Program Verification

Program verification, as a rough description, is about creating a program that can verify another program's behaviour. The way a user might verify the behaviour of a program is by constructing a mathematical proof on how the program behaves. This is a really interesting field for mathematically-inclined programmers. Also, this can be considered a form of quality assurance. It does not replace automated or manual testing, but instead gives more guarantees that the code works as it should. The project that I am interested on is [F*](https://github.com/FStarLang/FStar).

## Conclusion

I would like to clarify that I will not be involved in all of those projects in these 4 months; I may be involved in the ones that I can contribute to the best of my ability.

Without anything more to add, I believe this is a good point to end my introduction for the open source community, and I hope I will bring as much value as I can.