
## Background
---
Growing up, I played [Source Engine](https://en.wikipedia.org/wiki/Source_(game_engine)) based games. The intricate movement mechanics felt gratifying--whether it was surfing, bunnyhopping, or rocket jumping, something about the engine's movement left an impression.

My journey with game development began when I discovered the [Blender Game Engine](https://en.wikipedia.org/wiki/Blender_Game_Engine) in elementary school. Although I had trouble understanding the engine at the time, I was eager to learn it. I made splitscreen games and played with friends at a school computer.

It quickly became a hobby. Over the years, I've made a multitude of games, and I learned every part of the development process--modeling, texturing, animating, and programming. I've toyed with other game engines such as [Unity3d](https://en.wikipedia.org/wiki/Unity_(game_engine)), [Torque](https://en.wikipedia.org/wiki/Torque_(game_engine)), and [Unreal Engine](https://en.wikipedia.org/wiki/Unreal_Engine).

Of all the game engines I've used, Unity3d was my favorite--it didn't have a ridiculous entry skill level, had great community support, was very flexible, and used C#!

When I decided it was time to create a serious game, I stuck with what I loved: movement-based video games. These peculiar gamemodes have always been fairly unpopular, but the communities surrounding them have always been very dedicated and competitive.

I thought it would be fitting to create a rocket jumping game, one that would include the smooth movement I've always loved but unconstrained by the old technology of popular movement-based games.

## Project
---
The game is built using Unity3d, coded with C#, animated and modeled with [Blender](https://en.wikipedia.org/wiki/Blender_(software)), and textured with [GIMP](https://en.wikipedia.org/wiki/GIMP). It is a competitive rocket jumping game--players use explosives from rockets to propel themselves across a series of levels.

I relied on [Source's multiplayer documentation](https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking) for the client-server model. The game is server-authoritative, meaning the server ultimately controls the "state" of the game, rather than relying on information from clients. This has numerous benefits over a traditional client-server architecture: it prevents cheating, allows for validating data sent from the client to the server, and is very consistent and reliable over all clients. To combat the full [round trip delay](https://en.wikipedia.org/wiki/Round-trip_delay) of the server-authoritative model, I've added client-side prediction, a method that allows client-side actions to be performed instantly only on their end. To clarify, these actions only exist on the client--other clients use data from the server's game state.

Since then, Unity3d has transformed with the [new render pipelines](https://docs.unity3d.com/Manual/render-pipelines.html), new networking solutions, and [DOTS](https://unity.com/dots), the data-oriented technology stack. The engine has become somewhat unstable with the constant set of changes. For this reason, development for this project has slowed down.

Server-authoritative, multiplayer platformer.

STRAFE


## Background
---
The instant I discovered algorithmic trading, I knew I would need a tool to measure the performance of various trading strategies. I decided to design my own backtester-- one that would allow me to quickly test parameterized algorithms over years of historical data and thousands of tickers.

## Project
---
So I created a backtesting application in C++. It runs entirely on the command line, and the tedious computations are done on multiple threads to maximize efficiency. I used data from [Alpha Vantage](https://www.alphavantage.co/) and used [Doxygen](https://github.com/doxygen/doxygen) for documentation.

Considering the difficulty of obtaining historical data, the application has been designed with limitations:
- The only market data available comes from the equities market
- All data comes in daily tradebars (open, high, low, close, volume, timestamp)
- Assets come from only a few US exchanges
- The backtester does not take into account fees or slippage

The backtester allows you to customize any strategy-- you can modify the initial equity, start date, end date, and other parameters. You can open/close limit/market orders that short/long any ticker for any duration. 

To begin, simply create a class that inherits from `Strategy`:

```c++
class ExampleStrategy : public Strategy {
    public:
        ExampleStrategy();
        void onInitialize();
        void onDay();
        void onOrderFilled(const shared_ptr<Order>& order, const shared_ptr<Position>& position, double price, int shares);
};
```

Once you have created your class, add it to the driver in `driver.cpp`:


```c++
Driver::Driver() {
    strategies.push_back(make_shared<ExampleStrategy>());
}
```

All boilerplate is defined in `Strategy`-- here, you can pull market data, create orders, view positions, and much more.

For more detailed instruction, view the [repository](https://github.com/tareqalyousef/Backtester).

backtester


In creating my resume, I realized I had skills in web development with nothing to show, so I decided it would be appropriate to design a personal web portfolio--one that could showcase my ability to create websites.

So I created a personal portfolio using Ruby on Rails, PostgreSQL, and [Heroku](https://www.heroku.com). It contained [CRUDing](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) for projects and blog posts gated by an administrative login.

Later, I realized the setup was a little overkill for a simple portfolio, so I recreated the website using the static site generator provided with Node.js, which you are viewing right now!