## What Will We Create?
At the end of this blog post we will have a working cryptocurrency which can be traded/purchased on exchanges and transferred between owners of the coin. We shall dub this coin "JayCoin" or $JAY, and it's full implementation shall be under 100 lines of code.

## Getting Started / Setup
To get started on creating JayCoin we're going to need some Ethereum*, so head over to your preferred exchange to buy some. "Why Ethereum?" you may be wondering,but for JayCoin to exist and be under 100 lines we're actually going to build it on the Ethereum blockchain. This is pretty common knowledge, and I'm willing to put money on the fact that many of the coins you've heard of/own are implemented on Ethereum.

*If you're looking to just test out, you can get some free Rinkeby ETH at https://faucet.rinkeby.io and deploy it onto the Rinkeby test network.

After this you'll need to download Tokens by ConsenSys. If you have git installed you can install it by typing `$ git clone https://github.com/Consensys/Tokens`. If you don't have git installed, just head over [here](https://github.com/Consensys/Tokens) to download and unzip the repository.

## Remix
Now head over to [Remix](https://remix.ethereum.org), a web based Solidity IDE. For this to work, you'll need to have [Metamask](https://metamask.io/) installed, or be using a decentralized web browser such as Mist or Cipher. The wallet should also be filled with the Ethereum you obtained during setup. If you're unsure how to do this you can go to your browser's homepage to learn more. **Make sure you are connected to the proper network, real money = mainnet fake money = rinkeby.**

When you arrive at [Remix](https://remix.ethereum.org) it may seem a little overwhelming, don't worry. 

The first thing you want to do is delete the default contract. 

![Delete Contract](https://i.imgur.com/zVV2GfY.png)

Next item on the list is to import the previously downloaded contracts into Remix.

![Import Contracts](https://i.imgur.com/vmD68Xe.png)

## Deploying
We've successfully imported our contracts to Remix, now it's time to deploy them. Click on the file which says EIP20.sol, and navigate to over to "Run". Click on the text-box right next to Create and enter in "300, "JayCoin", 0, "JAY"". 
The 300 means that only 300 JayCoins will ever be created. 
JayCoin is the name of the coin. 
0 is the number of decimals we should be allowed to use (In this case we can't send half of a JayCoin). 
Jay is the ticker code for the coin.

![Deploy Contract](https://i.imgur.com/9hMmvNr.png)

Click on create, approve the purchase, and sit tight till it confirms. When it's done you should see a box pop up with your token.

## Buying/Selling On An Exchange
You can buy or sell your JayCoin on the Rinkeby Testnet [here](https://etherdelta.com/) by clicking "PPT" at the top and switching it to other and inserting our coin details.

![Etherdelta](https://i.imgur.com/Pm4Ff7E.png)

Step by step instructions on how to create a cryptocurrency.

How To Create Your Own Cryptocurrency

## Disclaimer
In no way am I a financial advisor or an expert in this field. I would only recommend trying out with small amounts you are willing to lose for educational purposes. Along with this, much of crypto is still a wild wild west, which no person or bot can predict.

## Setup
For our trading bot we'll be using Zenbot which describes itself as a "command-line cryptocurrency trading bot using Node.js and MongoDB". You can view the project's [Github here](https://github.com/DeviaVir/zenbot).
This guide assumes a fresh installation of Ubuntu 16.04, but many of these commands can be easily modified to work on other OS's.

### Requirements
- NodeJS

```shell
# This installs the latest version of NodeJS 8 (8.x)
$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs
```
- MongoDB

```shell
# Import the public key used by the package management system.
$ sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2930ADAE8CAF5059EE73BB4B58712A2291FA4AD5

# Create a list file for Mongo
$ echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.6 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.6.list

# Update the package list
$ sudo apt-get update

# Install the latest version of Mongo
$ sudo apt-get install -y mongodb-org

# Start Mongo
$ sudo service mongod start

# To Stop: sudo service mongod stop
# To Restart: sudo service mongod restart
```

### Installing Zenbot
Now we'll clone, and setup the latest version of Zenbot as per it's [Github Repo](https://github.com/DeviaVir/zenbot).
```shell
# Clone the repo
$ git clone https://github.com/DeviaVir/zenbot

# Enter in the folder and copy over the configuration file if needed
$ cd zenbot
$ cp conf-sample.js conf.js
```
Now you'll have to edit the config to fit your use case. You can use nano by running `nano conf.js` or you can use any other tool. Possible customization options:
- Notifications
    - Pushbullet
    - Slack
    - IFTT
    - XMPP
    - Discord
    - Prowl
    - TextBelt
- Exchanges
    - GDAX
    - Poloniex
    - Kraken
    - Bittrex
    - Binance
    - Quadriga
    - Gemini
    - Bitfinex
    - CEX.IO
    - Bitstamp
- Currency Pairs (`$ zenbot list-selectors`)

- Trading Strategies (`$ zenbot list-strategies`)
    - bollinger -
        Buy when (Signal ≤ Lower Bollinger Band) and sell when (Signal ≥ Upper Bollinger Band).
    - cci_srsi -
        Stochastic CCI Strategy
    - crossover_vwap -
        Estimate trends by comparing "Volume Weighted Average Price" to the "Exponential Moving Average".
    - dema -
        Buy when (short ema > long ema) and sell when (short ema < long ema).
    - forex_analytics -
        Apply the trained forex analytics model.
    - macd -
        Buy when (MACD - Signal > 0) and sell when (MACD - Signal < 0).
    - neural -
        Use neural learning to predict future price. Buy = mean(last 3 real prices) < mean(current & last prediction)
    - noop -
        Just do nothing. Can be used to e.g. generate candlesticks for training the genetic forex strategy.
    - rsi -
        Attempts to buy low and sell high by tracking RSI high-water readings.
    - sar -
        Parabolic SAR
    - speed -
        Trade when % change from last two 1m periods is higher than average.
    - srsi_macd -
        Stochastic MACD Strategy
    - stddev -
        Buy when standard deviation and mean increase, sell on mean decrease.
    - ta_ema -
        Buy when (EMA - last(EMA) > 0) and sell when (EMA - last(EMA) < 0). Optional buy on low RSI.
    - ta_macd -
        Buy when (MACD - Signal > 0) and sell when (MACD - Signal < 0).
    - trend_ema (default) -
        Buy when (EMA - last(EMA) > 0) and sell when (EMA - last(EMA) < 0). Optional buy on low RSI.
    - trendline -
        Calculate a trendline and trade when trend is positive vs negative.
    - trust_distrust -
        Sell when price higher than $sell_min% and highest point - $sell_threshold% is reached. Buy when lowest price point + $buy_threshold% reached.

## Running Zenbot with paper trading.
```shell 
# Install NPM dependencies
$ npm install

# Start paper trading
$ ./zenbot.sh trade --paper
# If customized:
$ ./zenbot.sh trade --paper --conf ./conf.js
```
It will now download previous data in order to train the strategy set for the bot. This may take awhile.
![Fetching Previous Data](https://i.imgur.com/iQxCu8H.png)

When it's done you'll see something like this:
![Zenbot in Action](https://i.imgur.com/wNlT1Tx.png)
This chart shows the latest prices of the selector we chose (ex. BTC-USD), along with recent actions the bot has taken.

## Manual Trading
Awesome! We now have a fully functional simulated crypto currency trading bot. If needed you can override the bot and manually set limit buy or sell orders by pressing the keys `B` or `S` respectively. You can cancel these orders if you change your mind by pressing `C`.

## Foreword
If you're looking for more advanced usage, check out the [repository](https://github.com/DeviaVir/zenbot). If you're looking to trade with real money, proceed with utter caution and don't forget about securing your server, database, and exchange account. I hope you found this article helpful and it helped you in your hodling endeavors.

This tutorial will detail over how to setup a cryptocurrency trading bot to automatically trade crypto in order to gain a profit.

Getting Started With Algorithmic Crypto Trading

In this blog post we'll be creating a very simple bot for Instagram, this post assumes a basic understanding and working installation of Python 3.6+. By the end of this post, we will have a working Instagram Bot which will be able to target and follow users, in order to convert them into followers themselves.

## Getting Started
Let's first get everything setup.
```shell
$ mkdir instabot
$ cd instabot
$ pip install -U git+https://github.com/LevPasha/Instagram-API-python
```

## First Steps
Now we'll import modules we need and ask for anything we need. You can fill these out in the terminal, and press enter when you are finished.
```python
from InstagramAPI import InstagramAPI
import time

def ask_for_info():
    """
    Ask the user running this script for certain info we need.
    Returns a dictionary with the answers.
    """
    username = input('What\'s your Instagram Username? ')
    password = input('What\'s your Instagram Password? ')
    num_to_follow = input('How many people should we follow per day? ')
    tags_to_use = [input('What tag should I use? (No #) ')]
    while True:
        more = input('Any more? (Leave blank for no) ')
        if more == '':
            break
        tags_to_use.append(more)

    # This does not validate the username or password, so make sure you enter in the right one!

    return {
            'username': username,
            'password': password,
            'num_to_follow': int(num_to_follow),
            'tags_to_use': tags_to_use
        }
```

## Login to Instagram
Now we can use the username and password we just obtained, to login the bot. This is done by creating the InstagramAPI class, and sending the request to login to Instagram. This function may fail on two major cases:
1. Incorrect Username or Password 
2. You need to verify the login, this can usually by fixed if you open the app and are prompted to verify the login attempt

```python
def login(username, password):
    api = InstagramAPI(username, password) # Instantiate the class
    api.login() # Send a login request
    return api
```

# Targeting
Now we have a logged in Instagram account, it's time to find the targets to follow. We'll search up people who have recently posted a picture using the hashtag(s) you provided before.
```python
def find_targets(api, tag):
    """
    Search for users who have posted a picture with tag, and return a list of user IDs.
    """

    ok = api.tagFeed(tag) # Automatically prints an error
    if not ok:
        raise Exception # Error the script

    resp = api.LastJson
    images = resp['items']

    users = []
    for image in images:
        users.append(
            # We use .get so we can filter out invalid data.
            # Invalid data is rare, but in this case we are prepared
            # pk is ID
            image.get('user', {}).get('pk', '')
        )

    # a list of users from the list of users which id isn't an empty string
    return [u for u in users if u != '']
```

## Following
Great job if you've made it this far! Just to recap, so far we can/have:
1. Imported the required modules
2. Can login
3. Can find targets based off of recent hashtags

Now it's time to follow them, we have to be smart about this as to avoid a ban. So we pause in between follows.

```python
def follow_all(api, targets, time_to_wait):
    """
    Follow all targets, while waiting time_to_wait in seconds
    """
    total_targets = len(targets)
    num = 0
    for t in targets:

        ok = api.follow(t)
        if not ok:
            print('Error while trying to follow ID: %s', t)

        num += 1
        print('Followed %d/%d' % (num, total_targets))
        time.sleep(time_to_wait)
```

## Wrapping it up
Time to bring it all together. We'll ask for your answers, find the targets, and follow each of them.
```python
if __name__ == '__main__':
    answers = ask_for_info()
    print('Thanks!')

    username = answers['username']
    password = answers['password']
    num_to_follow = answers['num_to_follow']
    tags_to_use = answers['tags_to_use']

    api = login(username, password)

    targets = []
    for tag in tags_to_use:
        targets += find_targets(api, tag)
    print('%d Targets Acquired!' % len(targets))

    secs_in_a_day = 86400
    time_to_wait = secs_in_a_day / num_to_follow

    print('Beginning to follow!', 'Make sure you keep an eye on your following count.')
    follow_all(api, targets, time_to_wait)
    print('All Done!')
```

Thanks for reading. If you have any more bot ideas you would like me to go over, comment them below. You can get the full script [here](https://gist.github.com/jaynagpaul/43fe6257a999522086283a41fc9a35b4)

## Credits
- [LevPasha](https://github.com/LevPasha) for writing the InstagramAPI wrapper

Create a working Instagram Bot which will be able to target and follow users, in order to convert them into followers themselves.

Creating a Simple Instagram Bot

## Setup
This guide assumes a working installation and basic knowledge of Python 3.6.x. First we'll install the library used to create automatic type annotations, [MonkeyType by Instagram](https://github.com/Instagram/MonkeyType).
```shell
>>> pip install MonkeyType
>>> pip install pytest
```
Then we'll create our example project to test out MonkeyType. Let's try it out with the fibonacci sequence.
```shell
>>> mkdir fibonacci
>>> cd fibonacci
```

```python
# fibonacci.py
def fibonacci(n):
    if n == 0: 
        return 0
    elif n == 1:
        return 1
    else: 
        return fibonacci(n-1)+fibonacci(n-2)
```

Let's try it out

```py
>>> fibonacci(10)
55
>>> fibonacci('10')
Traceback (most recent call last):
TypeError: unsupported operand type(s) for -: 'str' and 'int'
```

As you can see, this function is expecting for you to pass in an integer for it otherwise it will raise a type error. We can manually add the type annotation to help future consumers of this code, but being humans **and** programmers we often forget.

## Automating It
Great, we now have a file named fibonacci.py in our folder named fibonacci. Let's write a simple test for us to use.
```py
# test.py
from fibonacci import fibonacci as F

def test_fibonacci():
    assert F(10) == 55
    assert F(0) == 0
    assert F(1) == 1
```
We can test this out by running the command `pytest`.

Now it's time for us to collect the call traces. Run the command `monkeytype run test.py`. You should see a new file appear "monkeytype.sqlite3", this is a sqlite database filled with each function call, and the types returned and passed in. We can apply type annotations with the command `monkeytype apply fibonacci`.
Now check out the file fibonacci.py:

```py
def fibonacci(n: int) -> int:
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)
```
**Success!** We have successfully added type annotations to our module with barely any work!

Add type annotations to Python code automatically.

Automatic Type Annotations For Python

Open source social media automation software. Automatically grows an Instagram account organically. Pro plan was sold with additional professional features.

Instahelper

An article aggregator for the Berkeley Coding Academy. Used to create marketing content to garner more students to the academy.

BCA Article Aggregator

Modeled the most efficient budget plan for the Florida Rare Plant Conservation Endowment to maximize their efficiency. Wrote our findings in the PDF linked below. Submitted to HiMCM 2021.

Jay Nagpaul.

Student A self-taught developer with an interest in Computer Science.

⚡ About Me

All Creative Works.

📰 Latest Articles.