
Next.js has two forms of pre-rendering: **Static Generation** and **Server-side Rendering**. The difference is in **when** it generates the HTML for a page.

- **Static Generation** is the pre-rendering method that generates the HTML at **build time**. The pre-rendered HTML is then _reused_ on each request.
- **Server-side Rendering** is the pre-rendering method that generates the HTML on **each request**.

Importantly, Next.js lets you **choose** which pre-rendering form to use for each page. You can create a "hybrid" Next.js app by using Static Generation for most pages and using Server-side Rendering for others.



Static Generation and Server-Side Rendering

Two Forms of Pre-rendering


# Vim

Vim is a highly configurable text editor built to make creating and changing any kind of text very efficient. It is included as "vi" with most UNIX systems and with Apple macOS.

## Installation

Because we want an addon thats called `You complete me`, we cant use the standard `vim` that comes with the macbook pro.

To install the latest version, use homebrew:

``` 
brew install vim 
```

Set the following infront of your path so when you use `vim <file>` it will open the version you just installed via homebrew.

In `.zshrc` copy it should look something like this:

```
export PATH="/usr/local/bin:$PATH
```

Now you have `vim` with python 8 so you can use all the features of your normal text editor in `vim`.

## The Ultimate vimrc

The Ultimate vimrc is a collection of vimrc configurations to make easy the usage of vim.

To download the The Ultimate vimrc, you need to install the git client. If you need install it, use home brew:

```
brew install git
```

Now, download the vimrc files:

```
git clone https://github.com/amix/vimrc.git ~/.vim_runtime
```

To install the complete version, run:

```
sh ~/.vim_runtime/install_awesome_vimrc.sh
```

To install the basic version, run:

```
sh ~/.vim_runtime/install_basic_vimrc.sh
```

Vim - The ultimate text editor?


A short post to all those who have difficulty with repository hell. This Git command parts the sea, brings peace and makes the local repository die for your sins.

Especially in IntelliJ i was faced with this issue numerous times, not being able to switch branches without going through some kind of satanic IntelliJ ritual of saving the repo changes to a shelf.

The solution is here:

**Force overwrite of local files from remote repository:**

```
$ git fetch --all
$ git reset --hard origin/master
```

**To download changes from some other branch**

Use the following command:

```
$ git reset --hard origin/<insert_other_branch>
```

> _`Git fetch` downloads latest updates from remote, but doesn't merge or rebase in local files._

Thank the lord! The repo is resurrected back to its stable form!

### Want to know more, check out the [Git cheat sheet here!](https://github.github.com/training-kit/downloads/github-git-cheat-sheet.pdf)

GIT Command - Overwrite Trick


# IntelliJ Tricks to boost productivity

IntelliJ is a smart IDE used to code Java/Scala/Kotlin. It uses something called Jetbrains to almost code for you. Here is my favorite summery of keyboard shortcuts which made me WAY more productive in this heavy IDE.

## **Moving the cursor**

- One word at a time:

  - `Ctrl + Cursor`

- Move cursor to beginning of line:

  - `Home`

- Move cursor to end of line:
  - `End`

## **Moving the lines**

- Move line up:

  - `Shift + Alt + Up`

- Move line down:
  - `Shift + Alt + Down`

## **Format code**

- Duplicate line:

  - `Ctrl + D`

- Delete line:

  - `Ctrl + Y`

- Parameter info:

  - `Ctrl + P`

- Comment out selected line:

  - `Ctrl + /`

- Comment out code block:

  - `Shift + Ctrl + /`

- Fold code block:
  - `Shift + Ctrl + -/+`

## **Navigate through code**

- To class:

  - `Ctrl + N`

- To file:

  - `Shift + Ctrl + N`

- To symbol:

  - `Shift + Ctrl + Alt + N`

- Go back:

  - `Shift + Ctrl + <-/->`

- Find action:

  - `Shift + Ctrl + A`

- Search everywhere
  - Searches classes/files/symbols/actions)
  - Use tab to jump to type
  - `Shift + Shift`

## **The Nr 1 Productivity killer**

### File tabs

When using intelliJ you collect file tabs of previous files you have looked through or coded in.

This makes for bad productivity since you would have to pause your work and close the tabs one by one.

Instead! Disable tabs and use the recent files function!

1. In the find action, search for "tabs placement"
2. Disable "tabs placement"
3. Then use the following shortcut to navigate your recent files:

- Recent files

  - `Ctrl + E`
  - Search in recent files by writing the filename of the file you desire to look/work on.

- Recent edited files:
  - `Shift + Ctrl + E`

## **Code selection**

- Select line

  - `Shift + Home/End`

- Select words

  - `Shift + Ctrl + <-/->`

- Select characters

  - `Shift + <-/->`

- Extending selection

  - `Ctrl + W`

- Shrinking selection
  - `Shift + Ctrl + W`

## **Code completion**

- Envoking smart code completion:

  - `Shift + Ctrl + Space`
  - Most usefull:

    - After the new keyword in an object declaration
    - In the list of parameters of a method call
    - In return statements

  - `Shift + Ctrl + Space` `Twice`
  - Invokes smart code which completes:
    - Static expressions
    - Collections, lists and arrays

* Static method completion:
  - `Ctrl + Space + Ctrl + Space`

### Postfix completion

What is postfix expressions?

- Postfix notation is used to represent algebraic expressions.

Example:

```java
public class PostFixCompletion {
    void method(Collection<String> s) {
        // Postfix expression:
        if (s == null) {
            //...
        }
    }
}
```

