
Recently, I'm planning to build a weekend project for personal purposes. It's an application to analyse stock market data for helping me in my investment journey. I plan to use Node.js as the backend. However, I'm curious about how Node.js perform when handling a large dataset. How fast can it do the operation?

To answer that question, I created this scenario:
1. Create an array with 5 million elements with a float data type. It is to simulate the stock price dataset.
2. Calculate the [Simple Moving Average](https://www.investopedia.com/terms/s/sma.asp) for a specific window interval from that dataset. It is the operation that I want to measure.

Here is how I generated the 5 million elements of an array. We won't measure this operation.

```
const simulateClosingPrices = Array.from({length: 5000000}, () => Math.random() * 5000);
```

Below is the code to calculate SMA in JavaScript. I packaged it as a Node module.

<script src="https://gist.github.com/bepitulaz/5fc2b4a2a42b5225e2ea47b098a12883.js"></script>

Here is the execution time.

```
elapsed time:   160.32ms
elapsed user:   124.93ms
elapsed system: 28.68ms
```

#### Can we make it faster?

Hmm...how if I involve [Rust](http://rust-lang.org)? I love that language. It's a system programming language that doesn't have a garbage collector and compile into native code. In theory, it will be faster than JavaScript. To embed and use Rust with Node.js, I have to package it as a Node module. There are two options to do that. First, compile it as a Node native module. The second one, target it for [WebAssembly](https://webassembly.org) and package it as a Node module.

Let's try both options. These are the toolchain to make the Node module with Rust:
- [wasm-pack](https://rustwasm.github.io/wasm-pack/): It's a toolchain to compile Rust code into WebAssembly.
- [node-bindgen](https://github.com/infinyon/node-bindgen): It's a toolchain to compile Rust code into a native module.
- [neon-bindings](http://neon-bindings.com): This one can compile Rust code into a native module too. But, after I tried it, I couldn't reuse my existing Rust code for WebAssembly. I must adjust many parts of it. So, I abandon it.

Below is the code to calculate SMA in Rust and targeting WebAssembly.

<script src="https://gist.github.com/bepitulaz/88eb126ef1dd2ccd80d890aeee0c77a5.js"></script>

Below is the code to calculate SMA in Rust and targeting the native module. In my case, it will compile to `aarch64-apple-darwin` instruction since I ran this benchmark on the Apple M1 processor.

<script src="https://gist.github.com/bepitulaz/870868b5fe5fed87d21911d415a85891.js"></script>

### The result

```
First run
|                           | JS     | WASM  | Native Module |
|---------------------------|--------|-------|---------------|
| elapsed total time in ms  | 160.32 | 81.89 | 1137.70       |
| elapsed user time in ms   | 124.93 | 53.81 | 1106.9        |
| elapsed system time in ms | 28.68  | 22.25 | 74.05         |

Second run
|                           | JS     | WASM  | Native Module |
|---------------------------|--------|-------|---------------|
| elapsed total time in ms  | 144.09 | 75.94 | 1165.27       |
| elapsed user time in ms   | 123.32 | 52.72 | 1109.09       |
| elapsed system time in ms | 22.53  | 23.26 | 84.15         |
```

It is surprised me. My expectation was the native module will perform faster than WebAssembly, but the result was the opposite.  Probably, it happened because I tried to map the JS array directly into the Rust vector. I read some articles it said would be better if I passed the [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) instead of JS array. Let's try it in the next article.

According to this experiment, WebAssembly performs 2x faster for the total time than pure JavaScript when handling this scenario.

_The featured image photo by <a href="https://unsplash.com/@chrisliverani?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Chris Liverani</a> on <a href="https://unsplash.com/s/photos/speed?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>_
  


My company [Tanibox](https://tanibox.com) is developing agriculture software for two years. We focus on [Tania](https://usetania.org), our open source farm management software. We love growing plants, but we--all co-founders of Tanibox--never touch agriculture as an industry before Tanibox exist. So, we jumped to agriculture technology industry by trial and error. Here are some interesting insights from a couple of years building an open source software for agriculture to share with you.

![Farmers](https://images.unsplash.com/photo-1500937386664-56d1dfef3854?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=800)
<a style="background-color:black;color:white;text-decoration:none;padding:4px 6px;font-family:-apple-system, BlinkMacSystemFont, &quot;San Francisco&quot;, &quot;Helvetica Neue&quot;, Helvetica, Ubuntu, Roboto, Noto, &quot;Segoe UI&quot;, Arial, sans-serif;font-size:12px;font-weight:bold;line-height:1.2;display:inline-block;border-radius:3px" href="https://unsplash.com/@wflwong?utm_medium=referral&amp;utm_campaign=photographer-credit&amp;utm_content=creditBadge" target="_blank" rel="noopener noreferrer" title="Download free do whatever you want high-resolution photos from Warren Wong"><span style="display:inline-block;padding:2px 3px"><svg xmlns="http://www.w3.org/2000/svg" style="height:12px;width:auto;position:relative;vertical-align:middle;top:-2px;fill:white" viewBox="0 0 32 32"><title>unsplash-logo</title><path d="M10 9V0h12v9H10zm12 5h10v18H0V14h10v9h12v-9z"></path></svg></span><span style="display:inline-block;padding:2px 3px">Warren Wong</span></a>

**1. Most farmers are old and not a tech-savvy**

We build open source software. Our early adopter is mostly a software or hardware developer and tech enthusiast coming from several countries. The countries that I can notice because they are active in our forum: Indonesia, India, USA, UK, UAE, Hungary, Tajikistan, Canada, France, Sweden, Lithuania, and Brazil. Since we get hundreds of download for this couple of years, perhaps there are more people from other countries, but they are not active in the forum so that I can't notice.

Some of the early adopters are the developer that wants to sell and distribute our software to the farmer in their country. Most of them told the same issue that is hard to convince the farmer to digitalise their operation because most of the farmers are old and not tech-savvy. We also get that issue when introducing the software here in Indonesia.

The solution for this is to approach the younger farmer because they are more open-minded than the old one and we must lower barriers to entry.

**2. Digitalisation won't promise rich**

"If I use your software,  how many yields and profit it can increase? When is the break-even point? ", this type of question is usually coming from my country, Indonesia. It's hard to answer because it depends on your business operation. Digitalisation will help you to record your farm operation better. Then you can analyse which aspect of your farm to make it more efficient after several growing cycles.

Anyway, do you ask Microsoft with this type of question, "Hey, if I buy your Windows license, how many % of profit you can increase for me?".

**3. Localisation is important**

If you want to target the global market, you have to think about the localisation of your software since day one. Our mistake was not doing this as early as possible, so our market penetration is a little bit slow. Lucky for us, there are not many open source software for agriculture in the market. We support localisation in Tania 2 years after launch in version 1.6.

Even for the European market, most people including us are thinking of Europe as a single market. Yes, it is for a few aspects. But, Europe consists of many languages and most of the farmers, especially in the countryside, don't speak English.

**4. Offline first**

The countryside and the rural area are farms mostly located. The online connectivity can be an issue there. If you are building something for agriculture, think offline first. We do it when developing Tania.

**5. Most of the world's farms are small and family-run**

In terms of volume, it means this type of farmer is the lucrative market. It spreads across the globe. But, chasing this type of farmer is challenging though because the small-holder farmer is usually price-sensitive. The cost of your solution should be as low as possible.

### Conclusion
Agriculture is the slowest industry that adapts the new technology. I hope these insights are useful for anyone interested to jump in into building an agriculture technology solution.



It's been a while since my last post on this website. Three years ago. It's time to dust off and start writing again. I want to challenge my self, "how if I make this blog like a social media?" I will prioritise to post anything here instead of posting in social media whether it's a short or long content.

This blog post is the first attempt. Wish me luck with the idea!

![Typewriter](/images/type-writer.jpg)

<a style="background-color:black;color:white;text-decoration:none;padding:4px 6px;font-family:-apple-system, BlinkMacSystemFont, &quot;San Francisco&quot;, &quot;Helvetica Neue&quot;, Helvetica, Ubuntu, Roboto, Noto, &quot;Segoe UI&quot;, Arial, sans-serif;font-size:12px;font-weight:bold;line-height:1.2;display:inline-block;border-radius:3px" href="https://unsplash.com/@julsssy?utm_medium=referral&amp;utm_campaign=photographer-credit&amp;utm_content=creditBadge" target="_blank" rel="noopener noreferrer" title="Download free do whatever you want high-resolution photos from Julienne Erika Alviar"><span style="display:inline-block;padding:2px 3px"><svg xmlns="http://www.w3.org/2000/svg" style="height:12px;width:auto;position:relative;vertical-align:middle;top:-2px;fill:white" viewBox="0 0 32 32"><title>unsplash-logo</title><path d="M10 9V0h12v9H10zm12 5h10v18H0V14h10v9h12v-9z"></path></svg></span><span style="display:inline-block;padding:2px 3px">Julienne Erika Alviar</span></a>



In [part 1](/posts/introduction-to-functional-programming-in-javascript-part-1/), we had learned about two important concepts in functional programming paradigm: immutable data and pure function. Now, we will learn another important concept in functional programming, that is higher order function.

According to Wikipedia, higher-order function is a function that does at least one of the following:

*   takes one or more functions as arguments
*   returns a function as its results.

JavaScript has the first-class function. It means the functions in JavaScript treats as a value, that we can assign it to the variable, pass it around, and return from another function. Therefore, JavaScript supports higher order function. I'm sure every JavaScript programmer ever used higher order function in their life. If you ever used jQuery, you must be familiar with these syntaxes:

```javascript
$.get("my-api-url.com", function(res) {
  console.log(res);
});

// or

$("#my-awesome-button").click(function(evt) {
  evt.preventDefault();
});
```

Those are the sample implementations. We passed the function as an argument to another function.

**Map, Filter, and Reduce**

`Map`, `filter`, and `reduce` are three methods those are natively available in most browsers and in NodeJS. We will intensively use these methods when doing functional programming in JavaScript and also in any programming language.

`Map` takes a function and collection of items, runs the function on each item in the collection, and returns a new collection as the result. This is the simple example of `map`.

```javascript
let sample = [1, 2, 3]; // I want add each item by 1

// we pass an anonymous function to the map
let mapResult = sample.map((item) => {
  return item + 1;
});

console.log(mapResult); // [2, 3, 4]
console.log(sample); // the original data does not change: [1, 2, 3]
```

So, actually, we did not need to implement it by our self like we did in part 1 of this article -- the `pureFunction` section.

Next is `filter`. It takes a function and a collection, runs the function on each item in the collection, returns a new collection when the function returns `true`. This is the simple example of `filter`.

```javascript
let sample = [1, 2, 3]; // I want the even number only

let filterResult = sample.filter((item) => {
  return item % 2 === 0;
});

console.log(filterResult); // [2]
console.log(sample); // the original data does not change: [1, 2, 3]
```

The later is `reduce`. It takes a function and a collection of items,and returns the value by combining the items. This is the simple example of `reduce`.

```javascript
let sample = [1, 2, 3]; // I want to sum all the items

let reduceResult = sample.reduce((prev, current) => {
  return prev + current;
});

console.log(reduceResult); // 6
console.log(sample); // the original data does not change: [1, 2, 3]
```

The advantage of using `map`, `filter`, and `reduce` is you can easily chain all those function with predictable behaviour. This is the sample case to use it all together.

```javascript
let leads = [{
  name: "Acme Company",
  isDeal: true,
  currency: "USD",
  deal: 150
}, {
  name: "Seven Eleven",
  isDeal: false,
  currency: "IDR",
  deal: 1000000
}, {
  name: "Cozyfield",
  isDeal: false,
  currency: "IDR",
  deal: 2500000
}, {
  name: "Froyo Agency",
  isDeal: false,
  currency: "USD",
  deal: 2000
}];

// get all data with USD, change the currency symbol to $
let getUsdOnlyWithDollar = leads.filter((item) => {
  return item.currency === "USD";
}).map((item) => {
  return {
    name: item.name,
    isDeal: item.isDeal,
    currency: "$",
    deal: item.deal
  };
});

// [{ name: 'Acme Company', isDeal: true, currency: '$', deal: 150 },
// { name: 'Froyo Agency', isDeal: false, currency: '$', deal: 2000 } ]
console.log(getUsdOnlyWithDollar);

// get all data with isDeal is false, convert all USD currency to IDR
// 1 USD = IDR 13000, then sum all the amount of expected deal
let calculateIt = leads.filter((item) => {
  return !item.isDeal;
}).map((item) => {
  let result = {
    name: item.name,
    isDeal: item.isDeal,
    currency: item.currency
  };

  if(item.currency === "USD") {
    result.deal = item.deal * 13000;
  } else {
    result.deal = item.deal;
  }

  return result;
}).reduce((prevItem, currItem, index, array) => {
  return {deal: prevItem.deal + currItem.deal};
});

console.log(calculateIt); // { deal: 29500000 }
```

**Currying**

We won't cook that spicy and exotic cuisine for now. Currying is the process of transforming a function that takes multiple arguments into a function that takes only a single argument and returns another function if the arguments are still needed. Take a look at these two code snippets:

```javascript
let greeting = (message, name) => {
  return message + " " + name;
};

console.log(greeting("Hello", "Asep")); // "Hello Asep"
console.log(greeting("Hello", "Bagja")); // "Hello Bagja"
```

We already familiar with that syntax, nothing wrong with that. Now the curried version for that greeting function.

```javascript
let curriedGreeting = (message) => {
  return (name) => {
    return message + " " + name;
  }
}

let sayHello = curriedGreeting("Hello"); // this is partially applied function
console.log(sayHello); // it returns a function
console.log(sayHello("Asep")); // "Hello Asep"
console.log(sayHello("Bagja")); // "Hello Bagja"

// you can also call it directly by using another parentheses
curriedGreeting("Hello")("Asep"); // "Hello Asep"
curriedGreeting("Hello")("Bagja"); // "Hello Bagja"
```

At the moment we invoke `curriedGreeting` with only one argument, it will return the next function that still waiting to be invoked by the second argument. After the second argument is passed to the function, we will get our expected return value.

That looks so cool, but why we want to do that? It's not straightforward, is it? Ok, let me show you a use case that can be considered to use this technique.

```javascript
let callAPI = () => {
  // Do the web service call here. Let's assume it returns an array of objects
  return [{
    name: "Brio",
    manufacturer: "Honda"
  },
  {
    name: "Avanza",
    manufacturer: "Toyota"
  },
  {
    name: "Innova",
    manufacturer: "Toyota"
  }];
};

// Filter the data with curried function
let filterData = (fn) => {
  return (manufacturer) => {
    return fn.filter((item) => {
      return item.manufacturer === manufacturer;
    });
  }
}

// call the web service only one time
let filterBy = filterData(callAPI());

// then we can use the result multiple times
console.log(filterBy("Toyota"));
console.log(filterBy("Honda"));
```

Currying is a useful technique in functional programming. It can avoid repetition in our code, thus makes the code more efficient. I encourage you to play and use it in your JavaScript code.

**Summary and What's Next?**

JavaScript supports higher-order function very well. It makes JavaScript suitable to apply some techniques from functional programming paradigm, and we can combine it with the knowledge that we had learned from the [part 1](http://asepbagja.com/introduction-to-functional-programming-in-javascript-part-1/) of the article to make our code more brevity.

Learning functional programming won't hurt you. I encourage you to learn a programming language that specifically designed for it because many techniques and concepts are hard to explain or do in JavaScript. You can pick Haskell, Clojure, Scala, Elixir, OCaml, etc. By knowing imperative programming and functional programming you will get the best of both worlds.

Hope you enjoy this series of introduction to functional programming.



Imperative programming is a programming paradigm that uses a sequence of statements to reach a certain goal. It focuses on how to perform actions to achieve the expected result. Otherwise, functional programming paradigm concentrates on computing results rather than performing actions. In another word, the imperative one is an annoying micromanager in your office, and the functional one is a macromanager who just describe what's the job to be done.

Imagine this situation. You are asked by your boss to get 3 sales leads by the end of the week. The approach will be distinctive by those 2 paradigms.

The imperative boss will micromanage you by telling you something like these:

1.  Open Craigslist
2.  Find the phone number
3.  If you find it, please dial that number
4.  Tell to the prospective client, "Hello, I'm from annoying company...bla...bla..."
5.  If you can't find the phone number, you should seek the email address
6.  Send them an email with this sentence, "Hello, I'm from annoying company...bla...bla..."
7.  When you can't find the contact in Craiglist, you should try open Yellow Pages
8.  Schedule a meeting at Wednesday afternoon with the prospective client
9.  ...and so on, until you get 3 sales leads by the end of the week.

The functional boss will tell something more descriptive without micromanaging you:

1.  That is a computer with internet connection on the desk, you can use it to find and contact some leads
2.  You can use office phone to call them
3.  Schedule a meeting whenever you feel it is necessary
4.  Return back to me after you get 3 sales leads by the end of the week.

After we get distinctive between those 2 paradigms, now we will try to implement it in JavaScript. JavaScript currently is one of the hottest and mainstream programming languages which support multi-paradigms. So, we can use it to program in a functional way, while using the imperative features whenever necessary.

**The first pillar of FP: think about immutable data**

Immutable data means the data can't be modified after its creation to avoid side effects. JavaScript does not force us to use immutable data like any other programming language specifically designed for functional programming, therefore we should force our self to think about immutability when programming with the functional paradigm. Consider this mutable code:

```javascript
// 1: simple mutable data sample
let x = 10; // create the initial value
x = x + 1;
console.log(x); // now x's value is 11

// 2: the mutable loop
let sample = [1, 5, 3, 2];
for(let i = 0; i < sample.length; i++) { // the i's value is changing on each iteration
  sample[i] = sample[i] + 1;
}
console.log(sample); // now sample's value is [2, 6, 4, 3]
```

It's hard to spot the bugs in a large code base with many mutable data. Do you remember the micromanaging boss? Yes, it's kinda like that. According to sample number 2 above, we will read the loop 4 times to track the current value of `sample`. Imagine if you have an array with 1000 elements inside it. Have fun with that.

**The second pillar of FP: Pure Function**

A pure function is a function that does not depend on and modifies the states of the variable out of its scope. It means the function always returns the result given same parameters and produces no side effects. I will give you an example to understand about "side effect".

```javascript
let sample = [1, 2, 3]; // I want each element of this array add by 1.

function impureFunction(data) {
  for(let i=0; i < data.length; i++) {
    data[i] = data[i] + 1;
  }
  return data;
}

let result = impureFunction(sample);
console.log(result); // You get what you want: [2, 3, 4]
console.log(sample); // But you get the side effect too. The value has been changed :(
```

You can think the side effect in code is the same as the side effect in medicine. When you drink cough syrup, your cough maybe stops, but after that, you will feel sleepy. In a large code base, the impure function will hard to test and debug. So, we will rewrite that by using pure function and immutable data.

```javascript
let sample = [1, 2, 3];

function pureFunction(data, index, init) {
  if(index < data.length) {
    let current = [data[index] + 1];
    let result = init.concat(current);
    return pureFunction(data, index + 1, result); // we use recursion instead of for loop
  } else {
    return init;
  }
}

let result = pureFunction(sample, 0, []);
console.log(result); // you get what you want: [2, 3, 4]
console.log(sample); // your original data does not mutate: [1, 2, 3]
```

According to the code above, we are making a new array instead of mutating the original one. We also use recursion to avoid side effect. Let's scrutinize the `pureFunction` function to understand it.

```javascript
// pureFunction takes 3 parameters: data, index, init
// pureFunction will create a new array as a return value
pureFunction(data, index, init) {
  return init;
}

// The type signature of pureFunction actually like this
// I'm using Haskell type signature syntax, since JavaScript is dynamic typing
pureFunction :: [Int] -> Int -> [Int] -> [Int]

// data is for our original array
// index is for the index of the array
// result is our copy of original array
// so if we call the function, the operation actually like this
pureFunction([1, 2, 3], 0, []);

pureFunction(data, index, init) {
  let current = [data[0] + 1];
  let result = init.concat(current);
  return result; // it is [2]
}

pureFunction([1, 2, 3], 1, [2]);

pureFunction(data, index, init) {
  let current = [data[1] + 1];
  let result = init.concat(current);
  return result; // it is [2, 3]
}

// and so on
```

That is the explanation of pure function. What you give is what you get. It does not depend on to any variable outside its scope. So, we can test and debug the function easier.

**Summary**

In this first part, we had changed our way of thinking to express our idea to achieve the result. We have learned about immutable data and pure function to avoid side effect and made our code more concise. Those are still basic things before we dive deeper to learn about functional programming in JavaScript (or in another language). Hope you enjoy it and see you in the next part.

P.S. [The second part](/posts/introduction-to-functional-programming-in-javascript-part-2/) of this article has been published.



Google announced that they use HTTPS as a ranking signal [on 2014](https://webmasters.googleblog.com/2014/08/https-as-ranking-signal.html), and it becomes more standard in their search result. Therefore, I decide to use HTTPS also for this blog; and it looks pretty too for having a green lock icon on the browser. I'm a Docker devotee, so I'll show you how to do it by using Docker.

**1. Install Docker on the server**

I'm using Ubuntu 16.04 on my [Digital Ocean](https://m.do.co/c/603d8d4e7ded) droplet. So, you can follow Docker official installation guide for Ubuntu on their documentation page [here](https://docs.docker.com/engine/installation/linux/ubuntulinux/).

**2. Run Let's Encrypt companion for Nginx proxy container**

Before running this container, I will shortly explain what Let's Encrypt is, in case you never heard it. Taken from its website, it is a free, automated, and open certificate authority (CA), run for the public's benefit. Let's Encrypt is a service provided by the [Internet Security Research Group (ISRG)](https://letsencrypt.org/isrg/). Hence, we don't need to buy and manually renew the SSL certificate anymore.

I assume you are at the home folder (/home/user/). You should create a directory for storing the certificates.

```
/home/user/:$ mkdir certs
```

Then, you will run Nginx as the proxy server for our WordPress container. I'm using Nginx proxy image which is maintained by [jwilder](https://github.com/jwilder/nginx-proxy).

```
/home/user/:$ docker run -d -p 80:80 -p 443:443 \
  --name nginx-proxy \
  -v /home/user/certs:/etc/nginx/certs:ro \
  -v /etc/nginx/vhost.d \
  -v /usr/share/nginx/html \
  -v /var/run/docker.sock:/tmp/docker.sock:ro \
  jwilder/nginx-proxy
```

If you look the command above, 3 writable volumes are declared:

*   `/etc/nginx/certs` is for creating and renewing Let's Encrypt certificates
*   `/etc/nginx/vhost.d` is for changing the configuration of vhosts, and it's needed by Let's Encrypt
*   `/usr/share/nginx/html` is for writing challenge files, so Let's Encrypt can verify your domain.

After the Nginx proxy container is running, you will run Let's Encrypt container to create and renew the certificate for each domain that you want to add the SSL certificate. I will use the Let's Encrypt image which is maintained by [JrCs](https://github.com/JrCs/docker-letsencrypt-nginx-proxy-companion).

```
/home/user/:$ docker run -d \
  -v /home/user/certs:/etc/nginx/certs:rw \
  --volumes-from nginx-proxy \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  jrcs/letsencrypt-nginx-proxy-companion
```

Ensure those 2 containers are running by using `docker ps` command. Then you can start any containers to be proxified with https connection by using this command:

```
/home/user/:$ docker run -e "VIRTUAL_HOST=yourdomain.com" \
  -e "LETSENCRYPT_HOST=yourdomain.com,www.yourdomain.com" \
  -e "LETSENCRYPT_EMAIL=your@youremail.com" \
  ... # put the rest of the necessary settings here
```

The `LETSENCRYPT_HOST` and `LETSENCRYPT_EMAIL` are necessary, so Let's Encrypt service can automatically create and renew valid certificate for each virtual host.

**3. Install MySQL database**

I'm using [MySQL official image](https://hub.docker.com/_/mysql/). I'm storing the MySQL data in host directory to prevent data loss when the container restart or die.

```
/home/user/:$ mkdir data

/home/user/:$ docker run --name wp_mysql \
  -v /home/user/data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=my-secret-pw \
  -e MYSQL_USER=my-user \
  -e MYSQL_USER_PASSWORD=my-password \
  -e MYSQL_DATABASE=wordpress -d mysql:latest
```

For my case, I'm importing my MySQL dump from the old WordPress setup to the MySQL container.

```
/home/user/:$ docker exec -i wp_mysql mysql -umy-user -pmy-password wordpress < dump.sql
```

**4. Containerize the Old WordPress Setup**

I'm not using WordPress official image since this is an existing blog, not a new one. So, I re-arrange my WordPress directory structure before containerizing it. Here is the structure.

```
wordpress_root
| src (for wp-content, wp-include, and the entire WordPress files)
| Dockerfile
```

This is my Dockerfile. I'm using PHP7 Apache as a base image.

```
FROM php:7-apache

MAINTAINER Asep Bagja Priandana <asep@asep.co>

RUN a2enmod rewrite expires

# install the PHP extensions we need
RUN apt-get update && apt-get install -y libpng12-dev libjpeg-dev && rm -rf /var/lib/apt/lists/* \
	&& docker-php-ext-configure gd --with-png-dir=/usr --with-jpeg-dir=/usr \
	&& docker-php-ext-install gd mysqli opcache

# set recommended PHP.ini settings
# see https://secure.php.net/manual/en/opcache.installation.php
RUN { \
		echo 'opcache.memory_consumption=128'; \
		echo 'opcache.interned_strings_buffer=8'; \
		echo 'opcache.max_accelerated_files=4000'; \
		echo 'opcache.revalidate_freq=60'; \
		echo 'opcache.fast_shutdown=1'; \
		echo 'opcache.enable_cli=1'; \
} > /usr/local/etc/php/conf.d/opcache-recommended.ini

COPY src/ /var/www/html/
```

Then modify the existing `wp-config.php`.

```
// Don't hardcode your DB setting. Instead use environment variable.
/** The name of the database for WordPress */
define('DB_NAME', getenv('WORDPRESS_DB_NAME'));

/** MySQL database username */
define('DB_USER', getenv('WORDPRESS_DB_USER'));

/** MySQL database password */
define('DB_PASSWORD', getenv('WORDPRESS_DB_PASSWORD'));

/** MySQL hostname */
define('DB_HOST', getenv('WORDPRESS_DB_HOST'));

// Add these 2 lines, because we are running the Apache behind Nginx proxy
// Otherwise you will get infinite redirect
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https')
  $_SERVER['HTTPS']='on';

if (isset($_SERVER['HTTP_X_FORWARDED_HOST'])) {
  $_SERVER['HTTP_HOST'] = $_SERVER['HTTP_X_FORWARDED_HOST'];
}
```

Now, you can build your custom WordPress image.

```
/home/user/:$ docker build -t user/my_wordpress .
```

**5. Run the WordPress Image**

Let's run the newly created image.

```
/home/user/:$ docker run --name my_wordpress \
  --link wp_mysql:mysql \
  -e WORDPRESS_DB_USER=my-user \
  -e WORDPRESS_DB_PASSWORD=my-password \
  -e WORDPRESS_DB_NAME=wordpress \
  -e "WORDPRESS_DB_HOST=172.17.0.3" \
  -e "VIRTUAL_HOST=yourdomain.com" \
  -e "LETSENCRYPT_HOST=yourdomain.com,www.yourdomain.com" \
  -e "LETSENCRYPT_EMAIL=your@youremail.com" -d user/my_wordpress
```

Be careful, WORDPRESS_DB_HOST is your MySQL container's IP address.

**6. Pointing your domain to the host**

Now you can open your DNS manager and point the A record to your host IP and make www CNAME record with @ value. After the DNS propagation has completed and everything is correctly configured, you can access your website and see the little green lock icon on your browser.

**7. The last is configuring the URL inside your wp-admin**

Login to your WordPress dashboard then goes to Settings > General. Replace the http with https.

![wordpress](wordpress.png)

Voila, now your WordPress site has ben secured and Google will love it.



Most of you perhaps ever heard or read about [The Cashflow Quadrant](http://www.amazon.com/exec/obidos/ASIN/0446677477/mikeleeorg-20) by Robert Kiyosaki. I bought his book when I was a high school student. The book explained about quadrant of economic roles: employee, self-employed, business owner, and investor. The employee is people who have a job, I was. The self-employed is individuals who own a job, I was. The business owner is individuals who have a system that produces cash flow for themselves and other work for them; this is me now. The last is the investor, people who can make their money work for them; this is my next target.

To pursue that level, I should find a way to invest my money. So, last month, I decided to attend Sekolah Pasar Modal. It is a one day course which is held by Indonesia Stock Exchange. The course fee took only Rp 100.000, and the fee would be returned to the course attendees as balance in their investor account. Sekolah Pasar Modal is divided into 2 level. The first level is an overview of the stock market, shares, and the mechanism to start trading the stock. The second level is about the basic of fundamental analysis and technical analysis.

Technical analysis is for someone who wants to be a stock trader. It is a skill for reading charts as the primary tool to predict the market. Frankly, I'm not interested become a stock trader, or moreover to be a daily trader. My goal is to make a long-term investment. Buy a company's stock at the right price and hold it for a long time, and exit at the right moment. So, the primary skill should be a fundamental analysis. It is an ability to assess a company health by looking and analyzing its financial statement and its other essential data.

As Master Oogway said in Kungfu Panda 3, "If you only do what you can do, you will never be more than you are." So, now I re-open my knowledge from my accounting education background to be more than I am.



**Happy new year 2016.**

Annually I challenged myself with some new skills and some targets. Few years ago, I challenged myself to learn Mandarin, because it is the most spoken language in Asia. Therefore, I took a Mandarin short course and also self-learning it via Youtube.

I had also challenged myself to learn functional programming paradigm and tried to master one of the programming languages that used that paradigm. My choice was Clojure because it is using Lisp dialect. I was coming from PHP and JavaScript, so I should learn another dialect for broadening my horizon. Maybe now I'm still far to be a master of Clojure (LOL); but at least, I'm fluent coding with it.

In 2016, I'll give some challenges again for myself:

1.  Learning another programming language. The requirement is static typing, compiled to native code, and using different dialect from Lisp and C-based syntax. My choice will be OCaml, it is coming from ML (Meta Language) dialect. The target is I should deploy at least one production system which is written in OCaml.
2.  Learning Finnish. The target is hunting the northern lights from Lapland with my wife and communicating with Finnish people in Finland.
The number 2 is the hardest, but challenges are needed to push me beyond the limit. I'll write the progress here.

**Challenge accepted!**



I have a small green house in [my home front yard](https://asep.co/my-familys-journey-to-grow-our-own-food/), and I deployed some sensors like temperature, humidity, electrical conductivity (EC), and pH sensor there.

After the development of the sensors completed, it was the time for me to develop the web service for logging the data. I considered to use NoSQL database for persistent data storage. Otherwise I dismissed that idea for the sake of cost efficiency.

To use NoSQL database, I should open one or two servers in cloud provider for running it. As we know, the cost for compute engine is charged per hour. Let's pick AWS EC2 for the example. T2.small instance pricing is $0.04/hour. That's too expensive for non-profit purpose.

**The solution**

I decided to make my own NoSQL solution. Persisted all data logs to plain text and put it on AWS S3. That's cheaper, because S3 is storage server and it is charged per GB. For the first 1 TB, it only costs me $0.02/GB. It will takes a long time to reach 1 GB, if only for saving plain text.

The concept is simple. Just catch the string from the sensor, transform it into Clojure data structure, and save it inside the plain text file. To query it back, I just need to read the plain text file, transform the string back into Clojure data structure, and do the computation.

Here is the snippet code for writing and querying the data.

```
(ns data-logging.core
  (:require [clojure.string :as str]
            [clojure.walk :as walk]
            [clojure.java.io :as io]
            [clj-time.coerce :as coerce]
            [clj-time.local :as l]))

(defn data-parser
  "Parsing data from sensor."
  [raw-string]
  (let [split-data (str/split raw-string #",")
        flatten-data (->
                      (map #(str/split % #"=") split-data)
                      (flatten))]
    (-> (apply hash-map flatten-data)
        (walk/keywordize-keys))))

(defn write-today-log
  "Write today log file."
  [sensor-data file-name]
  ;; check if file already exist
  (if (io/.exists (io/as-file file-name))
    ;; exist: append new hash map to vector.
    (let [existing-data (read-string (slurp file-name))]
      (spit file-name
            (with-out-str
              (pr
               (conj existing-data (data-parser sensor-data))))))
    ;; not exist: create new file and insert the vector of hash map.
    (spit file-name
          (with-out-str
            (pr (conj [] (data-parser sensor-data)))))))

(defn search-log
  "Search data between two times."
  [start-time end-time file-name]
  ;; update the date time string to timestamp
  (let [log-data (read-string (slurp file-name))
        with-timestamp (map
                        #(update-in % [:datetime] coerce/to-long)
                        log-data)]
    ;; let's find the data!
    (let [result (filter #(and
                           (> (:datetime %) (coerce/to-long start-time))
                           (< (:datetime %) (coerce/to-long end-time)))
                         with-timestamp)]
      ;; here is the result
      (map #(update-in % [:datetime]
                       (fn [x]
                         (l/format-local-time
                          (coerce/from-long x)
                          :mysql))) result))))
```

This is how to use it.

```
;; Saving the sensor data
(write-today-log "sensorid=123,temp=31.52,humidity=45.4,datetime=2015-12-08 17:31:30" "today-2015-12-08.log")

;; Querying the data
(search-log "2015-12-08 14:00:00" "2015-12-08 19:00:00" "today-2015-12-08.log")
```

Someday if I can get profit from my greenhouse and I need to scale this system, I just need to export the log into another data storage technology. It's simple, cheap, and scalable.



[Geekcamp Jakarta 2015](http://geekcamp.id/) is a technology and business conference organized by KMKLabs. This is my presentation about computer generated music using Clojure and Overtone. The talk is using Bahasa Indonesia, but here I try to give the English transcript.

<iframe class="vidio-embed" src="https://www.vidio.com/embed/178403-geekcamp-lambda-jakarta" width="560" height="317" frameborder="0" scrolling="no" allowfullscreen="allowfullscreen"></iframe>

**Transcript**

[00:20] I want to talk about music. Who loves music here? I'm sure many of you loves music.

[00:27] Are there many programmers here? Because it will relates with code also.

[00:36] First, I will introduce myself. My daily job is a CTO in Froyo, it's my digital marketing agency, its office is located in Bintaro. I'm also an organizer of Lambda Jakarta, it's functional programming meetup. We are discussing about Haskell, Clojure, Scala, F#, you name it. All about functional programming.

[01:06] If you look at the bottom of the slide, you can see if actually I want to be a farmer. I have private greenhouse at my home and I'm also a seasonal bedroom musician.

[01:26] This is the usual way to play music. Oh, It is my favorite band, Dream Theater. You must be play using real instrument, such as guitar, keyboard, drum, and so on.

[01:40] But, I think it will be more interesting if we can play music using a computer. We will use the programmer's way. Our instrument will be the text editor. Is it looking weird for you? Yes, it is. With the text editor, we can generate music with various sounds.

[02:06] I'm using Clojure for the programming language. Clojure is a Lisp implementation on top of Java Virtual Machine. Before we continue this talk, anybody here knows Lisp? Ok, you know it, you know it, ah you, my downline, must be know it.

[02:26] Clojure is a slightly young Lisp implementation. Released in 2007, and created by Rich Hickey. Maybe if there's someone here who has not known it, this is the Clojure code looks like. 90% of Clojure code is like that. Just call function with argument, argument, whatever argument, and so on. 90%. The rest of 10% is knowing about symbol, keyword, string, vector, map, and atom if you need mutable. Because Clojure in default is actually immutable.

[03:26] This is the simple sample code. `defn` is a function definition, parameter is a vector,`let` for local scope variable, `if` for condition, and it return true and the else is false. How to call the function? You just call the function name and put the parameter. That's it.

[04:17] Then, for the sound engine we will use Overtone. It utilises SuperCollider engine. Maybe if any of you here is a game developer, there's a chance you have heard about it. You can use it for sound synthesizing and mimicking the real instrument.

[04:53] Let's try hello world. The hello world is slightly different.

[05:14] If you know about sound design or synthesizer, actually sound is coming from sine wave, square wave, saw wave, and triangle wave. Each of them has different timbre. Let's start from sine wave.

[05:48] _typing_

[06:30] If you notice, in sine wave function you'll see frequency, attack, sustain, and release parameter. If any of you here is play in a band, there's a chance you have seen knobs on the keyboard or synthesizer to set those parameters. Attack to set how fast the tone will reach the peak, sustain to set how long the tone, and release to set how long the tone will disappear.

[07:17] _trying the waveform one by one_

[08:37] There's also noise. Just a noise sound.

[09:03] We can combine all of it to be more interesting sound like in subtractive synthesis technique.

[09:16] Let's try the simple one. Frequency modulation synthesis. A waveform that modulated by another waveform. It is like Yamaha DX-7 synthesizer. It's a breakthrough sythesizer in 80's. Here it is.

[10:28] The second sample. We can play the sampler. So, in Overtone we can also use recorded sound to be played.

[10:57] _typing_ Like this. Kick drum, snare drum, piano, or maybe guitar loop.

[11:50] We can also play chords. But, it is insane to type line by line if you play in live situation. You won't make it.

[12:09] So the better way is creating the sequencer. Sequencer is a tool to play sound loop. Now, I'm trying to make piano and drum loop.

[12:44] Left hand.

[12:50] Then the right hand.

[13:00] Then we add the drum loop.

[13:18] It's no problem if we add a synth sound that we had created before it.

[13:34] Ah I have to finish the demo, because the time is over now. Actually, you can use Overtone for recording, composing a song, or connect it to midi device.

[14:28] At last, let's jamming on Github. So, jamming is not only in music studio, we can music jamming also in Github.

**Slide and Sample Code**

The slide is using English. You can read on [Slideshare](http://www.slideshare.net/AsepBagja/geekcamp-id-2015-programmable-music).

You can also see the sample source code on [Github](https://github.com/bepitulaz/programmable-music).



My wife's dream after we married was having a garden at home. But at that moment, we were living in an apartment with a very small balcony. It's theoritically impossible to plant anything. So, we discovered a way to plant vegetable at small space and we found it. Hydroponic was the answer. We can plant without soil but only water.

**The Age of Farming in The Apartment**

At the first time, we were growing spinach. It sprouted fast, only need 3 days to see the small leaves. After around 7 days, we were moving the sprouts to the hydroponic system for growing it. We chose wick system, the very simple hydroponic system. Instead of growing, the spinach was wilting.

The second time, we were growing lettuce. Because we read about lettuce is the easiest vegetable for hydroponic beginner. At that time, we added LED growing lamp to our hydroponic system, because we knew that our vegetables was getting lack of sun light. But we still got the same result like before, the lettuce was wilting.

![first-prototype](/blog-img/simple-hydroponic.jpeg)

We tried another shot. I forgot how many times we tried to grow vegetables in the apartment and got so many failures. At last, we knew the failure came from the temperature and the humidity. The temperature inside our flat were too high and the humidity level were too dry.

**The Age of Farming in The Greenhouse**

Few months ago, after we were living in the apartment for a year. We were moving to the new house. A house on the ground. At that time, Indonesia was in dry season. So, we got an idea to build our greenhouse at the front yard to isolate all the vegetables from the outside and also to easily controlled the temperature and the humidity.￼

![Build the small greenhouse.](/blog-img/build-greenhouse.jpeg) Build the small greenhouse.

We are building our NFT (Nutrient Film Technique) system as a growing system for lettuce and kale. We are also building the drip system for tomato, eggplant, and cucumber. The result is satisfying. All the vegetables grow healthy and can be harvested.

Our greenhouse is not only for growing vegetables, that is also the place for me to learn IoT (Internet of Things) application development. Hydroponic farming is a suitable area for implementing the power of internet connected sensor and machine learning, because it generates a lot of data e.g., air and water temperature, humidity, EC (electric conductivity) of water, and PH.

![iot-implementation](/blog-img/iot-implementation.jpeg) The internet of thing implementation.

**Why We Do All That Things?**

We used to buy vegetables in supermarket - don't ask why we are not going to traditional market. Usually vegetables in supermarket is not too fresh, and the price is also high-priced, especially for hydroponic vegetables. Thus, why we learn to grow our own food.

Despite that reason, successfully growing our own food is like getting a new life achievement. Maybe we are getting one step ahead to prepare our self for zombie apocalypse, nuclear war, or living on Mars.

![growing-lettuce](/blog-img/growing-lettuce.jpeg) We are growing lettuce.



_A letter from my dad about how to make my company bigger._

My dad was a government auditor for 35 years plus. He never expected me to be an entrepreneur. At the first, he did not support me, but now he is the one who regularly give me advices about running a company.

A few days ago, he sent me an email (in Bahasa Indonesia) that I thought it was a very good advice and I would like to share it to another startup founder. Here is the email which I translate into English.

> _Assalamu'alaikum wr. wb.,_
>
>
> _Just for refreshment. Don't ignore internal control. The startup world tends to neglect the corporate culture, because startup needs to be fast, spontaneous, and less (long) bureaucracy. With bigger (startup) organization size and scalability, there's no reason for not accepting the corporate culture._
>
>
> _For early stage company, especially a technology company, agile concept, fast pace, spontaneous, and risk taking culture should be maintained to release the innovative product faster; get a lot of feedbacks from user and doing next iteration. For product development, it is very good approach. But when the company turns to be a mature company, the company culture should turns to be mature also. When the size of the company is getting bigger and bigger, the line of products or service is getting more, and the number of clients or users is increasing, that's the moment to adopt the corporate culture into the company. Of course, you'll get conflicts in every aspect in the company. Moreover if many people are involved in it, e.g. investors and employees, but this is an adjustment that the company need. Corporate culture will help you to control the operation of the company to be more efficient and stay effective, also it can secure your company asset._
>
>
> _[David] said, "He has certainly wronged you in demanding your ewe [in addition] to his ewes. And indeed, many associates oppress one another, except for those who believe and do righteous deeds - and few are they." And David became certain that We had tried him, and he asked forgiveness of his Lord and fell down bowing [in prostration] and turned in repentance [to Allah ]. - Quran surah Saad:24_
>
>
> _Usually startup can be very messy when it starts to go into the corporation operational matters such as legal, finance, HR, etc. More time you spend to reject the corporate culture, faster your company will die. Embracing the corporate culture will become an important step to bring your company into higher level._
>
>
> _Even though Asep (me) is a CTO and a programmer, but don't forget you are a guy who had taken accounting major in college, so you won't forget the element of internal control. Ok?_
>
>
> _Unless you want to be a startup, forever._
>
>
> _Wassalamu'alaikum wr. wb._

The last sentence is very bold. You want to be a startup forever or go into higher level. Thanks, my dad.



Today, September 21, 2015, I'm officially 28 years old.

Many people say 28 is the starting age to enter adulthood. In astrology, they call it Saturn Return. It is a period for Saturn completing its full orbit around the Sun, and Saturn is returning to the position when the people were born.

Whatever people talk about the age of 28, I believe it is the age for starting something matters and meaningful in my life and my career. My first career milestone was building a company before 25 years old, and I achieved that. I found a digital marketing agency with my partner from scratch. It is a good cashflow business until now.

Now, after 3 years plus doing service business for the client, I'm ready to expand my career.

**Education for Tech**

Inspired by the initiative to teach my office boy for coding, I'm thinking how if I scale this initiative to many people who want to learn coding, but don't know how to start it. It sounds very interesting, isn't? Who know if I can make them get a better career for their life after learning coding?

I'm in the progress to start this very soon with my partner. Oh, the name for this initiative is Framework.

**Agriculture**

Apparently human population in earth is proliferating, but how about the food production? Can it balance the population? Starting from this background, I and my wife are just thinking how to produce our own food. Hence, we learnt hydroponic farming. We are living in dense city with no land for farming, but hydroponic can answer that challenge. No soil and can do vertically.

Leveraging my coding skill, I add some computer and sensor automation to our hydroponic farm. Luckily, I and my wife have some friends who are in the same train with us. So, we are starting Tanibox to help the world produce more edible vegetables and fruits.



Currently, I'm developing an indoor farming system to grow vegetables (at the moment is Lettuce) and herbs in my house. You can check the project's progress on [my Hackaday's page](https://hackaday.io/project/7124-tanibox-indoor-farming-system). The system should controls the lighting on and off at the correct time, logs the temperature and humidity and triggers the fan based on it, and sends the farm log to the server, so, I can predict the harvest time and the farm optimal condition in the future. At the heart of the system, I'm using Raspberry Pi as a micro controller.

Physical world is actually concurrent, thus why not give Clojure a shot? It's a good language for handling concurrency, right?

So, here is my first working version of my code for controlling the LED growing lamp.

```
(ns farmbox.lighting
  (:require [clojure.core.async :as a :refer [>! <! >! <!! go chan close!]]
            [gpio.core :as gpio]))

  (def port (gpio/open-port 4))

  (defn switch-on []
    "Switch the lamp on."
    (if (= (gpio/read-value port) :high)
      (do (gpio/set-direction! port :out)
          (gpio/write-value! port :low)
          "Lamp is on")
      "Lamp is on"))

  (defn switch-off []
    "Switch the lamp off."
    (if (= (gpio/read-value port) :low)
      (do (gpio/write-value! port :high)
          (gpio/set-direction! port :in)
          (gpio/close! port)
          "Lamp is off")
      "Lamp is off"))

  (defn lighting-machine []
    "Create the process for turning on/off the lights."
    (let [in (chan)
          out (chan)]
      (go (let [input (<! in)]
        (cond
          (= input "on") (>! out (switch-on))
          (= input "off") (>! out (switch-off)))
          (do (close! in)
              (close! out))))
      [in out]))

(defn plug-the-machine [switch-status]
  "Call the process of lighting here."
  (let [[in out] (lighting-machine)]
    (>!! in switch-status)
    (println (<!! out))))
```

I gave `Lamp is off` and `Lamp is on` string because go channel can't be given `nil` value.

**The drawback of using Clojure in Raspberry Pi**

Although Clojure is good for handling concurrency, but its runtime is too heavy for device with limited resources likes Raspberry Pi. Its startup time can takes around 2 minutes. It won't be a big problem for production, because you only start the app once. Otherwise it will give some pains in the ass when in development phase, the compile time and the startup time are too slow.

In the second iteration, I will try to evaluate NodeJS as the runtime and use ClojureScript for coding it.



_One of the biggest problem of having pet is filling its needs while the owner leaving the home._

I had an aquarium which was filled with 7 fish, and the fish should be fed at least once a day or better twice a day in small portion. A week ago, I and my wife must left our home for celebrating Eid together at my parent's home in another town, thus it led me for creating an automation system to feed my fish.

Three days before the departure, I started to create it. I have an Arduino Uno R3, an ESP8266 wifi module, a Tower Pro SG90 micro servo, and a Starbucks' juice bottle as a fish food container. My first design was making a system that can tell me via email if it successfully feeds the fish twice a day, but then I remembered that my current home doesn't has always-on-internet. So, I ditched the email feature and surely I didn't need to use ESP8266.

Then I moved with second design. The Arduino would be rotating the servo twice a day without notified me whether it fed the fish successfully or not. I tested it several times, and 150% sure that this device worked with zero bug in code.

![working-design](/blog-img/aquarium-post-mortem.jpeg)

I left my home confidently.

Yesterday, I arrived to my home. Open the door. Stank very bad smell. What the hell was going here? Oh my God! All the fish was floated up on the thicken water. I assessed they had died for 3 days because of ammonia and not by automation system failure.

The catastrophic came from my prepaid home electricity. It showed 000 kwh (kilo watt hour), hence my aquarium pump and filter was turning off and couldn't cleaning up the food leftover. I miscalculated the power usage of all electricities in my home. I should bought more KWh before I left, but I didn't.

**Conclusion**

The lessons that I learned here are:

1.  Prepare the automation system with backup battery. I have a plan to create mini solar powered battery system as a backup from the main electricity.
2.  Making a simple app that can calculate the amount of needed kwh for all home appliances.



Why I'm deeply in love with Clojure? That's because I can do full stack development only in one language. I can write HTML with the same Clojure data structure, then styling it by writing CSS in exactly the same data structure. When I need to do user interface development, I can use ClojureScript then compile it into JavaScript. Actually writing ClojureScript is more pleasant than writing vanilla JavaScript. How about the backend development? You don't say. Clojure was invented for that purpose.

Here is the content of my `project.clj` for doing full stack Clojure website development:

```
(defproject sample "0.1.0"
  :description "FIXME: description"
  :url "https://asep.co"
  :min-lein-version "2.0.0"
  :dependencies [[org.clojure/clojure "1.7.0-beta2"]
                 [org.clojure/clojurescript "0.0-3291"]
                 [org.clojure/core.async "0.1.346.0-17112a-alpha"]
                 [compojure "1.3.4"]
                 [selmer "0.8.2"]
                 [garden "1.2.5"]
                 [jayq "2.5.4"]
                 [ring "1.4.0-RC1"]]
  :plugins [[lein-ring "0.8.13"]
            [lein-ancient "0.6.7"]
            [lein-cljsbuild "1.0.6"]
            [lein-garden "0.2.6"]]
  :resource-path "resources"
  :aot :all
  :main sample.handler
  :uberjar-name "sample-standalone.jar"
  :ring {:handler sample.handler/app}

  :cljsbuild {:builds [{:source-paths ["src-cljs"]
                        :compiler {:output-to "resources/public/js/main.js"
                               :optimizations :simple
                               :pretty-print true}}]}

  :garden {:builds [{:id "screen"
                     :source-paths ["src-styles"]
                     :stylesheet sample.core/screen
                     :compiler {:output-to "resources/public/css/screen.css"}
                     :pretty-print? true}]}

  :profiles {:dev {:dependencies [[ring-mock "0.1.5"]]
                   :ring {:auto-refresh? true}}})
```

I write CSS code by using [Garden](https://github.com/noprompt/garden). It is fun. Who doesn't want to trade their CSS pre-processor with full fledged programming language? For HTML templating, I usually use [Selmer](https://github.com/yogthos/Selmer) when I collaborate with front-end developer who doesn't speak Clojure. But[Hiccup](https://github.com/weavejester/hiccup) is also good when you want to write HTML in Clojure data structure. If I need to create React application, I will use [Reagent](https://reagent-project.github.io/) library. Frankly, developing React application is more convenience using ClojureScript.

Clojure and ClojureScript really make me a happy developer.



This weekend, I am experimenting to use [React Bootstrap](http://react-bootstrap.github.io/) with ClojureScript. For whom that doesn't know it yet, React Bootstrap is a [Bootstrap 3](http://getbootstrap.com/) component built with [ReactJS](http://facebook.github.io/react/). I'm using [Reagent](https://reagent-project.github.io/) library for interacting with React from ClojureScript, instead of [Om](https://github.com/omcljs/om).

Integrating React Bootstrap and Reagent was confusing me at the first. It was non-trivial effort. I searched Google and got no relevant solutions for hours. So, this working solution is based on my trial and error experimentation.

Let's start.

In `project.clj` file, I use Reagent with `:exclusions`, because I have to use React version from NPM not the version that comes from Reagent. Don't forget to create `react.cljs` which contains only `(ns cljsjs.react)`.

`project.clj`
```
(defproject sample "0.1.0-SNAPSHOT"
  :description "Write your definition here."
  :url "http://sample.org"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.7.0-beta2"]
                 [org.clojure/clojurescript "0.0-3269"]
                 [reagent "0.5.0" :exclusions  [cljsjs/react]]]
  :node-dependencies [[react-bootstrap "0.21.2"]]
  :plugins [[lein-cljsbuild "1.0.5"]
            [lein-npm "0.5.0"]]
  :source-paths  ["src-clj"]
  :resource-path "resources"
  :npm-root "resources"
  :cljsbuild {:builds [{:source-paths ["src-cljs"]
                        :compiler {:output-to "resources/main.js"
                        :optimizations :advanced
                        :pretty-print true}}]})
```
`react.cljs`
```
(ns cljsjs.react)
```
Now, look at the index.html file. I use React and React Bootstrap which come from NPM. I manage the NPM dependencies by using [lein-npm](https://github.com/RyanMcG/lein-npm). It is a good Leiningen plugin for integrating NPM and Leiningen seamlessly.

`index.html`

```
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">

    <title>Sample</title>

    <link rel="stylesheet" href="css/bootstrap.min.css">
  </head>

  <body>
    <div id="apps" class="container-fluid"></div>

    <script type="text/javascript" src="react.min.js"></script>
    <script type="text/javascript" src="react-bootstrap.min.js"></script>
    <script type="text/javascript" src="main.js"></script>
  </body>
</html>
```

Finally in `core.cljs`, I can do JS interop to call React component from React Bootstrap module.

`core.cljs`

```
(ns sample.core
  (:require [cljsjs.react]
            [reagent.core :as reagent :refer [atom]]))

(defn text-editor
  "Text editor for static blog."
  []
  (let [grid (aget js/ReactBootstrap "Grid")
        row (aget js/ReactBootstrap "Row")
        col (aget js/ReactBootstrap "Col")]
    (reagent/create-element grid #js{}
      (reagent/create-element row #js{}
        (reagent/create-element col #js{:xs 6 :md 6}

          ;; create div for text editor
          (reagent/create-element "div" #js{:contentEditable true} "Left column"))
          (reagent/create-element col #js{:xs 6 :md 6} "Right column")))))

(reagent/render [text-editor] (.getElementById js/document "apps"))
```

This is my working project structure for doing all those thing.

```
doc
resources
-- node_modules
---- react-bootstrap
---- react
-- index.html
-- main.js
src-clj
src-cljs
-- cljsjs
---- react.cljs
-- sample
---- core.cljs
target
test
project.clj
```



As a web developer and iOS developer, I didn't know much about hardware or bare metal programming. I only learned about resistor, capasitor, transistor, etc when I was still in junior high school, thus my electronic knowledge is very limited.

**Arduino Uno R3. My First Board.**

I was interested for learning electronic again as a hobby around 2-3 years ago, when I read that Arduino is easy for learning micro controller programming. I bought it for IDR190.000 (around USD15). I also ordered a bread board for prototyping, some jumper cables, and a pair of LEDs.

I must admit that it was not easy enough for the first time. I had to learn Arduino IDE with Processing language, and learned some jargons that I never knew before in web programming e.g., baud rate, digital pin, analog pin, Tx/Rx, serial port, etc. Finally, I can made my first project run. It was blinking the LED project. Arduino IDE makes everything simple, from writing the code (sketch) until uploading it to the board.

Today, learning Arduino programming from web development background is getting easier. We can do it by using JavaScript with NodeJS and Johnny-Five package.

**Raspberry Pi. Small Linux Board with ARM Processor.**

After doing some small toy projects in Arduino platform, I read about Raspberry Pi the $35 credit card size computer. The first time I knew about GPIO (General Purpose Input/Output) was from this board, and with this board also I learned how to build a cross compiler toolchain for compiling C program from OSX to RPi. I was using this board for various purposes, mostly for home entertainment.

My latest hobby project was building the automation system for my aquarium. It utilized RPi to control servo motor for rotating the fish food dispenser over the internet. I built it by using NodeJS, SocketIO, and [Johnny-Five](https://www.npmjs.com/package/johnny-five) package.

<iframe src="https://www.youtube.com/embed/oNoDhwC3RDk" width="560" height="315" frameborder="0" allowfullscreen="allowfullscreen"></iframe>

The problem came when I want to deploy it on my aquarium. I felt $35 was not worth to be placed as a permanent installation, because I still need the RPi for my home entertainment. So, I should find the cheap way. Arduino obviously not the cheap way. It is $15, but if I want to connect it to the internet I should buy either ethernet shield or the expensive wifi shield.

My friend gave me a solution via Twitter. He mentioned about...

**ESP8266. The $5 Wifi Module.**

I google-ed it. It is a new wifi module that people usually use it as a module for Arduino, but actually it can be used as a stand alone micro controller. So, I ordered it for IDR70.000, also with USB TTY programmer for IDR22000. The total shopping was just IDR99.000 (around $7). It is worth to solder permanently.

The USB TTY is used to program the micro controller. ESP8266 has 2 GPIO pins and working with 3.3 volt power. I can't use JavaScript for this hardware, thus it becomes my first time for writing my own firmware in C and deploy (flash) it to a hardware that don't have operating system. Now, I'm in progress for porting my aquarium system to use this coin size and cheap module.

I will write the tutorial about how to use it in the next post.



Although coding is not a basic communication skill for human, I prefer to encourage people for learning it, especially for someone who wants to expresses and develops his/her idea in technology industry but doesn't come from computer science background. There are couple of reasons according to that opinion.

In the first place, if people know basic coding skill, he/she can develop his/her very beginning concept of software by his/her own hand, then his/her can show it to the more appropriate software engineer. It will establishes an effective communication between the idea owner and the software engineer. Second, basic coding skill can improve his/her decision making skill, because he/she will writes many decisions for many conditions in his/her flow of codes and datum.

In spite of the benefits of having the ability to code, learning it also has some hurdles, such as too many programming languages out there. It will make newbie feel confuse to choose their very first programming language. One more example obstacle, books that teach about coding usually too technical and contain many technical jargons which can scare non-technical people at a glance.

Many peoples that desire to make business in technology industry are not always coming from computer science background; they only have ideas, and also many computer science degree holders don't know how to make business by using their knowledge. Thereby, both of them should meet on one table if they desire to grow together. Thus, basic coding skill will be helpful to establish the communication between them in this circumstance.



_This is the story of my life about my relationship with some programming languages from the first time I learnt computer programming until now. It was like finding a life partner._

**Pascal**

I met her around 2003 from my high school accounting teacher. She was my very first date in programming world. I tried to digest how to do programming and what I can do with programming. My relationship with Pascal was very short. I didn't serious relationship with her; rarely kept in touch with her, thus we broke up. With Pascal, I only wrote some simple CLI programs for calculating my physics and math homework.

**Visual Basic 6**

After Pascal, I was dating a pretty girl from Microsoft called Visual Basic 6. She was very nice girl. Drag and drop GUI programming (it was such an instant gratification), interactive IDE (imho), and the most important thing was I could compile the program to has .exe extension, so that I could show off my program to my friends easily. LoL teenager :P

**Java**

She was just an acquaintance. I only said hello to her; chatted for a while; then said goodbye and never met with her anymore.

I know Java is good and many people love her, but I don't have a good chemistry with her.

**PHP**

I wanted to learn web programming, then I met with PHP. At that time, I made a date with PHP 4. She didn't have supports for object oriented programming, and by the way I also didn't know yet about what object oriented programming was. So, not a big deal.

Now PHP is my true life partner. I have a love and hate relationship with her, but I can't leave her. She is easy going (I mean easy to deploy on any server), practical, and easy to understand. She evolved from an ugly language to be better and better.

**Javascript**

As a web developer, I couldn't avoid to meet and keep in touch with this little girl. Even to make a simple alert window on the browser. My relationship with her is so-so until now.

**Objective C**

I accidentally met her, the girl with a pair of brackets, because I accidentally bought an iPhone 4 on 2010. I was thinking, "This expensive gadget should generate more money for me". So, I learnt to understand her, Objective C.

Now, she is my very best friend to help me earn some extra money.

**Ruby**

This was my affair from PHP. The grass is always greener on the other side, no? I tried to replace PHP with Ruby from my development stack, but she didn't play it very well for me. Ruby with her famous RoR framework wasn't matching with my digital agency workflow. She couldn't be deployed on shared host and the main problem was when we hand over the project to another developer or the client. In Indonesia, they mostly couldn't understand it.

So, I was coming back to my true love, PHP. Now, I still write Ruby code just for making some small CLI tools.
In the late 2013, I learnt functional programming paradigm. This was a new paradigm for me, and it opened my eyes and my mind.

**Erlang**

My very first crush in functional programming world. I read many good things about her, so I tried to approach her. But in reality, she was the girl who can blow my mind in the first date. Her syntax is bewildering me. The OTP framework is also hard to understand by me. So, after 3 months trying to compromise with her. I gave up.

**Racket**

She comes from the family of LISP language. So, she uses S-Expression. Parentheses, parentheses everywhere (puts Buzzlightyear meme here please). Looked weird at the first sight, but I was feeling the good chemistry with LISP based language. My friend said to me, "LISP doesn't have syntax, you will easily understand it.". My friend was right, this language is easy.

I hang-out for a while with Racket. I loved her, but I knew she won't fit in my development tool box. I need more practical language with a good community support and lot of libraries.

So, I moved on. Good bye Racket, thanks for making me fell in love with LISP, but I had to find the perfect partner in functional programming world.

**Clojure**

Lastly, I met with Clojure. A young girl who was born in 2007. She is a LISP on JVM (Java Virtual Machine). Although she is still young, but I don't doubt her capabilities, because LISP is mature language and JVM also has mature ecosystem. When I can't find Clojure library, I can interop with existing Java library. Is it good, right?

Clojure also has a sister. Her name is Clojurescript. She can builds Clojure code into Javascript. Sophisticated.
That's my journey in programming world. So, there are 4 active girls beside me now. PHP is my true love and my lifetime partner for developing website, Javascript a little girl that helps me making interaction in the browser, Objective C will comes when I need to develop iOS application, and lastly Clojure the young girl who teaches me a lot about functional programming and also for developing system on top of JVM.

P.S. because of Clojure, now I can adapt the functional programming paradigm also to my PHP and Javascript code.



Saat saya menuliskan artikel ini, posisi saya sudah berada di kota Ankara, Turki. Sedang bersantai di balkon hotel, menikmati udara sejuk, dan sinar mentari kawasan Mediterania. Saya berada di kota ini untuk mengurus visa untuk tinggal di Estonia. Ya, akhirnya setelah pertama kali mengenal Estonia dan [membangun bisnis di sana](/business/pengalaman-mengagumkan-mendaftarkan-perusahaan-di-estonia) secara jarak jauh pada tahun 2017, sekarang saya memutuskan untuk berpindah ke sana.

![Terbang di atas Ankara](/blog-img/fly-ankara.jpg)

[Kilas balik ke tahun 2018](/personal/satu-dekade-saya), ini adalah tahun di mana saya dan istri memutuskan untuk pindah dari Tangerang Selatan. Sudah merasa bosan dan sumpek tinggal di wilayah seputaran Jakarta, kami pun memutuskan untuk hidup lebih lambat jauh dari hiruk pikuk ibukota. Pulau Bali menjadi pilihan. Setahun sekali dari semenjak menikah tahun 2014, selalu berlibur ke Bali. Akhirnya malah jatuh cinta dengan pulau tersebut.

Saat itu saya berkata ke istri, "Setelah Jakarta, sekarang kita menuju ke Bali untuk *slow life*. Setelah Bali, tujuan berikutnya Estonia atau Finland. Kalau ternyata tidak kesampaian dalam 5 tahun, ya kita menetap di Bali saja. Beli rumah dan membangun bisnis dari sana." Istri pun setuju dengan rencana tersebut. Kenapa targetnya dua negara tersebut? Lagi-lagi cinta pada pandangan pertama setelah sempat berkunjung ke kedua negara tersebut di tahun 2017.

**Pandemi Covid-19 mengubah segalanya**

Tahun 2020, tahun yang memaksa saya untuk keluar dari [zona nyaman (lagi)](/business/terima-kasih-froyo-asep-is-out). Bisnis di Tanibox bergoyang. Beberapa klien putus kontrak akibat pandemi dan hanya menyisakan 1 klien saja dari Portugal. Selain itu investasi di kebun jagung seluas 7 hektar juga mengalami kegagalan. Untuk kebun jagung, ini adalah kombinasi pandemi dan salah memilih partner kerjasama. Beruntungnya di luar Tanibox, saya kadang masih menerima proyek pembuatan web dan app. Jadi arus kas keluarga masih lumayan aman.

Tapi saya dan istri merasa akan sulit maju di tengah pandemi yang tidak menentu dan tampaknya akan lama ini, jika kami masih menetap di Bali. Untuk mendapatkan hasil yang berbeda, tentu membutuhkan cara yang berbeda pula. Permasalahannya, kembali ke Jakarta bukan lah opsi untuk kami berdua. Kami sudah malas untuk kembali tinggal di sana.

Maka opsi satu-satunya adalah pindah ke Eropa dengan pertimbangan kami sudah ada bisnis di sana yang bisa dimaksimalkan jika posisinya sudah pindah ke sana. Karena sejauh ini pun klien kami baik itu Tanibox atau dari bisnis konsultan *web/app development* juga kebanyakan dari Eropa. Maka itu menjadi opsi yang masuk akal untuk kami. Akhirnya saya berkata ke istri, "Kita coba tetapkan *deadline*. September 2021 harus sudah ada kejelasan kita mau pindah ke mana. Kalau September tidak ada kejelasan, kita cari opsi alternatif lain."

Saya dan istri pun mulai berhitung, bagaimana caranya pindah antara ke Finland atau Estonia. Ada 3 opsi:
- Pindah sebagai *entrepreneur*. Tapi ternyata setelah dihitung dan dibaca aneka persyaratannya. Sepertinya akan sangat mahal dan ribet. Karena semua biaya harus ditanggung sendiri semua.
- Pindah dengan cara sekolah lagi. Ini saya tidak yakin, karena mengejar akademis bukan lah saya banget. Ini pun opsi mahal, karena persiapan untuk sekolah lagi juga membutuhkan biaya yang tidak sedikit.
- Pindah dengan cara mencari kerja sebagai karyawan. Akhirnya ini saya jadikan opsi yang paling masuk akal. Saya harus mencari perusahaan yang mau mensponsori saya untuk relokasi.

**Berburu pekerjaan**

Saya pun mulai memoles CV dan [LinkedIn](http://linkedin.com/in/asepbagja/) saya. Bahkan di tengah masa pencarian pekerjaan ke luar negeri ini, saya sempat mengambil tawaran untuk menjadi Tech Lead di sebuah startup di Jakarta. Pertimbangan saya saat itu, karena pekerjaannya bisa dikerjakan secara *full remote* dari Bali dan lumayan untuk tambahan pengalaman di CV.

Lima bulan setelah saya terima tawaran sebagai Tech Lead, startup di Jakarta tersebut mulai bergoyang dari sisi keuangan. Banyak karyawan di-PHK dan akhirnya banyak juga karyawan yang memilih untuk mengundurkan diri. Termasuk saya.

Mungkin memang sudah jalannya harus pindah ke luar negeri. Satu minggu setelah saya mengundurkan diri, saya mendapat undangan wawancara dari perusahaan di Belanda dan Estonia. Yang di Belanda saya gagal di wawancara kedua, tetapi yang di Estonia malah berlanjut terus hingga 4 kali wawancara dan akhirnya mendapatkan pekerjaan sebagai Full-Stack Software Engineer di [Jobbatical](https://www.jobbatical.com). Secara keseluruhan hanya membutuhkan waktu 1 bulan dari wawancara pertama hingga saya mulai masuk hari pertama.

Saat wawancara, saya dari awal mengatakan, "Walaupun pekerjaan ini bisa *remote* dari Indonesia tapi saya berkeinginan untuk direlokasi ke Estonia." Ternyata disetujui. Tidak tanggung-tanggung, semua biaya relokasi disponsori termasuk biaya relokasi istri dan 2 kucing kami.

Bahkan saat wawancara terakhir dengan HR, saya bertanya, "Saya juga ada perusahaan di Estonia, apakah saya masih boleh mengurus bisnis saya?" Malah dijawab, "Kami sangat mendukung *entrepreneurship* selama tidak berkompetisi dengan Jobbatical. Saya sendiri selain jadi HR di sini, juga punya startup sendiri."

Jadi, ya ini lah saya sekarang. Setelah 3 bulan bekerja secara remote untuk Jobbatical, sekarang saya direlokasi ke Estonia.

**Suksma, Bali!**

![Sunset di Bali](/blog-img/sunset-bali.jpg)

Jadi, sampai bertemu lagi Bali di lain waktu. Tempat yang memang cocok untuk merasakan *slow life*. Tetapi sayangnya situasi saat ini tidak memungkinkan untuk berlama-lama tinggal di Bali. Terima kasih untuk 3,5 tahun terakhir yang seperti *roller-coaster*, dan untungnya selalu ada pantai dan gunung yang bisa menjadi tempat penyegaran pikiran.



Sebentar lagi kita akan memasuki tahun 2020, sebuah awal dekade baru. Di media sosial, banyak orang menuliskan pencapaian-pencapaian penting di hidupnya selama periode 2010-2019. Saya pun akan melakukan hal serupa, tapi tidak di media sosial. Akan lebih bebas jika saya tuliskan di blog ini saja.

![from this to this](/blog-img/graduation.png)

### 2010

Awal dekade yang lalu dimulai dengan lulus kuliah dari Fakultas Ekonomi, jurusan Akuntansi, Universitas Islam Indonesia. Walau menyandang gelar Sarjana Ekonomi, *passion* saya tetap di bisnis, komputer, dan teknologi. Begitu lulus, saya melamar kerja sebagai pemrogram web di sebuah studio web kecil di Yogyakarta. Tujuannya untuk mempelajari bagaimana berbisnis di bidang IT. Oh ya, saya memiliki keahlian pemrograman sudah sejak SMA. Ketika lulus kuliah saya sudah bisa memprogram dengan menggunakan Pascal, Visual Basic, dan PHP.

Saya bertahan 6 bulan saja di studio web di Yogyakarta, karena pekerjaannya terasa berulang dari satu proyek ke proyek lain. Tidak ada tantangan lebih. Akhirnya di akhir 2010, memutuskan pindah ke Bandung. Saya masuk ke studio web bernama iCreativeLabs.

### 2011

Pindah ke Bandung membuat saya terekspos banyak komunitas kreatif dan komunitas IT. Relasi menjadi lebih luas, wawasan seputar industri IT juga bertambah. Di tahun ini saya juga memutuskan untuk keluar dari iCreativeLabs dan mulai mencoba berusaha sendiri sebagai *freelancer*. Tiga bulan menjadi pekerja lepas, lalu ada seseorang dari Singapore yang menghubungi saya. Dia mengajak saya untuk menjadi *technical co-founder* di startup yang sedang dia bangun. Orang ini mengetahui kontak saya dari beberapa artikel tentang saya di Daily Social (terima kasih DS), dan membaca blog pribadi saya.

Ini adalah pengalaman ber-startup saya yang pertama. Waktu itu saya bekerja secara *remote* sambil bolak-balik Bandung-Singapore nyaris sebulan sekali. Startup ini gagal *take-off* karena tidak menemukan *product market fit*, dan akhirnya bubar setelah setahun.

### 2012

Pindah ke Jakarta karena mendirikan perusahaan baru yang bernama Amazing Milk (PT Diasfiko Bintang Kreasi) dan bergerak di bidang konsultan pemasaran digital. Perusahaan ini didirikan oleh 4 orang. Dua orang *co-founder* aktif yang menjalankan kegiatan bisnis harian, dan dua orang lagi tidak aktif di kegiatan harian karena mereka juga memiliki agensi lain yang bergerak di bidang pemasaran kreatif *offline*. Perusahaan ini hanya berumur sekitar setahun karena ada ketidaksamaan visi dengan dua *co-founder* yang tidak aktif.

Di tahun ini juga saya bertemu dengan seseorang yang sekarang menjadi [**istri saya**](https://retno.eu). Bertemunya di mana? Di Twitter. Tidak sia-sia investasi bikin akun Twitter sejak 2009.

### 2013

Pindah ke Tangerang Selatan. Dengan *co-founder* yang sama saat mendirikan Amazing Milk dan karyawan 4 orang yang berasal dari Amazing Milk juga, kami mendirikan agensi digital baru yang bernama [**Froyo**](http://froyo.co.id) (PT Froyo Kreatif Indonesia). Mengapa namanya Froyo? Karena susunya sudah basi dan berubah jadi yoghurt.

### 2014

Setelah 2 tahun LDR Tangsel-Semarang, akhirnya memutuskan untuk menikah.

Di tahun ini juga Froyo pindah ke kantor yang lebih besar karena tim kami saat itu bertambah besar.

### 2015

Di tahun ini, terekspos dengan *precision agriculture*. Istri saya suka bercocok tanam. Ketika itu kami bahkan punya *greenhouse* kecil di halaman rumah. Di *greenhouse* ini lah kami bereksperimen dengan sensor-sensor dan membuat perangkat lunak yang bernama [**Tania**](https://usetania.org).

Tahun 2015 ini juga saya mulai merasa galau tentang masa depan dan tujuan hidup. Orang biasa menyebutnya *quarter life crisis*.

### 2016

Terekspos dengan negara yang bernama Estonia karena kawan dekat saya mendapat beasiswa kuliah di sana. Banyak membaca soal Estonia dan akhirnya menemukan program [**Estonia e-Residency**](https://asepbagja.com/id/artikel/apa-itu-estonia-e-residency/). Di tahun ini akhirnya memutuskan untuk mendaftar sebagai e-Resident.

Cikal bakal [**Tanibox**](https://tanibox.com) mulai terbentuk di tahun ini. Di 2016 ini juga, kami meluncurkan Tania versi awal ke publik sebagai proyek *open-source*.

Masih galau dengan tujuan hidup, bisnis, dan karir. *Quarter life crisis* saya lumayan lama juga sekitar 2 tahunan.

### 2017

Mengambil keputusan besar. Saya memutuskan untuk [*exit* dari Froyo](https://asepbagja.com/id/artikel/terima-kasih-froyo-asep-is-out/) dan menjual seluruh kepemilikan saham saya di sana. Di tahun ini krisis seperempat abad saya menghilang. Bersama istri, tekad kami bulat untuk menjadikan Tanibox sebagai sebuah bisnis.

Kami segera [**mendaftarkan Tanibox**](https://asepbagja.com/id/artikel/pengalaman-mengagumkan-mendaftarkan-perusahaan-di-estonia/) sebagai perusahaan di Indonesia dan Estonia sekaligus.

### 2018

Awal tahun 2018, memutuskan pindah ke Bali karena sudah bosan hidup di Tangsel dan Jakarta.

Dalam hal bisnis, ini tahun terburuk saya sepanjang ber-startup ria. Menjelang akhir 2018, uang modal di Tanibox habis, PHK karyawan, dan kesulitan keuangan. Penyebabnya adalah kombinasi antara produk yang tidak diinginkan pasar Indonesia (GRO), bermain di B2C tapi dana untuk melakukan pemasaran terbatas, dan bertemu relasi bisnis yang salah.

Di akhir 2018, istri dan saya memutuskan untuk membuat satu bisnis baru untuk menjaga arus kas kami. Bisnis untuk dapur *ngebul* istilahnya. Kami membuat studio konsultan untuk pengembangan produk digital bernama [**Chloe & Matt**](https://chloematt.com).

### 2019

Ini adalah tahun "yang penting bisa bertahan hidup" dan Tanibox terus jalan. Beruntung lah 3 tahun lalu kami menjadikan Tania sebagai proyek *open-source*. Dari *open-source* saya mendapat relasi-relasi baru dari Eropa, Afrika, dan Amerika Selatan.

Kami memulai kembali Tanibox dengan modal terbatas dan hanya bekerja berdua dengan istri saya. Di awal 2019 kami lakukan *pivot*. Sekarang kami mentarget pasar B2B sehingga kegiatan pemasaran bisa dilakukan dengan modal terbatas, dan menganggap pasar Indonesia sebagai bonus (jika ada.) Strategi ini cukup berhasil. Sepanjang 2019, kami bisa bertahan hidup dengan beberapa klien dari negara-negara di Eropa.

*P.S. Istri saya juga menuliskan catatan satu dekadenya yang menarik untuk dibaca: [Satu Dekade Ini Ngapain Saja?](https://www.retno.eu/id/blog/05-2010-2019/)*



### Pembaruan artikel

*Per tanggal 24 November 2020, TransferWise sudah bisa kirim IDR ke luar negeri secara langsung. Jadi trik pada artikel ini tidak diperlukan lagi. Berikut ini caranya, diambil dari newsletter TransferWise yang saya dapat. Saat saya coba, sepertinya ini baru bisa dilakukan via aplikasi mobile TransferWise, karena saya tes di versi website belum ada pilihan rekeningnya. Jangan lupa, untuk melakukannya tetap harus membuat akun [Wise](https://wise.com/invite/u/asepp1) terlebih dahulu.*

*TransferWise telah berganti nama menjadi Wise. Walaupun begitu, layanannya tetap sama.*

<iframe width="560" height="315" src="https://www.youtube.com/embed/peL7AvJbroU" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

Internet membuat batas antar negara seakan tidak ada. Walaupun tinggal di Indonesia, kita bisa mencari peluang-peluang bisnis dan pasar-pasar baru di luar Indonesia untuk memasarkan produk. Seperti saya yang memanfaatkan [Estonia e-Residency](/id/artikel/apa-itu-estonia-e-residency) untuk membangun perusahaan di Eropa. Tentu saja memiliki bisnis di luar negeri artinya harus berurusan dengan mata uang asing. Untuk kasus saya, saya harus berurusan dengan mata uang Euro dan kadang-kadang US Dollar.

Situasi saya saat ini:

- Rekening bisnis berada di bank di Estonia.
- Rekening pribadi berada di Indonesia. Rekening pribadi ini digunakan untuk kebutuhan hidup sehari-hari.

Ada dua situasi pengiriman uang yang selalu saya hadapi semenjak bisnis ini berdiri tahun 2017:

1. Bagaimana cara mengirimkan uang dari rekening bisnis di Estonia ke rekening pribadi di Indonesia untuk biaya hidup?
2. Bagaimana cara mengirimkan uang dari rekening pribadi di Indonesia ke rekening bisnis di Estonia?

Situasi nomor satu mudah dimengerti lah, lalu mengapa bisa ada situasi nomor dua? Ini agak rumit. Biasanya disebabkan oleh:

1. Ada pembayaran yang masuk via PayPal. PayPal saya menggunakan akun Indonesia dan hanya bisa melakukan penarikan ke akun bank di Indonesia. Kenapa kok tidak bikin saja akun PayPal Estonia? Karena tidak bisa. Akun PayPal dibuat berdasarkan lokasi di mana kita tinggal. Penggunaan VPN tidak disarankan, karena kalau ketahuan bisa-bisa akun PayPal saya diblokir.
2. Kebetulan ada klien dari lokal dan mereka hanya mau bayar via transfer bank ke bank lokal. Jadi untuk kepentingan pembukuan dan juga membayar vendor di Estonia saya harus kirimkan uang ini dari bank pribadi di Indonesia ke akun bisnis di Estonia.

Jadi bagaimana cara mengirimkan uang antar negara? Cara paling mudah adalah ya langsung saja transfer antar bank.

**APAAA? MUDAAAH?**

Ngga *ding*, saya bohong 🙈🙈 *Wire transfer* bank antar negara itu selain lama sampainya (bisa sampai 3 hari kerja) juga mahal. Dulu waktu awal-awal bisnis, saya selalu pakai *wire transfer*. Paling tidak saya bisa bayar biaya transfer sekitar Rp300.000-Rp400.000 per sekali transfer.

Untuk mengirimkan uang dari Estonia ke Indonesia sih enak saya tinggal buka Internet banking dan kirim, tapi sebaliknya dari Indonesia ke Estonia saya harus ke kantor bank. Mengantre, mengisi formulir, menyerahkan KTP, dan bayar biaya materai. Hiduplah Indonesia Raya! 🤗 Baik kirim dari Estonia, maupun dari Indonesia biasanya membutuhkan waktu 2-3 hari kerja. Hingga akhirnya saya menemukan TransferWise di mana biaya transfer yang saya bayar hampir sekitar 10x lipat lebih murah daripada pakai *wire transfer* bank.

### Apa itu TransferWise?

[Wise](https://wise.com/u/asepp1) adalah perusahaan fintech yang berdiri sejak 2011 dan memiliki layanan mengirim uang antar negara dengan biaya rendah dan cepat. Pendiri perusahaan ini adalah orang Estonia yang tinggal di Inggris. Sejarah berdirinya karena si pendiri merasakan bagaimana mahalnya dia mengirimkan uang dari Inggris ke Estonia untuk membayar *mortgage* lewat transfer bank biasa. Bisa baca sejarah awalnya di [sini](https://en.wikipedia.org/wiki/TransferWise).

Bagaimana TransferWise mengakali masalah biaya ini? Prinsipnya adalah mereka memiliki banyak akun bank dengan saldo memadai di berbagai negara. Sehingga ketika pengguna mendaftar di TransferWise, pengguna juga dapat memiliki banyak akun dalam berbagai macam mata uang. Supaya mudah dipahami, saya akan memakai kasus saya bagaimana saya mengirimkan uang dari Estonia ke Indonesia.

Anggap lah saya mengirimkan 100€. Maka susunannya kira-kira akan seperti ini.

![Sistem Wise](/blog-img/sistem-transferwise.jpg)

Sampai sini semoga jelas ya, mengapa TransferWise bisa sangat murah dan cepat hanya dalam hitungan menit untuk mengirim dari Estonia ke Indonesia.

Nah, masalah baru lagi akan muncul di situasi sebaliknya. Mengirim uang dari Indonesia ke Estonia (transfer ke luar negeri). Mengapa? Masalahnya adalah TransferWise tidak menyediakan layanan untuk mengirim uang Rupiah ke mata uang lain. Jadi kita hanya bisa menerima bayaran dari luar tanpa bisa mengirim ke luar. Mungkin ada regulasi yang harus dipenuhi oleh TransferWise ke Bank Indonesia jika mau mengadakan layanan pengiriman tersebut.

### Mari berkenalan dengan Jenius

[Jenius](https://www.jenius.com/) adalah layanan perbankan dari PT Bank BTPN (~~Bank Tanpa Papan Nama~~ Bank Tabungan Pensiunan Nasional.) Sebetulnya memang benar kalau disebut tanpa papan nama, karena Jenius ini merupakan layanan yang operasionalnya hanya dari aplikasi di ponsel pintar dan kartu debit. Kita bisa menabung, mengatur keuangan, membayar tagihan, dan membayar transaksi *online* baik di dalam maupun di luar negeri. Jenius sendiri secara resmi tidak memiliki layanan untuk melakukan transfer antar negara. Hal ini bisa dilihat di [FAQ mereka](https://www.jenius.com/faq/transfer).

Tetapi...*drum roll*

Dengan mengkombinasikan Jenius dengan TransferWise kita bisa transfer ke luar negeri dengan biaya super rendah tanpa harus mengantre ke bank. Di gambar ini lah rahasianya. Ternyata kita bisa mendepositkan mata uang Euro dengan menggunakan kartu debit Visa/Mastercard. Kartu debit Jenius menggunakan Visa.

![Debit Card](/blog-img/tw-step-2.png)

Kamu bisa lihat di gambar di atas, untuk mengirim 41€ dari Indonesia biayanya HANYA 0,14€. Jauh sekali dibandingkan *wire transfer* secara tradisional yang bisa menghabiskan Rp300.000-Rp400.000. Jadi skema pengirimannya akan seperti ini kira-kira.

![Sistem Jenius](/blog-img/sistem-jenius.jpg)

Oh, iya, karena kartu debit Jenius ini menggunakan mata uang Rupiah, jadi TransferWise memberikan biaya tambahan untuk melakukan konversi dari Rupiah ke Euro. Biayanya tetap saja murah 1,23€. Jadi total biaya transfer untuk 41€ adalah 1,37€. Sangat jauh bukan dibanding transfer bank tradisional.

![Biaya tambahan](/blog-img/tw-step-3.png)

### Kesimpulan

TransferWise memiliki kemampuan untuk mengirim uang dengan biaya murah ke 59 negara termasuk Indonesia dan cepat hanya dalam hitungan menit (selama dilakukan saat hari kerja.) Sedangkan Jenius memberi kemudahan untuk membayar transaksi di *merchant* luar negeri. Catatan penting:

1. Pastikan setelah membuat akun di [Wise](https://wise.com/invite/u/asepp1), kamu membuka *balance* untuk mata uang Euro. Karena saat ini hanya *balance* Euro yang bisa di-*top up* dengan menggunakan debit Visa/Mastercard. Semisal tujuan transfermu adalah bank di Amerika Serikat, kamu bisa kirim USD dari *balance* Euro dengan biaya yang masih tetap rendah.
2. Kartu Jenius yang dapat digunakan di TransferWise adalah m-Card (kartu utama) karena saya sudah coba menggunakan e-Card (kartu virtual) dan selalu ditolak oleh sistem.

Semoga artikel ini bermanfaat untuk teman-teman yang memiliki urusan bisnis di luar negeri atau mengirimkan uang ke kerabat di luar negeri.



Dua minggu terakhir ini saya sibuk mengerjakan sebuah proyek sampingan pribadi yang berhubungan dengan pasar finansial, yaitu melakukan otomatisasi terhadap kegiatan perdagangan di bursa cryptocurrency. Saya yakin untuk yang sudah terbiasa melakukan kegiatan *trading* pasti sering mendengar istilah *robot trading*. Di mana perdagangan dilakukan secara otomatis oleh komputer.

!["Candlestick chart"](/blog-img/candlestick.jpg)
<a style="background-color:black;color:white;text-decoration:none;padding:4px 6px;font-family:-apple-system, BlinkMacSystemFont, &quot;San Francisco&quot;, &quot;Helvetica Neue&quot;, Helvetica, Ubuntu, Roboto, Noto, &quot;Segoe UI&quot;, Arial, sans-serif;font-size:12px;font-weight:bold;line-height:1.2;display:inline-block;border-radius:3px" href="https://unsplash.com/@m_b_m?utm_medium=referral&amp;utm_campaign=photographer-credit&amp;utm_content=creditBadge" target="_blank" rel="noopener noreferrer" title="Download free do whatever you want high-resolution photos from M. B. M."><span style="display:inline-block;padding:2px 3px"><svg xmlns="http://www.w3.org/2000/svg" style="height:12px;width:auto;position:relative;vertical-align:middle;top:-2px;fill:white" viewBox="0 0 32 32"><title>unsplash-logo</title><path d="M10 9V0h12v9H10zm12 5h10v18H0V14h10v9h12v-9z"></path></svg></span><span style="display:inline-block;padding:2px 3px">M. B. M.</span></a>

Saya memutuskan untuk membangun sistem sendiri dari nol dengan tujuan supaya benar-benar paham bagaimana sistem yang saya bangun bekerja sambil terus mengasah ilmu di bidang *[algorithmic trading](https://www.investopedia.com/articles/active-trading/101014/basics-algorithmic-trading-concepts-and-examples.asp)*.

Perlu diingat bahwa artikel yang saya tulis ini sifatnya hanya catatan belajar saya, jadi jangan ditelan mentah-mentah.

### Perkenalan Tentang High-Frequency Trading

High-Frequency Trading (HFT) adalah strategi perdagangan aset di mana *trader* tidak menyimpan aset lama-lama, biasanya tidak akan lebih dari satu hari dengan keuntungan dari setiap *trade* sangat tipis tetapi dilakukan dengan jumlah yang banyak. Strategi dieksekusi secara cepat oleh komputer. HFT biasanya digunakan oleh *investment banks*, hedge fund, atau investor institusional untuk bertransaksi dalam volume yang besar dan kecepatan tinggi (bisa sampai hitungan milidetik) di bursa efek.

Di Indonesia, HFT tidak bisa digunakan di Bursa Efek Indonesia karena tidak diperbolehkan dan mungkin memang sistem di bursanya sendiri belum siap.

Oleh karena itu, untuk proses belajar, saya beralih ke bursa cryptocurrency karena bursa-bursa cryptocurrency pada umumnya memiliki API (Application Programming Interface) untuk mengakses data perdagangan secara *real-time* dan API untuk membuka posisi jual/beli.

### Arsitektur Sistem

Sistem yang saya buat menggunakan arsitektur *microservices* untuk memastikan bahwa sistem ini bisa diperbesar lagi dengan mudah *(scalable)*. Ada empat *services*: Raw Data Service, Trading Service, Trading Strategy Development Service, dan Data Warehouse.

!["Arsitektur Sistem"](/blog-img/my-hft-system.jpg)
*Arsitektur sistem trading yang saya rancang.*

#### Raw Data Service

*Service* ini digunakan untuk mengambil *ticker* secara berkala dari bursa. *Ticker* adalah data harga jual dan beli pada suatu aset. Untuk saat ini saya ambil per 30 detik sekali untuk setiap aset karena saya rasa untuk saat ini belum perlu dilakukan lebih cepat lagi.

Data mentah yang didapat dari bursa langsung dimasukkan ke data warehouse agar nantinya bisa dianalisa dan digunakan untuk membuat strategi perdagangan. Selain dimasukkan ke Data Warehouse, data mentah ini juga dikirimkan secara *real-time* ke Trading Service menggunakan format MsgPack melewati MQTT Broker.

Raw Data Service saya bangun dengan menggunakan *framework* Ruby on Rails. Mungkin terlihat *overkill* ya menggunakan Rails untuk *service* sesederhana ini. Alasan saya menggunakannya karena selain saya sudah terbiasa, Rails juga sangat cepat untuk melakukan pembuatan purwarupa aplikasi yang banyak menggunakan CRUD, dan ada fitur Active Jobs sehingga saya tidak perlu pusing-pusing melakukan konfigurasi *cron jobs*.

#### Trading Service

Untuk *service* ini saya menggunakan Python tanpa *framework*. Mengapa Python? Karena ekosistem pustaka-pustaka pengolahan data dan analisa data sangat berlimpah dibandingkan Ruby.

Di dalam Trading Service ini lah algoritma *trading* diimplementasikan. Sistem akan bereaksi terhadap *ticker* yang didapat dari MQTT Broker, apakah sebaiknya melakukan posisi beli atau jual. Ketika sinyal beli atau jual sudah keluar, *service* ini akan mengontak Trading API di bursa.

#### Trading Strategy Development Service

*Service* ini tidak berhubungan dengan bursa sama sekali. Di bagian ini lah saya melakukan [analisa teknikal](https://en.wikipedia.org/wiki/Technical_analysis) dengan menggunakan berbagai macam indikator, membangun algoritma yang akan digunakan sebagai strategi, dan juga melakukan *backtesting*. *Backtesting* adalah tahapan menguji algoritma dengan menggunakan data historis apakah algoritma tersebut menguntungkan atau tidak. Data historis ini saya ambil dari Data Warehouse.

!["Backtesting"](/blog-img/backtest.png)
*Contoh hasil backtesting menggunakan data satu hari ke belakang dengan timeframe satu menit*

#### Data Warehouse

Di sini saya menggunakan PostgreSQL untuk melakukan penyimpanan data time series. Sejauh ini masih memadai.

### Kesimpulan

Sistem yang saya bangun ini belum lah sempurna (boleh dibilang HFT abal-abal haha) dan masih jauh dari sistem HFT di luar sana yang dengan kecepatan tinggi dapat melakukan *trading* dalam hitungan milidetik. Bahkan hingga membuat *[flash crash](https://en.wikipedia.org/wiki/2010_Flash_Crash)* pada pasar.

Mari jika mau berdiskusi atau memberi saran bisa tinggalkan pesan di kolom komentar atau lewat email saya yang tercantum di menu sebelah kiri.

<u>**Daftar API dan pustaka pemrograman yang digunakan**</u>

- [Indodax](https://indodax.com). Bursa cryptocurrency Indonesia yang saya gunakan. Dokumentasi API-nya dapat dilihat [di sini](https://indodax.com/downloads/INDODAXCOM-API-DOCUMENTATION.pdf).
- [TA-Lib](http://ta-lib.org/). Pustaka pemrograman pada bahasa C untuk melakukan analisa teknikal. Dapat digunakan untuk Python melalui *[wrapper](https://github.com/mrjbq7/ta-lib)*.
- [Pandas](https://pandas.pydata.org/). Pustaka Python untuk melakukan analisa data.
- [Numpy](https://numpy.org/). Pustaka Python untuk array dan matriks multi-dimensi yang besar.
- [Backtrader](https://www.backtrader.com/). Framework untuk melakukan *backtesting* dengan menggunakan Python.
- [Mosquitto MQTT Broker](http://mosquitto.org/). Pub/sub messaging untuk protokol MQTT. Ada MQTT kliennya untuk Ruby dan Python.
- [MessagePack](https://msgpack.org/index.html). Serialisasi data dengan menggunakan format biner. Lebih kecil ukurannya dibanding JSON.
- [Ruby on Rails](https://rubyonrails.org). Ruby web framework.
- [Dokku](https://github.com/dokku/dokku). Platform-as-a-Service berbasis Docker. Anggap saja Heroku tapi di-*host* di server sendiri.



Saya sering sekali mendapat pertanyaan dari teman atau kenalan setiap kali mereka melihat website [Tanibox](https://tanibox.com), "Loh, Tanibox itu alamatnya di Estonia? Kok, bisa? Kenapa?" Untuk menjawab pertanyaan ini, saya harus memulai dengan menjelaskan program [Estonia e-Residency](http://e-resident.gov.ee/). Sedangkan untuk menjawab pertanyaan, "kenapa kok Estonia?", kamu bisa memulai kisah awalnya di tulisan saya pada tahun 2017 [di sini](/id/artikel/pengalaman-mengagumkan-mendaftarkan-perusahaan-di-estonia).

!["Running Remote 2019"](/blog-img/running_remote.jpg)
*Menjadi panelist di Running Remote Conference 2019 bersama tim dari pemerintah Estonia untuk program e-Residency*

### Sedikit fakta tentang Estonia

Estonia adalah sebuah negara kecil di Eropa Utara dan merupakan anggota dari Uni Eropa. Negara tetangganya adalah Rusia di sebelah timur, sebelah selatan berbatasan dengan Latvia, sedangkan di utara dan barat berbatasan dengan Laut Baltik. Di seberang utara Laut Baltik, terdapat negara Finlandia yang berjarak 2,5 jam penyebrangan menggunakan feri. Populasi penduduk di Estonia hanya berkisar 1,3 juta jiwa saja.

Setelah merdeka dari Uni Soviet pada tahun 1991, Estonia berinvestasi cukup banyak di infrastruktur digital. Hingga saat ini, mereka dikenal sebagai negara yang paling maju di bidang e-Government. Penduduk di Estonia sudah terbiasa mengakses semua portal dan layanan pemerintah secara _online_. Berbekal satu kartu identitas (eID), warga Estonia bisa mendirikan perusahaan, mengurus keperluan administratif seperti ganti alamat, mendeklarasikan pajak, melakukan tandatangan dokumen-dokumen legal, melakukan pemilihan umum, dan bahkan di beberapa kota besarnya kartu identitas tersebut bisa terhubung dengan tiket transportasi publik.

### Program e-Residency

Di tahun 2014, pemerintah Estonia memutuskan untuk membuka akses infrastruktur digital mereka untuk semua orang, tidak peduli apa pun kewarganegaraannya. Program ini bernama Estonia e-Residency. Dengan mengikuti program e-Residency, kamu akan mendapatkan kartu eID Estonia yang bisa dicolokkan ke laptop dengan menggunakan _smart card reader_.

Bedanya dengan kartu eID milik warga yang tinggal di Estonia adalah eID e-Residency hanya dapat dipakai untuk urusan bisnis perusahaan saja, seperti pendirian perusahaan, tandatangan dokumen legal perusahaan, akses perbankan Estonia, dan perpajakan.

!["Kartu e-Residency"](/blog-img/e-residency_asep.jpg)
*Kartu eID Estonia milik saya. Ini kartu versi pertama, versi berikutnya sudah memiliki desain berbeda.*

### Keuntungan menjadi Estonia e-Resident dan membuka perusahaan di Estonia

Mengapa Estonia dan bukan negara lain? Berikut ini beberapa alasannya.

1. Kalau kamu menargetkan pasar Uni Eropa, maka mendirikan perusahaan di Estonia merupakan pilihan tepat karena Estonia juga merupakan anggota Uni Eropa. Transfer bank antar negara Uni Eropa dapat dilakukan secara instan tanpa ada biaya tambahan karena ada SEPA (Single Euro Payments Area.) Ini akan memudahkan klienmu dan kamu.
2. Estonia tidak menerapkan pajak korporasi berdasarkan pendapatan perusahaan, tapi berdasarkan deviden yang didistribusikan. Jadi kalau perusahaanmu tidak membagi deviden di akhir tahun, maka perusahaanmu tidak perlu membayar pajak ke pemerintah. Pajaknya ini sekitar 20%.
3. Untuk membuka perusahaan di Estonia, kamu diharuskan menyetor modal awal _(share capital)_ sebesar 2,500€. Nah, di sini serunya, kamu bisa menangguhkan penyetoran modal awal ini hingga 10 tahun. Jadi kamu bisa memulai bisnis dulu hingga pemasukanmu cukup mumpuni tanpa harus dibebani menyetor modal sebesar itu.
4. Perusahaan Estonia boleh 100% dimiliki oleh orang asing dan didirikan oleh hanya satu orang. Kalau PT di Indonesia, harus minimal dua orang pendiri dan tidak bisa 100% asing. Sehingga banyak dimanfaatkan juga oleh _freelancer_ yang akhirnya memilih mendirikan perusahaan untuk berbisnis. Menjalankan bisnis dengan menggunakan badan hukum jelas terlihat lebih terpercaya bukan dibanding tanpa badan hukum?
5. Mendirikan perusahaan di Estonia membutuhkan waktu kurang dari 24 jam dan semua dilakukan dari depan laptop bermodal eID. Tidak perlu panas-panasan mengantar berkas-berkas dan cetak-cetak dokumen.

### Kesalahpahaman yang umum seputar Estonia e-Residency

Ada beberapa kesalahpahaman yang umum dilontarkan oleh orang-orang ketika mendengar program e-Residency. Berikut saya tuliskan yang paling sering saya temui:

**1. "Kamu berarti berkewarganegaraan ganda dong, padahal kan Indonesia tidak mengakui kewarganegaraan ganda."**

Tidak. Estonia e-Residency tidak ada sangkut pautnya dengan kewarganegaraan. Program ini tidak memberikanmu paspor Estonia, program ini HANYA memberimu akses ke infrastruktur bisnis di Estonia secara _online_.

**2. "Kalau saya ikut program Estonia e-Residency berarti saya bisa bebas masuk ke Estonia tanpa perlu mengurus visa Schengen?"**

Tidak. Estonia e-Residency bukan lah pengganti visa dan tidak ada hubungannya sama sekali. Kalau kamu mau bepergian ke Estonia dan negara EU lainnya, maka kamu tetap harus mengurus visa Schengen seperti biasa.

**3. "Kalau saya mendirikan perusahaan di Estonia menggunakan e-Residency saya bisa pindah ke Estonia."**

Ya, ini bisa. Tentu saja lewat prosedur imigrasi standar. Kamu harus mengajukan izin tinggal, biasanya _temporary residence_ dan membuktikan ke pihak imigrasi kalau kamu memiliki koneksi dengan Estonia, misalnya punya klien di Estonia atau memiliki beberapa karyawan Estonia. Oh ya, kalau usahamu adalah startup teknologi, kamu bisa mengajukan visa startup Estonia. Tentu startup-mu harus lolos seleksi oleh _startup committee_ Estonia.

**4. "Kamu pasti mencoba menghindari pajak Indonesia dengan bikin perusahaan di Estonia."**

Tidak semudah itu, Ferguso! Estonia mengenakan pajak pendapatan pribadi berdasarkan tempat tinggal di mana seseorang itu berada. Jika saya tinggal di Indonesia dan merupakan _tax residence_ Indonesia, ya penghasilan yang saya dapat dari perusahaan di Estonia tetap saya laporkan dan bayarkan di Indonesia. Estonia tidak akan mengenakan pajak pendapatan pribadi ke saya, hanya pajak yang berhubungan dengan perusahaan yang saya bayarkan ke Estonia, contohnya pajak pertambahan nilai dari jasa perusahaan saya. Estonia bukan lah negara _tax haven_ tetapi lebih ke _administrative haven_, di mana semua proses berlangsung transparan dan tidak bertele-tele.

### Kesimpulan

Semoga artikel ini dapat membantu kamu untuk lebih memahami tentang program Estonia e-Residency. Kalau ada pertanyaan, silahkan tinggalkan pertanyaan di kolom komentar. 🙂



Dari awal saya berencana [exit dari Froyo](/id/artikel/terima-kasih-froyo-asep-is-out), saya sudah bersiap-siap mengurus aneka macam dokumen legal untuk perusahaan baru saya, Tanibox. Waktu itu saya segera mengurus pendirian PT yang berdomisili di Tangerang pada bulan Februari 2017. Saya menggunakan jasa notaris untuk pengurusan PT sampai tuntas. Waktu itu notaris saya cuma bilang, "kalau mengurus di Tangerang akan sedikit lebih lama loh birokrasinya, Mas, dibanding Jakarta. Bisa beda sekitar 2 bulan." Saya pun setuju. Perkiraan saya paling juga Mei 2017 udah beres. Ternyata meleset hingga 6 bulan!

Hasilnya sampai bulan Agustus 2017 ini (saat tulisan ini keluar), PT Tanibox Agritech Indonesia baru ada akte dan NPWP saja. SIUP sama sekali belum keluar. Luar biasa bukan?

!["Card in Use"](/blog-img/card-in-use.jpeg)
*Kartu e-Residency pada saat digunakan*

### Estonia E-Residency

Sekarang saya akan bercerita mundur sedikit ke tahun 2016. Di tengah tahun 2016, saya sempat membaca-baca berita soal Estonia e-Residency. Intinya adalah dengan memiliki kewarganegaraan digital Estonia, para entrepreneur di seluruh dunia bisa membuka perusahaan di Estonia hanya dari depan laptop di mana pun mereka berada.

!["Estonia Map"](/blog-img/estonia-map.png)
*Estonia dengan ibukotanya Tallin. Penduduk Estonia hanya sekitar 1,3 juta orang.*

Setelah membaca beberapa artikel lanjutan, akhirnya saya pun tertarik mencoba untuk menjadi early adopter Estonia e-Residency, walaupun waktu itu saya belum tahu pasti mau saya apakan e-Residency tersebut. Saya pun mendaftarkan diri di website [https://e-estonia.com/](https://e-estonia.com/), menyerahkan berbagai macam dokumen legal, dan membayar sekitar 100 Euro.

Dikarenakan Estonia tidak memiliki kedutaan besar di Indonesia, maka saya minta kartu e-Residency dikirimkan ke konsulat Estonia di Singapura. Di Singapura sendiri, Estonia hanya memiliki konsulat bukan kedutaan besar. Kedutaan besar terdekat dari Indonesia adanya di Beijing. Alhasil saya harus menunggu kartu e-Residency saya sampai di konsulat Singapura sekitar 3 bulan dari yang seharusnya 1 bulan sudah bisa saya dapatkan, karena kartunya harus jalan-jalan dahulu ke Beijing.

!["E-Residency Kit"](/blog-img/e-residency-kit.jpeg)
*Paket e-Residency yang isinya smart card dan card reader-nya.*

### Mendaftarkan Perusahaan di Estonia dengan e-Residency

Balik lagi ke tahun 2017. Saya pun memutuskan untuk mendaftarkan Tanibox di Estonia, karena setelah dipertimbangkan layanan Tanibox itu bisa dijual secara global. Selama pasarnya ada dan bisa dijangkau, kenapa harus membatasi diri dengan hanya berjualan di Indonesia? Kami memang bercita-cita bisa menembus pasar European Union, baik pasar customer-nya maupun pasar tenaga kerjanya. Estonia merupakan salah satu negara yang tergabung di European Union. Tentu akan lebih legit jika kami berbisnis di Eropa menggunakan entitas perusahaan Eropa dibanding menggunakan entitas Indonesia.

Saya menggunakan jasa [http://leapin.eu/](http://leapin.eu/) untuk mendaftarkan perusahaan saya di Tallinn. Prosesnya berlangsung sangat cepat, semua hanya dari depan laptop. Tidak perlu mengeluarkan pulpen maupun pergi ke tukang fotokopi. Semua hanya dengan menggunakan kartu e-Residency untuk login ke Website, menandatangani dokumen pendirian perusahaan, dan menandatangani dokumen-dokumen perpajakan.

!["LeapIN"](/blog-img/leapin.png)
*Proses onboarding di dashboard Leapin yang sangat transparan.*

Biaya awal yang saya keluarkan untuk semua proses pendirian Osaühing (OÜ) ini adalah 278,80 Euro. Prosesnya membuat saya kagum. Saya mendaftarkan diri di Leapin hari Selasa, 1 Agustus jam 5 sore, yang artinya di Tallinn jam 12 siang. Keesokan harinya, Rabu, 2 Agustus jam 8 malam yang berarti di Tallinn jam 3 sore Tanibox OÜ sudah terdaftar di Estonia dan sudah bisa digunakan untuk berbisnis.

Satu-satunya kelemahan dari sistem e-Residency (untuk saat ini), adalah belum bisa membuka rekening bank di Estonia secara jarak jauh. Tapi jangan khawatir, karena undang-undang untuk membuka rekening bank lewat jarak jauh dengan menggunakan Skype (Skype ini awalnya adalah startup Estonia sebelum dibeli Microsoft) sudah disahkan. Katanya sih Swedbank dan LHV, akan mulai tes implementasi di kuartal ketiga tahun 2017. Untuk sementara waktu, bagi entrepreneur yang belum mau mengeluarkan uang untuk perjalanan ke Estonia demi membuka rekening bank, maka dapat menggunakan layanan seperti Transferwise Borderless atau Holvi untuk menerima, menyimpan, dan mengirimkan uang dari dan ke rekening bank di negaranya masing-masing.

### Kesimpulan

Maka perbandingan antara mendirikan PT Tanibox Agritech Indonesia yang berdomisili di Tangerang dengan pendirian Tanibox OÜ yang berdomisili di Tallinn, adalah berikut ini.

**Tangerang, Indonesia**

Biaya: Rp 12.500.000 untuk jasa notaris dan mengurus PT sampai tuntas

Waktu yang dibutuhkan: 6 bulan dan belum beres :(

*Update terbaru: Akhirnya beres setelah 9 bulan!*

**Tallinn, Estonia**

Biaya: 278,80 Euro untuk jasa pengurusan pendirian OÜ sampai tuntas

Waktu yang dibutuhkan: kurang dari 24 jam kerja

*Ciiieeee….langsung jadi multinesyeeenel…*

<u>**Pembaruan tulisan di 2019**</u>

- LeapIN sudah berubah nama menjadi [Xolo](https://www.xolo.io)
- Sekarang Tanibox menggunakan jasa [1Office](https://www.1office.co) bukan LeapIN/Xolo lagi.
- Sampai 2019, membuka rekening bank Estonia tetap butuh datang langsung ke Estonia.



!["Mic drop"](/blog-img/mic_drop.jpg)
*A mic dropped is taken from [Flickr](https://www.flickr.com/photos/robnas/3400482826).*

Awal tahun 2017, seperti tahun-tahun sebelumnya saya membuat sebuah resolusi yang saya tuliskan di blog. Tidak seperti resolusi tahun-tahun sebelumnya yang saya tuliskan cukup panjang, tahun ini artikel tentang resolusi saya sangat singkat. Saya mau melakukan Mars-shot (istilah karangan saya sendiri,) karena moonshot menurut saya masih terlalu kecil.

Bulan Februari 2017, saya menyatakan niat untuk exit dari bisnis Froyo — perusahaan yang saya bangun bersama rekan saya Andika Alivano sejak 2012 (awalnya masih bernama Amazing Milk.) Tentu saja ini sebuah keputusan besar yang tidak diambil secara tiba-tiba. Saya sudah mulai memikirkan hal ini sejak kuartal pertama 2016 (tanpa bilang ke siapa-siapa selain ke istri saya tentunya.) Selama setahun saya berusaha mempersiapkan banyak hal, seperti misalnya mencari siapa yang bisa menggantikan saya kelak di Froyo. Sampai akhirnya, this is it!

Lalu sebenarnya apa yang saya kejar sampai harus exit? Mungkin ada dari teman-teman yang mengikuti petualangan istri dan saya dalam bertani? Semua terangkum dari tahun 2015 di dalam satu artikel [berikut ini](/posts/my-familys-journey-to-grow-our-own-food). Itu lah cikal bakal Tanibox. Saya dan istri saya punya visi dan cita-cita besar di industri agrikultur untuk Tanibox, dan kalau mau diseriusi maka kami harus fokus.

Selain itu, saya dan istri saya ingin membangun Tanibox di luar area Jabodetabek karena kami ingin merasakan hidup di luar Jabodetabek lagi. Mata kami tertuju pada Bali. Beberapa kali ke pulau tersebut, kami merasa di sana lah tempat yang cocok untuk memulai startup yang berhubungan dengan agrikultur dan teknologi. Tentu saja hal ini akan sulit dicapai jika saya harus membagi fokus dengan Froyo yang ada di Tangerang.

Oleh karena itu, akhirnya saya memutuskan untuk exit dari Froyo setelah melakukan berbagai macam perhitungan dan pertimbangan. Akhir kata saya ucapkan terima kasih kepada co-founder saya Andika dan seluruh tim Froyo baik yang sudah keluar, baru masuk, dan yang masih aktif berkarya di Froyo. Kalian memberikan saya banyak pengalaman yang sangat berharga sejak tahun 2012.

Keep up your great works and wish me luck in the new journey. Cheers!


Asep Bagja Priandana

Featured article

Bye, Bali! Sampai Jumpa Lagi.

Podcasts

Catatan Asep Bagja

Ngopini Sejenak

Ujung Ke Ujung

English

Experiment: Boost Node.js App Performance With Rust

Insights to Sell Agritech Product

Going Back to My Personal Web

Bahasa Indonesia

Perjalanan Satu Dekade Saya

Mengakali Biaya Transfer Uang Antar Negara Dengan Jenius dan Wise

Membangun Sistem High Frequency Trading Sederhana