The `method` method takes in a colleciton of string `s`.
By writing `s.` then using the **postfix completion shortcut:** `Ctrl + J`
Will bring up a list of postfix expressions to choose.
Filter the list by writing:

- `nn` / `null` -> Checks expression to be null.
- `notnull` -> Checks expression to be not-null.
- `synchronized` -> Produces synchronization statement.
- `try` -> Inserts statement in try-catch block.
- `for` -> Iterates over enumerable collection.
- `fori` -> Iterates with index over collection
- `forr` -> Iterates with index in reverse order.

## **Code Generation**

**Getter & Setter methods**

- `Alt + Insert`

**Stub test, setUp, tearDown methods**

- `Alt + Insert`

## **Version Control tricks**

### **Commiting changes:**

- `Ctrl + K`
  - Brings up the built inn commit interface

#### Commit flow:

Inside the **commit interface**, the focus starts in the `commit message` box.

1. Write your commit message.

2. Go to your **change list**:

   - `Shift + Tab`

3. See the **differance** in a file:

   - `Ctrl + D`
   - Changes here are automatically sent to the change set.
   - Press `Esc` key to leave diff view.

4. **Revert** changes in a file:

   - `Ctrl + Alt + Z`
   - `tab` to the **revert** button
   - Press `Enter` key to confirm **revert** file.

5. **Before commit actions**:

   - Select to perform task before commit.

6. Press `Tab` button to move the focus to the **Commit** button
   - Press `Enter`

### **VC Popup Menu**

- Get a popup list of alle VC operations directly from a keyboard shortcut

  - `Alt + Back Quote`

- Each list item is accociated with a number which you can access by pressing on your keyboard.

- When selecting branch, search by typing in your search word.
  - Intellij will automatically filter the branch list as your typing.

## **Reformat:**

- `Tab` to move selection one tab stop to the right

- `Shift + Tab` to move selection one tab stop to the left

- `Ctrl + Alt + L` to reformat current selection or current file

- `Ctrl + W` to extend selection

- `Alt + 1` to move focus to the project tool window

TIP!

> Use `Ctrl + W` to expand selection, then `Ctrl + Alt + L` to reformat the code.

## **Optimaizing imports**

Imports can get messy when coding, which leads to libraries included that are not used.
This can be solved easily by using the `optimizing imports` shortcut:;

- `Ctrl + Alt + O`

### Optimize imports on the fly

When this is activated, intellij automatically changes and optimizes the imports as you code.

- `Shift + Ctrl + A` to open the **Actions** popup search field.
- Search for "_optimizing imports on the fly_" and activate it.

### Only optimize imports on commited files

- `Ctrl + K` to bring up the commit interface.
- Select `Optimize imports` in the **before commit** field.
- Select `Commit`

## **Navigate to Compilation Error**

When compiling an application in IntelliJ you will receive errors in the `event log`.
Instead of using the mouse to click the error that will send you to the errors location, simply do this:

- After a compilation error.
- Press `Esc`.
- Press `Ctrl + Alt + Down` to move to next error.
- Press `Ctrl + Alt + Up` to move back to the previous error.
- Then press `Esc` to move to the error location.

## **Bonus**

### Language injection

## **Other's**

### MultiCursor

```
ctrl + ctrl (hold last ctrl and move cursor)
```


IntelliJ IDE - Productivity Tricks


It can take a few weeks (if not months) getting started with React Native, can boilerplates give a jump start to mobile development? And if so, which are the best?

There are three boilerplates worth considering:

- [Ignitee](https://github.com/infinitered/ignite) - 9,375 stars
- [Pepperoni App Kit](https://github.com/futurice/pepperoni-app-kit) - 4,453 stars
- [Snowflake](https://github.com/bartonhammond/snowflake) - 4,399 stars

We will be taking a closer look at the most popular of them all, the `ignite` boilerplate.

## Ignitee CLI

Ignite is now the 'hottest' CLI for React Native.

It includes boilerplates, plugins, generators and more.

Ignite requires a Node version of 7.6+ minimum, check your version by running:

```
node -v
```

Install [`Yarn`](https://yarnpkg.com/lang/en/docs/install/) for your system.

Then run the following commands to add the `ignite-cli` and to create your `ignite` boilerplate.

```javascript
$ yarn global add ignite-cli
```

#### Ignite includes two primary boilerplates

##### Andross:

> The tried and true (React Navigation, Redux, & Redux Saga)

<img src="https://camo.githubusercontent.com/49c1245faf62f39e5a486e0df0f8e5fa281f06ac/687474703a2f2f69725f7075626c69632e73332e616d617a6f6e6177732e636f6d2f70726f6a656374732f69676e6974652f69676e6974652d616e64726f73732d6c61756e63682d73637265656e2e706e67" alt="Andross" width="400">

It includes:

- React Native 0.57.7
- React Navigation 3.0.0
- Redux
- Redux Sagas
- And more!

##### Bowser:

> The latest and greatest (React Navigation, MobX State Tree, & Typescript)

<img src="https://camo.githubusercontent.com/b598169ed7d3a9eea78e921acd10adee55bf53eb/687474703a2f2f69725f7075626c69632e73332e616d617a6f6e6177732e636f6d2f70726f6a656374732f69676e6974652f69676e6974652d626f777365722d6c61756e63682d73637265656e2e706e67" alt="bowser" width="400">

This boilerplate includes:

- React Native
- React Navigation
- MobX State Tree
- Typescript
- Reactotron (requires 2.x)
- And more!

I won't go into detail about these services in this post. I will choose a preferred boilerplate after testing and explain the services more in detail in a future post.

## How to:

Lets choose `ignite`s newest boilerplate `bowser`.

First of all to start of a bowser boilerplate, simply run the following command and choose `bowser` from the terminal menu:

```
$ ignite new MyNewAppName
-----------------------------------------------
  (                  )   (
  )\ )   (        ( /(   )\ )    *   )
 (()/(   )\ )     )\()) (()/(  ` )  /(   (
  /(_)) (()/(    ((_)\   /(_))  ( )(_))  )\
 (_))    /(_))_   _((_) (_))   (_(_())  ((_)
 |_ _|  (_)) __| | \| | |_ _|  |_   _|  | __|
  | |     | (_ | | .` |  | |     | |    | _|
 |___|     \___| |_|\_| |___|    |_|    |___|
-----------------------------------------------

An unfair headstart for your React Native apps.
https://infinite.red/ignite

-----------------------------------------------

🔥 igniting app BowserStyle
? Which boilerplate would you like to use? Bowser (React Navigation, MobX State Tree, & TypeScript)
> Bowser  *
> Andross
```

If you open your `NewAppProject` directory, you will see loads of files that come will the `ignite` boilerplate compared to the standard setup using `react-native new` or `expo init` command.

Run simulator:

```
For iOS:
  cd ProjectFolder
  react-native run-ios

For Android:
  cd ProjectFolder
  react-native run-android
```

To see what else Ignite CLI can do in the command line:

```
  cd ProjectFolder
  ignite
```

### Project directory structure

The project structure is some more advanced that a simple `react-native new` / `expo init` default project structure.

The project structure will look similar to this:

```
ignite-project
├── app
│   ├── components
│   ├── i18n
│   ├── models
│   ├── navigation
│   ├── screens
│   ├── services
│   ├── theme
│   ├── utils
│   ├── app.tsx
│   ├── environment-variables.ts
├── storybook
│   ├── views
│   ├── index.ts
│   ├── storybook-registry.ts
│   ├── storybook.ts
├── test
│   ├── __snapshots__
│   ├── storyshots.test.ts.snap
│   ├── mock-i18n.ts
│   ├── mock-reactotron.ts
│   ├── setup.ts
│   ├── storyshots.test.ts
├── README.md
├── android
├── ignite
│   ├── ignite.json
│   └── plugins
├── index.js
├── ios
└── package.json
```

Lets go deeper into the directories included in `Bowser`.

#### The `./app` directory:

Like when running the default structure commands, the `app` directory is present.

Inside the `app` directory, it will look similar to this:

```
app
│── components
│── i18n
├── models
├── navigation
├── screens
├── services
├── theme
├── utils
├── app.tsx
├── environment-variables.ts
```

**components:**
This is where your components live. Normally you would have components created with a `.js` file. Since `bowser` includes typescript, each component will have a directory containing a `.tsx` file, along with a `story.tsx` file. Optionally if the component is large, the component directory can include `preset.ts`, and `props.ts` files for better organisation.

**i18n:**
If you included the `react-native-i18n` service, this is where your translations live.

**models:**
This is where your models and model logic lives. Each model has a directory that contains the `mobx-state-tree` model file, test file, and other supported files like actions, types etc.

**navigation:**
Your `react-navigation` files live here.

**screens:**
The react screen component which takes up the entire screen and is part of the navigation hierarchy lives here. Each directory contains the `.tsx` file, assets or helper files.

**services:**
Services that interface with the outside world like REST APIs, Push Notifications etc, live here.

**theme:**
Your theme lives here, built including spacing, colors, typography, timing etc.

**utils:**
Shared files like helpers, utilities like date helpers, formatters etc are often placed here. If a helper or utility is only used by a specific component/model in your application the file should live with that component/model.

**app.tsx:**
Your entry point to your application. The main App component that renders the rest of the application. You can also choose if you would like to run the app in storybook mode.

#### The `./ignite` directory:

This is where the `ignite` CLI and all things `ignite` live. Generators, plugins and examples are included to help you get started.

#### The `./storybook` directory:

This is where stories will be registered and where the Storybook configs will live.

[Storybook](https://storybook.js.org/basics/guide-react-native/) is a UI development environment for rapid iteration and testing of UI components. This allows you to visualise the different states of the individual components of your app and test the UI interactions.

#### The `./test` directory:

This is where your Jest configs and mocks live. As well as storyshots test files.

## Attaching to Expo

If you are like me and use the `expo` toolchain to kick of your project, and you would still like to use one of Ignites boilerplates simply use the command:

```
expo init <AppName>
cd <AppName>
ignite attach
// Then choose which boilerplate you would like to use
```

This also works for:

- create-react-native-app
- create-react-app
- normal Reach JS projects
- empty directories

Not all plugins work in all environments, but many features of Ignite CLI are available.

For more info check out their documentation at https://expo.io/ !

React Native: Boilerplates overview


Inspired by the (Reactive movement - manifesto)[https://www.reactivemanifesto.org/], rxJava is an implementation of Reactive Stream specification created by Netflix. Reactive streams is a concept for handling data streams asynchronous. It is built by Netflix to be able to effectively reduce network chattiness. Their goal with rxJava is to allow the client to invoke a single "heavy" client request that is executed in parallel on the server.

Its concept is based on an `Observable`/`Iterable` type and `Subscribing` on these to send data streams async.

The following notes are not explained in high detail. Since in the process of writing this i switched to the `Reactor` library, because of upgrading to Spring Boot 2, which needs Java 8 and rxJava only runs Java 6. Both are based on a similar concept but different in structure.

## Observable / Iterable

**`Observable`** data type can be thought of as a "push" equivaltent to `Iterable` which is "pull".

**`Iterable`** data type pulls values from the producer and the thread blocks until those values arrive.

The producer pushes values to the consumer whenever values are available.

Which creates an approach which is more flexible, because values can arrive synchronously or async.

#### `Observable` type

Adds two missing semantiqcs which are present in the `Iterable` type:

- Producer can signal to the consumer that there is no more data available.
- Producer can signal to the consumer that an error har occured.

This makes `Observable` and `Iterable` unified.

The only difference is the direction which the data flows.

Always return `Observable`, always request `Iterable`.

#### Creating an Observable from existing Data structures

- From existing data structures:
- Use the Observable `just()` and `from()` methods to convert objects, lists, or arrays of objects into Observables that can emit those objects.

```java

Observable<String> o = Observable.from("a","b","c");

// Inserting a list into an observable
def list = [5,6,7,8]
Observable<Integer> o = Observable.from(list);

//
Observable<String> o = Observable.just("one object");

```

#### Creating an Observable via the `create()` method

- Via the `create()` method, you can implement async i/o, computational operations, or even 'infinite' streams of data by designing your own Observable.

###### Synchronous Observable example:

- Custom Observable that blocks when subscribed to (does not spawn an extra thread)

```java
def customObservableBlocking() {
    return Observable.create(
        { aSub ->
            for (int i=0; i<50; i++) {
                if (false == aSub.isUnsubscribed()) {
                    aSub.onNext("value_" + i);
                };
        }
        // after sending all values we complete the sequence
        if (false == aSub.isUnsubscribed()) {
            aSub.onCompleted();
        }
    });
}

// Output:
customObservableBlocking().sub({ it -> println(it); });
```

###### Asynchronous Observable example:

- Observable that emits 75 strings.
- Doesn't block when subscribed to as it spawns a separate thread.

```groovy
def customObservableNonBlocking() {
    return Observable.create(
        { sub ->
            final Thread t = new Thread(new Runnable() {
                void run() {
                    for (int i = 0; i < 75; i++) {
                        if (true == sub.isUnsubscribed()) {
                            return;
                        }
                        sub.onNext("value_" + i);
                    }
                    if (false == sub.isUnsubscribed())
                }
            });
            t.start();
        }
    );
}
// Output:
customObservableNonBlocking().sub({ println(it) })
```

- Fetch a list of Wiki articles async, in Groovy:

```groovy
def fetchWikiArticleAsync(String... wikiArticleNames) {
    return Observable.create({ sub ->
        Thread.start( {
            for (articleName in wikiArticleNames) {
                if (true == sub.isUnsubscribed()) {
                    return;
                }
                sub.onNext(new URL("http://en.wikipedia.org/wiki/" + articleName).getText());
            }
            if (false == sub.isUnsubscribed()) {
                sub.onCompleted();
            }
        });
        return(sub);
    });
}

// Output:
fetchWikiArticleAsync("Tiger", "Elephant")
    .sub({println "--- Article ---\n" + it.substring(0, 125); });
```

#### Transforming Observables with Operatiors

- Chain `operators` together to transform and compose Observables
- Async call `customObservableNonBlock` with chaining:

```java
def simpleComposition() {
    customObservableNonBlocking().skip(10).take(5)
        .map({ stringValue -> return stringValue + "_xform" })
        .subscribe({ println "onNext => " + it })
}
```

- `skip(10)` - Jumps to the 10th value
- `take(5)` - Grabs the 5 next values
- `map(...)` - maps each value and concatenates `stringValue` with `_xform` => `$stringValue_xform`
- `subscribe(...)` - returns the mapped values with `onNext =>` concatenated

This is an early rxJava summery. Switching to the `reactor` library instead, the concepts are the same but structured differently/more simply and accepts Java 8.

More information about rxJava, check it out here: (HERE)[https://github.com/ReactiveX/RxJava]


Reactive Data Streams - quick rxJava Summery


Home Assistant recently came out with their new UI in January. A ui called Lovelace it has now become their default ui interface. Taking a new approach for building user interfaces for Home Assistant.

Note! I had to cut this project short because of the timeframe for my new job, but here is a quick overview over my custom Lovelace UI which i was able to put together.

A dynamic UI with a whole new set of features:

- 24 card grid.
- A UI editor.
- Faster!
- And fully customizable
  - Cards have a list of attributes and options which can alter how your data is presented.
  - Themes!
  - Entity overriding privileges (name and icon).
  - Custom cards built from the HA community.

<center>
  <img src='/assets/images/ha-step3/lovelace-default.png' height="80%" width="80%" style="padding:10px;"/>
</center>

This is whats so fun about this new platform is that the community is blooming. Make HA work for you!

Take a look at my UI in mobile view:

<center >
  <img src='/assets/images/ha-step3/ui-1.png' height="40%" width="40%" style="padding:10px;"/>
  <img src='/assets/images/ha-step3/ui-3.png' height="40%" width="40%" style="padding:10px;"/>
  <img src='/assets/images/ha-step3/ui-2.png' height="40%" width="40%" style="padding:10px;"/>
  <img src='/assets/images/ha-step3/ui-4.png' height="40%" width="40%" style="padding:10px;"/>
  <img src='/assets/images/ha-step3/ui-5.png' height="40%" width="40%" style="padding:10px;"/>
  <img src='/assets/images/ha-step3/ui-6.png' height="40%" width="40%" style="padding:10px;"/>
</center>
<br>


Home Assistant - Lovelace introduction: Step 3


The question that confuses most beginners in react.

What is the difference of props and state?

Lets clarify this.

Props includes data which we give to a component.

State includes data that is local or private to that component. So other components cannot access that state, it s completely internal to that component.

Lets say we have a Counters component.

```javascript
import React, { Component } from 'react';
import Counter from './counter';

class Counters extends Component {
  state = {
    counters: [
      {id: 1, value: 0},
      {id: 2, value: 0},
      {id: 3, value: 0},
      {id: 4, value: 0}
    ]
  };
    render() {
    return (
      <div>        
        { this.state.counters.map(counter =>
          <Counter key={counter.id} value={counter.value} id={counter.id}>
          </Counter>
          )
        }
      </div>
    );
  }
}

export default Counters;
```

If you take a closer look at the `render` method of the `Counters` component:

```javascript
<Counter key={counter.id} value={counter.value} id={counter.id}></Counter>
```

All attributes we are setting here are part of the `props`, the input to the `Counter` component.

We cannot access the `state` of this component. It is local and internal to that component.

Props is read only, for example lets look at the `Counter` component.

```javascript
import React, { Component } from 'react';

class Counter extends Component {
  state = {
    value: this.props.value
  };

  handleIncrement = product => {
    this.setState({value: this.state.value + 1});
  };

  render() {
    return (
      <div>
        <span className='badge badge-warning'>{this.state.value}</span>
        <button
          onClick={ () => this.handleIncrement({ id: 1 }) }
          className="btn btn-secondary btn-sm">click
        </button>
      </div>
    );
  }
}

export default Counter;
```

Look closer at the helper method `handleIncrement`, which increments the counter by one:

```javascript
handleIncrement = product => {
  this.setState({value: this.state.value + 1});
};
```

If we update the `handleIncrement` method to update the `props.value` like this:

```javascript
handleIncrement = product => {
  this.props.value = 0;
  // this.setState({value: this.state.value + 1});
};
```

And we increment it in the view, we would get this error:

<img src="https://i.ibb.co/gyXg32t/Screenshot-2019-02-19-at-09-51-31.png" alt="react-native prop error" width="600">

So react does not allow you to change any props to any component.

If you would like to modify the input during the lifecycle of a component, you have to get that input and put it in the state like initially done in the `handleIncrement` method:

```javascript
handleIncrement = product => {
  this.setState({value: this.state.value + 1});
};
```

## More information about state and props

For more information about [state](https://facebook.github.io/react-native/docs/state) and [props](https://facebook.github.io/react-native/docs/props) visit the react [docs.](https://facebook.github.io/react-native/docs)

React Native: State vs Props


For React Native we need `node`, `Watchman`, React Native CLI and `Xcode`.

**node:**
* A javascript package manager.

**Watchman:**
* A service for watching changes in files and trigger actions when files are changed.

**React Native CLI:**
* A command line interface module for React Native.

**Xcode:**
* Apples IDE to test your application on an Iphone simulator.

## 1. Install `node` and `Watchman`

Install node and watchman using [Homebrew](https://brew.sh/index_se.html).

```
brew install node
brew install watchman
```

## 2. Install React Native CLI

Install React Native CLI with the node package manager (npm).

```
npm install -g react-native-cli
```
## 3. Install Xcode and the Xcode Command line tools.

Install [Xcode from the app store](https://itunes.apple.com/us/app/xcode/id497799835?mt=12).

In Xcode preferences, go to `locations` and download the Xcode CLI found at `Command Line Tools`.

Go to `Components` and download a simulator of your choice, preferably the newest.

## 4. Starting a React Native project

Now you can run these commands in your terminal to start of a React Native project:

```
react-native init MyApp
cd MyApp
react-native run-ios
```

This will initiate a React Native project, and showcase it in an iOS simulator that should look similar to this:

<img src="../assets/images/React-native-ios.png" alt="react-native" width="400">

## Expo

Expo is a free toolchain built around React Native like `react-native` to help build native iOS and Android projects.

The toolchain provides tools to simplify development of React Native apps by supplying components of users interface and services that are normally available in third-party native React Native components. All these you can find in Expo SDK.

Simply install the Expo CLI and run the simulator by running the following commands:

```
npm install -g expo-cli
expo init MyApp
cd MyApp
npm start
```

The last command will start Metro Bundler, which is a HTTP server that compiles the JavaScript code of our app using Babel and serves it to the Expo app.

You will also notice it pops open the Expo Dev Tools, a control panel for developing your app, in your default browser.

### Open the app on your phone or simulator

Looking at the Expo Dev Tools, you have available options on which type of simulator you would like to run (Android or iOS). And you have the option to scan the QR code to run the app on your phone in real time using Live Reload.

All you have to do is download the [Expo app](https://expo.io/tools#client) on either Android or iPhone and scan the QR code, and you are ready to go.


### React Native Documentation:

Learn more about how React Native works by looking at the [docs](https://facebook.github.io/react-native/docs/tutorial.html).


Starting a React Native project with Expo



TypeScript is one of the fastest rising technologies of 2018. This brief summary is filled with what you need to know to understand its key concepts.

Reference to FlavioCopes blog, a great place to learn.

---

TypeScript is built by Microsoft. Its open source, developed public at [https://github.com/Microsoft/TypeScript](https://github.com/Microsoft/TypeScript).

A superset of ECMAScript 2015, also know as ES6, which means that any valid JS is also valid TypeScript.

Run `npm install -g typescript`  to globally install the TypeScript compiler on your system, available to you using the `tsc` command.

Create an `app.ts` file.

Write your first program:

```javascript
const greet = () => {
  console.log('Hello world!')
}
greet()
```

As you see, its just plain JavaScript, but stored in a `.ts` file.

Compile the program using the `tsc app.ts` command.

The compiler compiles the program into a new file: `app.js`, with this content:

```javascript
var greet = function () {
  console.log('Hello world!')
};
greet();
```

Just like *old JavaScript*, the TS compiler compiles TypeScript to ES5 by default, which means that its almost guaranteed to be suppored by all modern browsers.

To change the compilation target to another version, for example to ES2018 run the following:

```javascript
`tsc app.ts --target ES2018`:
```


```javascript
const greet = () => {
  console.log('Hello world!');
};
greet();
```

Here almost nothing changed except for the additional semicolons.

Play around with TS to JS compilation, check out [https://www.typescriptlang.org/play/](https://www.typescriptlang.org/play/).

<br>
<br>

# TYPING
---

Most important functionality provided by TypeScript is the type system:

* static types
* interfaces
* type interence
* enums
* hybrid types
* generics
* union/intersection types
* access modifiers
* null checking

It resembles languages like Go or C, so if you've coded these languages you already know how this works. Unike dynamic languages like Python or Ruby, this is all new.

The type system allows adding types to:

* variables
* function arguments
* function return types

Giving a more rigid structure to your programs.

This is how:

### You define a string variable in TypeScript:

```typescript
const greeting : string = "hello!"
```

### A function accepts an argument of a specific type:

```typescript
const multiply = (a: number, b: number) => {
  return a * b
}
```

### You declare their return value:

```typescript
const multiply = (a: number, b: number): number => {
  return a * b
}
```
<br>

Valid types are:
* `number`
* `string`
* `boolean`
*  `enum`
* `void`
* `null`
* `undefined`
* `any`
* `never`
* `Array`
* `tuple`

`any` is a type that identifies, as its name says, **any** type.

<br>

# CLASSES
---

Like JavsScript, you declare classes like this:

```typescript
class Car {

}
```

Defining class fields:

```typescript
class Car {
  color: string
}
```

Fields are public by default. You can set a field to be `private` or `protected`:

```typescript
class Car {
  public color: string
  private name: string
  protected brand: string
}
```

Private fields can only be accessed by the class that its declared in.

Protected fields can only be accessed by deriving classes.

TypeScript also has `static` fields, which are class fields instead of object fields:

```typescript
class Car {
  static numberOfWheels = 4
}
```

`initialize` fields with a constructor:

```typescript
class Car {
  color: string

  constructor(theColor: string){
    this.color = theColor
  }

}
```

Shorthand syntax to make it simpler:

```typescript
class Car {
  constructor(public color: string){}

  printColor() {
    alert(this.color)
  }
}

(new Car('red')).printColor()
```

A field can be `read only`:

```typescript
class Car {
  readonly color: string
}
```

> in this case its value can only be set in the constructor.

Class methods:

```typescript
class Car {
  color: string
  constructor(public color: string) {
    this.color = color
  }
  drive() {
    console.log('You are driving the car')
  }
}
```

You create objects from those classes, like in JavaScript, using the `new` keyword:

```typescript
const myCar = new Car('red')
```

You can extend an existing class using the `extend` keyword:

```typescript
class ElectricCar extends Car {
  //..
}
```

Call `super()` in the constructor and in methods to call the extended class corresponding method.

<br>

# ACCESSORS
---

Getters and setters:

```typescript
class Car {
  private _color: string

  get color(): string {
    return this._color
  }

  set color(color: string) {
    this._color = color
  }
}
```
<br>

# ABSTACT CLASSES
---

To define an abstract class there needs to be a class that extends it, and implements its eventual abstact methods:

```typescript
abstact class Car {
  abstract drive()
}

class SportsCar extends Car {
  drive() {
    console.log('You are driving a sports car')
  }
}
```

<br>

# INTERFACES
---

Interfaces build upon basic types. Use an interface as a type, and its interface can contain other type definitions:

```typescript
interface SetOfNumbers {
  a: number;
  b: number;
}

const multiply = (set: SetOfNumbers) => {
  return set.a * set.b
}

multiply({ a: 1, b: 2 })
```

An interface can also be an interface for a class implementation:

```typescript
interface Car {
  name: 'string'
  new (brand: string)
  drive(): void
}

class SportsCar implements Car {
  public name

  constructor(public brand: string) {
    //..
  }

  drive() {
    console.log('You are driving a sports car')
  }
}
```


<br>

# FUNCTION FEATURES
---

Functions can have optional parameters using the `?` symbol after the parameter name:

```typescript
class Car {
  drive(kilometers?: number) {
    if(kilometers) {
      console.log('Drive the car for ${kilometers} kilometers')
    } else {
      console.log('Drive the car')
    }
  }
}
```

Parameters can have default values:

```typescript
class Car {
  drive(kilometers = 10) {
    console.log('Drive the car for ${kilometers} kilometers')
  }
}
```

Functions can accept a verying number of parameters by using rest parameters:

```typescript
class Car {
  drive(kilometers = 10, ...occupants: string[]) {
    console.log('Drive the car for ${kilometers} kilometers, with those people on it:')
    occupants.map((person) => console.log(person))
  }
}
(new Car()).drive(20, 'Andre', 'Peter', 'Roger')
```


<br>

# ENUMS
---

A great way to defined named constants.

```typescript
enum Order {
  First,
  Second,
  Third,
  Fourth
}
```

Simply reference `Order.First`, `Order.Second` etc.

You can assign values to constants explicitly:

```typescript
enum Order {
  First   = 0,
  Second  = 1,
  Third   = 2,
  Fourth  = 3
}
```

or use strings:

```typescript
enum Order {
  First = 'FIRST' ,
  Second = 'SECOND',
  Third = 'THIRD',
  Fourth = 'FOURTH'
}
```

<br>

# GENERICS
---

A new feature not available in many programming languages. You can create a function, interface or class that works with different types, without specifying the type up front.

It is mutable, so if you change the type at compile time, the compiler will throw an error.

We could do this by omitting types to all or using `any`.

But with generics all the tooling is going to be able to help us.

Example:

```typescript
function greet<T>(a: T) {
  console.log('Hi ${a.name}')
}
greet({name: 'André'})
```

The `T` symbol identifies a generic type.

the type can be resistricted to a certain class family or interface, using the `extends` keyword:

```typescript
interface Greetable { name: string }
function greet<T extends Greetable>(a: T) {
  alert('Hi ${a.name}!')
}
greet({ name: 'André'})
```

# WANT MORE?

We just went over the basics of TypeScript, go to the [official docs](https://www.typescriptlang.org/docs) for more!


TypeScript syntax summary


After the setup of my Jekyll site I came across Hugo.

Hugo is a static site generator, on the same line as Jekyll as it uses `Markdown` to create blog posts.

The main difference i noticed after testing Jekyll against Hugo is that it's fast. It seems like it has Go under the hood.

Let me do a quick tutorial to setup Hugo, its very easy and almost only done in the commandline:

## Hugo quicksetup tutorial:

## Step 1: Install `hugo`

I use mac, so for those other operating systems out there:

#### Windows:

Get the [Chocolatey](https://chocolatey.org/) package managment, then you can install Hugo with:

```ruby
choco install hugo -confirm
```

#### Linux

Get [Brew](https://brew.sh/) and follow the directions there.

```ruby
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```

Run the `brew` commend to install `hugo`

```ruby
brew install hugo
```

#### MAC (command above)

## Step 2: Create a new site:

Go to the directory where you want to create your `Hugo`{:ruby} repo, then run this command:

```ruby
hugo new site <name-of-site-dir>
```

Will create a new Hugo site in a folder named `name-of-site-dir`.

## Step 3: Add a Theme

> Requirement: `git` is installed

See [themes.gohugo.io](themes.gohugo.io) to browse themes.

I will use the [Ananke theme](https://themes.gohugo.io/gohugo-theme-ananke/)

Step into the site folder and run the folloing commands:

```ruby
git init

git submodule add https://github.com/budparr/gohugo-theme-ananke.git themes/ananke
```

Now edit the `config.toml` configuration file and add the Ananke theme:

Either echo it in from commandline:

```ruby
echo 'theme = "ananke"' >> config.toml
```

Or edit it from your text editor:

```ruby
baseURL = "http://example.org/"
languageCode = "en-us"
title = "My New Hugo Site"
theme = "ananke"
```

## Step 4: Add content

```ruby
hugo new posts/my-first-post.md
```

Edit the file if you like, you can use both `Markdown` or `Html`, your choice.

## Step 5: Start the server

```ruby
hugo server -D
```

Then navigate to [http://localhost:1313/.](http://localhost:1313/.)

## Step 6: Customize the Theme

You can tweak your site to personalise it before you release it to the public.

### Site config

Open `config.toml` in your favourite text editor.

Then replace `title` with something personal and `baseUrl` (if you have a domain already), like i did:

```ruby
baseURL = "http://andrehatlo.org/"
languageCode = "en-us"
title = "Hello! I'm André :)"
theme = "ananke"
```

> Tip:
> Making changes to files in your new Hugo site
> while the server is running will automatically update
> the site and you will see the changes right away.

## Now your site is up and running you can find more to do by reading the Hugo docs [here](https://gohugo.io/documentation/)

> Note that i stayed with Jekyll even though Hugo was an awesome choice for a personal blog with the same features > but fast. This is mostly because i found that Jekyll was more intuitive when coming to posting and doing simple > customization. What ever you pick if you choose to start a blog/portfolio you cant go wrong either way!


Hugo - as a static page blog


## Requirements:

1. Terminal
2. Check whether you have Ruby 2.1.0 or higher installed:

        $ ruby -v
        ruby 2.x.x

3. Install Bundler:

        $ gem install bundler

4. Create a local repository for your Jekyll site. (Jump to step 1 if this is done)

  * Install git, see [set up Git](https://help.github.com/articles/set-up-git/)
  * Open terminal
  * Initialize a new Git repo for your jekyll site:


        $ git init <GitHubUsername>.github.io
        Initialized empty Git repository in /Users/horseforce/andrehatlo.github.io/.git/
        # creates a new file directory on your local computer, Initialized as a Git repo


  * Then change directory to the new repository created:

        $ cd <GitHubUsername>.github.io


## Step 1: Install Jekyll using Bundler

1. Check if you have a Gemfile in your newly created repo

        $ ls
        Gemfile


    * If you have a Gemfile, skip to step 4.

2. Open up your favorite text editor, if you need one: [Atom](https://atom.io/). Then add these lines to a new file, and save.


        source 'http://rubygems.org'
        gem 'github-pages', group: :jekyll_plugins


3. Save the file as `Gemfile`, in the root directory of your local Jekyll repository. Now skip to step 5 to install Jekyll.

4. **Only** if you already have a Gemfile. Open your favorite editor, mine is [Atom](https://atom.io/), and add these lines to your Gemfile:


        source 'https://rubygems.org'
        gem 'github-pages', group: :jekyll_plugins


5. Install Jekyll and other dependencies from the GitHub Pages gem by running:


        $ bundle install
        Fetching gem metadata from https://rubygems.org/......
        Fetching version metadata from https://rubygems.org/...
        Fetching dependency metadata from https://rubygems.org/..
        Resolving dependencies...


## Step 2: Run your Jekyll site localy

You can generate site files for a basic Jekyll template site in your local repository.

1. If you don't already have a Jekyll site localy on your computer, create a Jekyll template site in a new directory:


        $ bundle exec jekyll _3.3.0_ new <new-jekyll-site-repo-name>
        New jekyll site installed in /Users/horseforce/<new-jekyll-site-repo-name>.


2. Navigate into your new site directory and edit your Gemfile by removing the following line:


        $ 'jekyll', "3.3.0"


3. In the same Gemfile, delete the `#` at the beginning of this line:


        $ gem "github-pages", group: :jekyll_plugins


4. Initialize the directory as a Git repo


        $ git init


5. Connect your remote repo on GitHub to your local repo for your site.


        $ git remote add origin http://github.com/<username/organization-name/your-remote-repo-name>


6. To edit the Jekyll site, open your jekyll local repository in an text editor. Make as much changes as you want and save them.

7. Preview changes locally by running a Jekyll command to build your site:

  * Navigate to your site root directory:


        $ cd <GithubUsername>.github.io


  * Run the following command:

    ```
    $ bundle exec jekyll serve
    Configuration file: /Users/horseforce/andrehatlo.github.io/_config.yml
                Source: /Users/horseforce/andrehatlo.github.io
           Destination: /Users/horseforce/andrehatlo.github.io/_site
     Incremental build: disabled. Enable with --incremental
          Generating...
                        done in 0.309 seconds.
     Auto-regeneration: enabled for '/Users/horseforce/my-site'
    Configuration file: /Users/horceforce/andrehatlo.github.io/_config.yml
        Server address: http://127.0.0.1:4000/
      Server running... press ctrl-c to stop.
    ```

  * In your browser, preview your local Jekyll site at `http://localhost:4000`

8. Add or stage your changes:


        $ git add .


9. Commit it


        $ git commit -m "some stuff changed"


10. Push your changes to your remote repository on GitHub


        $ git push -u origin master



## Step 3: Make github host it

### Navigate to your repository.

Which should be named in this format:

    <github-username>.github.io

If your repository is called something else, we can change it at the next step.

### Enter into your repository settings.

First thing you see is `Repository name`, edit it so that it matches the syntax:

    <github-username>.github.io

Next scroll further down in repo settings until you see `GitHub Pages`

### @ `GitHub Pages`

Hopefully it should now say:

> :heavy_check_mark: Your site is published at: [http://www.andrehatlo.github.io](http://andrehatlo.com)

> If not, there is possibly something wrong with your repository or github setup.

## Applying a custom domain

Scroll down on the github repo settings page until you see `Custom domain` under `GitHub Pages`.

Fill in your domain name, and click save.

Now go to your domain hoster website and create a CNAME record that points to your repo, this can be done in the settings of your DNS records.


    www.andrehatlo.com ->  CNAME -> <github-username>.github.io


## Now you should have your own domain hosted for free


Just keep tweaking your website and check out all the different themes out there! I will be coming with more tutorials about Jekyll in the future :smile:


### Hope this was helpfull enough as my first blog post.
### I'll try to excel as fast as possible by writing MANY MANY more! :wave: :wave:


Jekyll + Github = Free hosting: Tutorial


So, i've chosen to start blogging my experiences/insights/thoughts as a developer. Both to learn and to share knowledge.

Trying to find the right platform to start a blog was my biggest challenge.

Google didn't make in much easier, i have a feeling their algorithm favorites something called **WORDPRESS**. So i tested it out.

Making it through the first configuration, then the second configuration, then they wanted me to pay them for a domain name i already have.

At last i made it through to the end, and i was left with was a revamped version of Joomla.

Using Wordpress, there is almost no challenge, and you end up paying for something in end anyway, something i'm *_not_* interested in.

<br>

<center>
<iframe src="https://giphy.com/embed/O8pa1CyYSp1yE" width="480" height="269" frameBorder="0" class="giphy-embed" allowFullScreen></iframe>
</center>
<br>

I wanted the right platform, for a simple programming blog and portfolio for my future projects.

This was until i stumbled into the best place on the internet; *Reddit*, and found a post about **Jekyll**.

*For those who does not know what Jekyll is:*

>*Jekyll is a simple, blog-aware, static site generator for personal, project, or organization sites. Written in Ruby by Tom Preston-Werner, GitHub's co-founder, it is distributed under the open source MIT license*

This lightweight, easy to use, multilingual system is a perfect substitution for platforms similar to Wordpress.


### And do you know whats even better!?

Using Jekyll you can get *FREE* hosting through Github!
=======================================================

Follow my tutorial on how i used Jekyll and Github to create this blog/portfolio you are on right now:

[Free Blog/Portfolio with Jekyll and Github tutorial](https://www.andrehatlo.com/jekyll-github-free-host/)


Loading...