DEV Community: Thomas Jaskiewicz

Question - Should I write about it?

Thomas Jaskiewicz — Wed, 27 Jan 2021 21:21:33 +0000

Hi!

I’ve recently decided to quit google and replace google’s services with different services to secure own my data + avoid privacy issues...

If you wonder what’s “degoogle” about, see this article: here

I was thinking about writing a series of articles about deploying some self-hosted solution to your private servers/NAS/VPS. All in Docker, I could use Terraform to spin up some VPS. Some reverse-proxy, securing the setup, using SSL, etc.

Some initial ideas for articles:

Building a simple Infrastructure as a Code using Terraform to spin up our server.
Deploying Ghost as a blog engine.
Adding Comments engine and plugging it to the blog.
Adding Analytics solution and plugging it to the blog.
Deploying some cloud storage solution for storing files.
Separate article about reverse proxy, securing the setup, using SSL certs, hardening the server setup.
Other services that will be needed to replace google with something.
If you have more ideas, just let me know.

Would you find such articles useful?
Maybe it would be a great opportunity for you to learn something new, like #terraform, #docker, #reverse-proxy, #iaac? :)

Let me know your thoughts!

Cheers,
Thomas

Looking for a new terminal setup? I have something for you! ZSH + Starship + Hyper!

Thomas Jaskiewicz — Tue, 07 Jul 2020 18:57:30 +0000

Hi, Devs!

Many of you asked me to revise & update my article about setting up the terminal with Hyper.js, ZSH and Starship.

I'm happy to say that it has finally arrived. Please, use it, share it and comment! I'm also curious about your tips when it comes to the terminal environment.

Revised and updated article can be found here:

HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥

Thomas Jaskiewicz for Netguru ・ Sep 7 '19 ・ 20 min read

#terminal #shell #productivity #tutorial

Cheers!
Have a productive day :)

Photo by Tracy Adams on Unsplash

HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥

Thomas Jaskiewicz — Sat, 07 Sep 2019 22:10:00 +0000

[Revised at 2020-07-07]

Probably, the first thing that developers do after getting a new computer is… terminal setup. I wanted to share with you my current development setup - here, terminal setup.

Talk is cheap, let’s show some code.

1. Terminal - Hyper.js

1.1 Download and install Hyper.

Let’s go to Hyper™ page and download a version for your OS.

I downloaded a Mac OS version. When we extract zip file Hyper-3.0.2-mac.zip we get a Hyper.app file. To install it just drag it to Applications folder. Now, by using the Spotlight Search (CMD + SPACE) type hyper and there should be a Hyper application on the list.

The Hyper’s window looks like this in my case:

Don’t worry if your prompt looks differently. We are going to take care of it later. You might be using a different shell, different config at the beginning.

1.2 Basic configuration

Now, the magic happens. Hyper’s config is defined as ~/.hyper.js file. File is structured like this:



// Future versions of Hyper may add additional config options,
// which will not automatically be merged into this file.
// See https://hyper.is#cfg for all currently supported options.

module.exports = {
  config: {
    // choose either `'stable'` for receiving highly polished,
    // or `'canary'` for less polished but more frequent updates
    updateChannel: 'stable',

    // default font size in pixels for all tabs
    fontSize: 12,

    // font family with optional fallbacks
    fontFamily: 'Menlo, "DejaVu Sans Mono", Consolas, "Lucida Console", monospace',

    // default font weight: 'normal' or 'bold'
    fontWeight: 'normal',

    // rest of the config
  }
  // rest of the file
}

This is awesome information! We have complete control over our settings.

Let’ start with basic config.

1.2.1 Font

fontSize - personally, I prefer a little bigger font, let’s use 13. Later on you can change the font size in the terminal by using CMD + + and CMD + - keyboard shortcuts.
fontFamily - let’s use a really nice font with ligatures - FiraCode . I attach an overview below:

Installing instructions are described here. I prefer the manual way (for Mac OS):

Download the latest version of the font from Github releases tab: Releases · tonsky/FiraCode · GitHub - As for now, it’s Fira_Code_v5.2.zip .
Extract the archive and go to ttf directory.
Select all fonts .ttf files , click right , then Open and select Install Font

Now, when our font is installed let’s set it in our Hyper terminal. The config file should be placed in the home directory:



nano ~/.hyper.js



module.exports = {
  config: {
      fontSize: 13,
    fontFamily: '"Fira Code", Menlo, "DejaVu Sans Mono", Consolas, "Lucida Console", monospace',
      // rest of the config
  }
  // rest of the file
}

At this point we enabled Fira Code font in the terminal but ligatures are still not enabled. Let’s turn them on.

We need to install a dedicated plugin: hyper-font-ligatures:



hyper i hyper-font-ligatures

Plugin should immediately appear in our config file:



module.exports = {
  // rest of the file
  plugins: ["hyper-font-ligatures"],

To enable ligatures we need to add one more line to the config (See issue #8 and zeit/hyper#3607 for more details):



module.exports = {
  config: {
    // rest of the config
    webGLRenderer: false,
  }
  // rest of the file
}

Now, everything should work as expected and we should see new font with ligatures in the terminal:

1.2.2 Theme

With Hyper we can download multiple themes that are available here: Hyper Store - Plugins. I’m going to use Hyper Store - hyper-one-dark theme. To install it, just run:



hyper i hyper-one-dark

With my current shell it looks like this:

1.2.3 Search Plugin

To be able to search for a keyword in the terminal we need to install a dedicated plugin: Hyper Store - hyper-search



hyper i hyper-search

This time we need to restart the Hyper completely. After the restart we can start using our plugin:

1.2.4 Pane Navigation Plugin

If we want to jump between panes in the terminal we need to add Hyper Store - hyper-pane plugin:



hyper i hyper-pane

How it works?

1.2.5 Open new tabs with the same directory

When opening new tabs, I often want to be in the same directory. To be able to do it, let’s add Hyper Store - hypercwd:



hyper i hypercwd

1.2.6 Mark active tab by adding a symbol to it

Sometimes when we have multiple tabs opened it might be difficult to notice which one is active at the moment. Make our life easier and add Hyper Store - hyper-active-tab:



hyper i hyper-active-tab

I’m going to use a custom symbol:



module.exports = {
  config: {
    // rest of the config
    activeTab: '🚀'
  }
  // rest of the file
}

Now, it looks like this:

1.2.7 Showing CPU, RAM, battery stats

If we want to track our CPU, Memory, Battery resources we can add: GitHub - Hyperline/hyperline: ✨ Status line plugin for Hyper ✨:



hyper i hyperline

After full reload new status line will appear:

There is even a Spotify plugin showing the currently played song.

1.2.8 Bonus: feel this power!

Javascript enables users to create almost anything. Let’s see what Hyper Store - hyperpower can do:



hyper i hyperpower

This one is quite showy:

There are a lot of other plugins and the list is rapidly growing. For more plugins check especially those two sources:

Official plugins store: Hyper Store - Plugins
A repository with the list of Hyper plugins: https://github.com/bnb/awesome-hyper

2. Shell - ZSH + starship prompt

There are a few most popular shells for linux:

Bash Shell - Bash (Unix shell) - Wikipedia
Tcsh/Csh Shell - https://pl.wikipedia.org/wiki/Tcsh
Ksh Shell - https://pl.wikipedia.org/wiki/Korn_shell
Zsh Shell - https://pl.wikipedia.org/wiki/Zsh
Fish - https://pl.wikipedia.org/wiki/Friendly_interactive_shell

After experimenting with some shells I decided to use ZSH.

2.1 Installing ZSH

For Mac OS:



brew install zsh

If you don’t have a homebrew installed you can add it (official installation docs here):



/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Homebrew is a package manager for macOS.

After installing ZSH check its version:



❯ zsh --version
zsh 5.7.1 (x86_64-apple-darwin19.0)

❯ which zsh
/usr/local/bin/zsh

To use ZSH with Hyper we need to specify it in the config (~/.hyper.js):



module.exports = {
  config: {
    // rest of the config
    shell: '/usr/local/bin/zsh',
  }
  // rest of the file
}

At this point Hyper should start with freshly installed ZSH as default shell.

We can move on to the next point.

2.2 Installing starship prompt

There are many different prompts that can be used. After testing some of them I decided to stay with GitHub - starship/starship: ☄️🌌️ The cross-shell prompt for astronauts.

2.2.1 Install

There are a few different ways to install starship described in the documentation: GitHub - starship/starship: ☄️🌌️ The cross-shell prompt for astronauts.

For Mac OS:



brew install starship

Check whether it’s working:



❯ starship --version
starship 0.44.0

To enable startship prompt we need to add it to ~/.zshrc. Add following code to the end of ~/.zshrc file:



echo 'eval "$(starship init zsh)"' >> ~/.zshrc

After restarting the Hyper our terminal should look like this:

Unfortunately, we don’t have any syntax highlighting, commands completion, history enabled, aliases and a few other things. We need to adjust it.

2.2.2 Syntax Highlighting

There is another great repo with ZSH plugins that you should check out: GitHub - unixorn/awesome-zsh-plugins: A collection of ZSH frameworks, plugins & themes inspired by the various awesome list collections out there.. I searched it for a syntax highlighting plugin.

I’m going to use GitHub - zdharma/fast-syntax-highlighting: (Short name F-Sy-H). Syntax-highlighting for Zshell – fine granularity, number of features, 40 work hours themes.

I will install it by cloning the repo (it will allow later to easily keep it up-to-date by pulling the master):



# Create a `.zsh` directory to store our plugins in one place
mkdir ~/.zsh

# Clone repo to `~/.zsh/` directory
cd ~/.zsh && git clone [email protected]:zdharma/fast-syntax-highlighting.git

# Enable 'fast-syntax-highlighting' plugin in ZSH
echo "source $HOME/.zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh" >> ~/.zshrc

# Reload ZSH
source ~/.zshrc

If you couldn't clone the repo and got error like:



[email protected]: Permission denied (publickey)

Then try using "Clone with HTTPS", it would look like this:



git clone https://github.com/zdharma/fast-syntax-highlighting.git

After those few steps we should have already syntax highlighting enabled:

2.2.3 Setting completion plugin

We are going to use already defined completion.zsh from GitHub - robbyrussell/oh-my-zsh:



# Download completion config
cd ~/.zsh && wget https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/lib/completion.zsh

# Enable 'completion' plugin in ZSH
echo "source $HOME/.zsh/completion.zsh" >> ~/.zshrc

Additionally, this time we need to add a few more lines to ~/.zshrc file:



# rest of the `~/.zshrc` file

# Load completion config
source $HOME/.zsh/completion.zsh

# Initialize the completion system
autoload -Uz compinit

# Cache completion if nothing changed - faster startup time
typeset -i updated_at=$(date +'%j' -r ~/.zcompdump 2>/dev/null || stat -f '%Sm' -t '%j' ~/.zcompdump 2>/dev/null)
if [$(date +'%j') != $updated_at]; then
  compinit -i
else
  compinit -C -i
fi

# Enhanced form of menu completion called `menu selection'
zmodload -i zsh/complist

```
<!--kg-card-end: code-->

Restart the terminal and completion should work now:

<!--kg-card-begin: image-->

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-17.png)

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-18.png)

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-19.png)

<!--kg-card-end: image-->

You might ask, why I don’t use Oh My Zsh? It feels overloaded for me. I like to have control over the tools I use. I prefer to build things starting from small parts and build on that something bigger, step by step.

#### 2.2.4 Setting autosuggestions plugin

Except completion feature it’s nice to have also suggestions. When you start typing there is a suggestion displayed in the command line.  Let’s use [GitHub - zsh-users/zsh-autosuggestions: Fish-like autosuggestions for zsh](https://github.com/zsh-users/zsh-autosuggestions) plugin.

Install it:

<!--kg-card-begin: code-->
```shell
# Download 'zsh-autosuggestions' plugin
cd ~/.zsh && git clone [email protected]:zsh-users/zsh-autosuggestions.git

# Enable 'zsh-autosuggestions' plugin in ZSH
echo "source $HOME/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh" >> ~/.zshrc

# Reload ZSH
source ~/.zshrc

```
<!--kg-card-end: code-->

It works really nicely by suggesting the rest of the command, you can use arrows to accept suggested command:

<!--kg-card-begin: image-->

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-20.png)

<!--kg-card-end: image-->
#### 2.2.5 Commands history config

Here again, we are going to use a ready config from oh-my-zsh:

<!--kg-card-begin: code-->
```shell
# Download history config
cd ~/.zsh && wget https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/lib/history.zsh

# Enable 'history' config in ZSH
echo "source $HOME/.zsh/history.zsh" >> ~/.zshrc

# Reload ZSH
source ~/.zshrc

```
<!--kg-card-end: code-->

Now, by using the Up Arrow we can go back to our previous commands. We can also use backwards search by clicking `CTRL` + `R`:

<!--kg-card-begin: image-->

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-21.png)

<!--kg-card-end: image-->
#### 2.2.6 Colorized `ls` output

Right now when we want to list a directory’s content we have a raw gray list:

<!--kg-card-begin: image-->

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-22.png)

<!--kg-card-end: image-->

It doesn’t look good. Let’s use some colours to make it more readable.  
When you go to `ls` command’s manual there is a `-G` option:

<!--kg-card-begin: code-->
```shell
     -G Enable colorized output. This option is equivalent to defining CLICOLOR in the environment. (See below.)

```
<!--kg-card-end: code-->

But, we are not going to add `-G` each time when we want to use `ls`command. We can create an alias for it:

<!--kg-card-begin: code-->
```shell
# Enable colorized output for `ls` command.
echo "alias ls='ls -G'" >> ~/.zshrc

# Reload ZSH
source ~/.zshrc

```
<!--kg-card-end: code-->

It looks better now:

<!--kg-card-begin: image-->

![HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥](https://tjay.dev/content/images/2019/09/image-23.png)

<!--kg-card-end: image-->
#### 2.2.7 Key bindings

When working in the terminal on daily basis it’s good to have shortcuts enabled. Going back to the beginning of the line (`CMD` + `LEFT ARROW`), or to the end (`CMD` + `RIGHT ARROW`)?

Let’s install key bindings:

<!--kg-card-begin: code-->
```shell
# Download key bindings config
cd ~/.zsh && wget https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/lib/key-bindings.zsh

# Enable 'key-bindings' config in ZSH
echo "source $HOME/.zsh/key-bindings.zsh" >> ~/.zshrc

# Reload ZSH
source ~/.zshrc

```
<!--kg-card-end: code-->
#### 2.2.8 Aliases

Shell aliases play a huge part in productivity when using a command line. If you have well defined shortcuts it allows you to be really efficient and quick when developing new apps, scripts, etc.

<!--kg-card-begin: code-->
```shell
touch aliases.zsh 
echo "source $HOME/.zsh/aliases.zsh" >> ~/.zshrc

```
<!--kg-card-end: code-->

A few useful aliases that I often use are listed below:  
`~/.zsh/aliases.zsh`

<!--kg-card-begin: code-->
```shell
alias ls='ls -G' # colorize `ls` output
alias zshreload='source ~/.zshrc' # reload ZSH
alias shtop='sudo htop' # run `htop` with root rights
alias grep='grep --color=auto' # colorize `grep` output
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias less='less -R'
alias g='git'

alias rm='rm -i' # confirm removal
alias cp='cp -i' # confirm copy
alias mv='mv -i' # confirm move
alias cal='gcal --starting-day=1' # print simple calendar for current month
alias weather='curl v2.wttr.in' # print weather for current location (https://github.com/chubin/wttr.in)

```
<!--kg-card-end: code-->

As  a bonus, I thought that sharing git aliases might also benefit you. The list below might seem to be quite broad but I added comments explaining what each of them is meant to be doing.  
`~/.gitconfig`

<!--kg-card-begin: code-->
```shell
[alias]
  a = add # Add file contents to the index
  ai = add --interactive # Add modified contents in the working tree interactively to the index.
  ##############
  b = branch
  ba = branch --all # List both remote-tracking branches and local branches.
  bav = branch --all --verbose # When in list mode, show sha1 and commit subject line for each head, along with relationship to upstream branch (if any)
  bd = branch --delete # Delete a branch. The branch must be fully merged in its upstream branch, or in HEAD if no upstream was set with --track or --set-upstream-to.
  bdd = branch -D # Shortcut for --delete --force.
  bm = branch --move # Move/rename a branch and the corresponding reflog.
  bmm = branch -M # Shortcut for --move --force.
  br = branch --remotes # List or delete (if used with -d) the remote-tracking branches.
  ##############
  c = commit # Record changes to the repository
  ca = commit --all # Tell the command to automatically stage files that have been modified and deleted, but new files you have not told Git about are not affected.
  cm = commit -m # Use the given <msg> as the commit message.
  cam = commit -am # Shortcut for --all and -m
  cem = commit --allow-empty -m # Allows to create a commit without any files modified
  cd = commit --amend # Replace the tip of the current branch by creating a new commit.
  cad = commit --all --amend # Shortcut for --amend and --all
  cadne = commit --all --amend --no-edit # Amends a commit without changing its commit message.
  ##############
  cl = clone # Clone a repository into a new directory
  cld = clone --depth 1 # Create a shallow clone with a history truncated to the specified number of commits.
  ##############
  cp = cherry-pick # Apply the changes introduced by some existing commits
  cpa = cherry-pick --abort # Cancel the operation and return to the pre-sequence state.
  cpc = cherry-pick --continue # Continue the operation in progress using the information in .git/sequencer. Can be used to continue after resolving conflicts in a failed cherry-pick or revert.
  cps = cherry-pick --skip # Skip the current commit and continue with the rest of the sequence.
  ##############
  d = diff # Show changes between commits, commit and working tree, etc
  di = !"d() { git diff --patch-with-stat HEAD~$1; }; git diff-index --quiet HEAD -- || clear; d" # `git di $number` shows the diff between the state `$number` revisions ago and the current state
  dt = difftool # Show changes using common diff tools
  ##############
  f = fetch # Download objects and refs from another repository
  fo = fetch origin # Update the remote-tracking branches
  fu = fetch upstream # Fetch the branches and their respective commits from the upstream repository.
  ##############
  fk = fsck # Verifies the connectivity and validity of the objects in the database
  ##############
  g = grep -p # Print lines matching a pattern
  ##############
  l = log --oneline # Show commit logs, the commit message is prefixed with this information on the same line.
  lg = log --oneline --graph --decorate # Draw a text-based graphical representation of the commit history on the left hand side of the output.
  lgs = !"git log --pretty=format:"%C(yellow)%h\\ %ad%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=short" # SHA + date + Commit message + author
  lgc = !"git log --pretty=format:"%C(yellow)%h%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --numstat" # SHA + Commit message + author + changed files
  lgt = !"git log --graph --pretty='%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --all" # As tree: SHA + Commit message + Time ago + author
  ##############
  ls = ls-files # Show information about files in the index and the working tree
  lsm = ls-files --modified # Show modified files in the output
  lss = ls-files --stage # Show staged contents' mode bits, object name and stage number in the output.
  ##############
  m = merge # Join two or more development histories together
  ma = merge --abort # Abort the current conflict resolution process, and try to reconstruct the pre-merge state.
  mc = merge --continue # After a git merge stops due to conflicts you can conclude the merge by running git merge --continue
  mq = merge --quit # Forget about the current merge in progress. Leave the index and the working tree as-is.
  mm = merge master # Merge 'master' branch to the current branch.
  ##############
  o = checkout # Switch branches or restore working tree files.
  om = checkout master # Switch branch to master.
  ob = checkout -b # Create and switch to a new branch
  ##############
  pr = prune --verbose --progress # Prune all unreachable objects from the object database. Report all removed objects. Show progress.
  prn = prune --dry-run # Do not remove anything; just report what it would remove.
  ##############
  ps = push # Update remote refs along with associated objects
  psa = push --all # Push all branches (i.e. refs under refs/heads/); cannot be used with other <refspec>.
  psf = push --force # Usually, the command refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it. This flag disables these checks, and can cause the remote repository to lose commits; use it with care.
  psu = push --set-upstream # For every branch that is up to date or successfully pushed, add upstream (tracking) reference.
  ##############
  pso = push origin # `origin` is an alias in the system for a particular remote repository. Can be checked by running `git remote -v`.
  psao = push --all origin # Same as `push --all` but for origin.
  psfo = push --force origin # Same as `push --force` but for origin.
  psuo = push --set-upstream origin # Same as `push --set-upstream` but for origin.
  #############
  psom = push origin master # Same as `push origin` but for master branch.
  psaom = push --all origin master # Same as `push --all origin` but for master branch.
  psfom = push --force origin master # Same as `push --force origin` but for master branch.
  psuom = push --set-upstream origin master # Same as `push --set-upstream origin` but for master branch.
  #############
  pl = pull # Fetch from and integrate with another repository or a local branch.
  plr = pull --rebase # When true, rebase the current branch on top of the upstream branch after fetching.
  plv = pull --verbose # Pass --verbose to git-fetch and git-merge.
  #############
  plo = pull origin # Same as `pull` but for origin.
  plro = pull --rebase origin # Same as `pull --rebase` but for origin.
  plom = pull origin master # Same as `pull origin` but for master branch.
  #############
  plu = pull upstream # Same as `pull` but for upstream.
  plum = pull upstream master # Same as `pull upstream` but for master branch.
  plrum = pull --rebase upstream master # Same as `pull --rebase` but for upstream and master branch.
  #############
  rb = rebase # Reapply commits on top of another base tip.
  rba = rebase --abort # Abort the rebase operation and reset HEAD to the original branch.
  rbc = rebase --continue # Restart the rebasing process after having resolved a merge conflict.
  rbi = rebase --interactive # Make a list of the commits which are about to be rebased. Let the user edit that list before rebasing. This mode can also be used to split commits.
  rbs = rebase --skip # Restart the rebasing process by skipping the current patch.
  rbin = "!r() { git rebase -i HEAD~$1; }; r" # Interactive rebase with the given number of latest commits.
  #############
  re = reset # Reset current HEAD to the specified state
  rh = reset HEAD # HEAD is defined explicitly
  reh = reset --hard # Resets the index and working tree. Any changes to tracked files in the working tree since <commit> are discarded.
  rem = reset --mixed # Resets the index but not the working tree (i.e., the changed files are preserved but not marked for commit) and reports what has not been updated. This is the default action.
  res = reset --soft # Does not touch the index file or the working tree at all (but resets the head to <commit>, just like all modes do). This leaves all your changed files "Changes to be committed".
  rehh = reset --hard HEAD # HEAD is defined explicitly
  remh = reset --mixed HEAD # HEAD is defined explicitly
  resh = reset --soft HEAD # HEAD is defined explicitly
  rehom = reset --hard origin/master # Throw away all my staged and unstaged changes, forget everything on my current local branch and make it exactly the same as origin/master.
  #############
  r = remote # Manage set of tracked repositories
  ra = remote add # Adds a remote named <name> for the repository at <url>.
  rr = remote remove # Remove the remote named <name>. All remote-tracking branches and configuration settings for the remote are removed.
  rv = remote --verbose # Be a little more verbose and show remote url after name.
  rn = remote rename # Rename the remote named <old> to <new>. All remote-tracking branches and configuration settings for the remote are updated.
  rp = remote prune # Deletes stale references associated with <name>. By default, stale remote-tracking branches under <name> are deleted, but depending on global configuration and the configuration of the remote we might even prune local tags that haven't been pushed there.
  rs = remote show # Gives some information about the remote <name>.
  rao = remote add origin # Add new origin.
  rau = remote add upstream # Add new upstream.
  rro = remote remove origin # Remove origin.
  rru = remote remove upstream # Remove upstream.
  rso = remote show origin # Show current origin.
  rsu = remote show upstream # Show current upstream.
  rpo = remote prune origin # Prune current origin.
  rpu = remote prune upstream # Prune current upstream.
  #############
  rmf = rm -f # Remove files from the working tree and from the index. Override the up-to-date check.
  rmrf = rm -r -f # Same as above + Allow recursive removal when a leading directory name is given.
  #############
  s = status # Show the working tree status
  sb = status -s -b # Same as above + Give the output in the short-format. Show the branch and tracking info even in short-format.
  #############
  sa = stash apply # Like pop, but do not remove the state from the stash list.
  sc = stash clear # Remove all the stash entries. Note that those entries will then be subject to pruning, and may be impossible to recover.
  sd = stash drop # Remove a single stash entry from the list of stash entries. When no <stash> is given, it removes the latest one.
  sl = stash list # List the stash entries that you currently have.
  sp = stash pop # Remove a single stashed state from the stash list and apply it on top of the current working tree state, i.e., do the inverse operation of git stash push.
  sps = stash push # Save your local modifications to a new stash entry and roll them back to HEAD (in the working tree and in the index). The <message> part is optional and gives the description along with the stashed state.
  spsk = stash push -k # All changes already added to the index are left intact.
  sw = stash show # Show the changes recorded in the stash entry as a diff between the stashed contents and the commit back when the stash entry was first created. When no <stash> is given, it shows the latest one.
  st = !git stash list | wc -l 2>/dev/null | grep -oEi '[0-9][0-9]*'
  #############
  t = tag # Create, list, delete or verify a tag object signed with GPG.
  td = tag --delete # Delete existing tags with the given names.
  tl = tag --list # Show verbose output about tags.
  #############
  w = show # Show various types of objects.
  wo = show --oneline # This is a shorthand for "--pretty=oneline --abbrev-commit" used together.
  wf = show --format=fuller # Print more extensive info.
  #############
  aliases = !git config -l | grep alias | cut -c 7- # List git aliases
  branches = branch --all # List both remote-tracking branches and local branches.
  remotes = remote --verbose # Be a little more verbose and show remote url after name.
  contributors = shortlog --summary --numbered  # List contributors with number of commits
  amend = commit --amend --no-edit # Amend the currently staged files to the latest commit.
  go = "!f() { git checkout -b \"$1\" 2> /dev/null || git checkout \"$1\"; }; f"    # Switch to a branch, creating it if necessary
  fb = "!f() { git branch -a --contains $1; }; f" # Find branches containing commit
  ft = "!f() { git describe --always --contains $1; }; f" # Find tags containing commit
  fc = "!f() { git log --pretty=format:'%C(yellow)%h %Cblue%ad %Creset%s%Cgreen [%cn] %Cred%d' --decorate --date=short -S$1; }; f" # Find commits by source code
  fm = "!f() { git log --pretty=format:'%C(yellow)%h %Cblue%ad %Creset%s%Cgreen [%cn] %Cred%d' --decorate --date=short --grep=$1; }; f" # Find commits by commit message
  dm = "!git branch --merged | grep -v '\\*' | xargs -n 1 git branch -d"    # Remove branches that have already been merged with master (a.k.a. ‘delete merged’)

```
<!--kg-card-end: code-->
## Summary

I hope you will find this article useful and it will help you boost your productivity in the command line. It’s not an ultimate setup, rather treat it as a beginning or enhancement for your current setup. The amount of available tools, plugins, configs is simply overwhelming. Each user has different use cases, different technologies that he uses.  
I tried to focus on the common ground which could be used by anyone.

If you know and recommend some of the tools you use and can’t live without please let me know in the comments.

**This article was originally posted on my personal dev blog: [https://tjay.dev/](https://tjay.dev/howto-my-terminal-shell-setup-hyper-js-zsh-starship/?utm_source=dev.to&utm_medium=footer-link&utm_campaign=reblogging)**

_Photo by [Анна В](https://unsplash.com/@niakris?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/shell?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)_

HowTo: Working with large files in Ruby efficiently.

Thomas Jaskiewicz — Tue, 03 Sep 2019 13:07:41 +0000

How can we read files in Ruby?

* Testing file generated by running a following command:

❯ openssl req -newkey rsa:2048 -new -nodes -x509 -days 3650 -keyout key.pem -out cert.pem

It has a clearly defined the beginning and the end of the file which fill be useful while reading the files.

1. `File.read()` which is actually `IO.read()`:

> file = File.read("cert.pem")
=> "-----BEGIN CERTIFICATE-----\nMIICljCCAX4CCQD5x/0DnI1UazANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJQ\nTDAeFw0xOTA4MzExOTQ0NDdaFw0yOTA4MjgxOTQ0NDdaMA0xCzAJBgNVBAYTAlBM\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2qJrZayMFRE7zIeUL8CZ\nzqsOcwEv6flF41EjIvVf6h164i+NGkRu9E0wo1LHYsoF5tutYKKpRLJoY9xGq+Jr\n1SPOJYGBaFqKyQye+lnSzJdpnCAklXObfJpGtBmKCm4OTcb8eC4nm2q4x3mNkP5Z\nTgzdfIhALCwtD6wsHcyy5qmqGfPWAaGUDHqAQRu7QV/vu5VzJXgN0c6Zj+bOWw4H\n7Zu+FxtpUACQk4lnqt9CUzp6GX3dIETTfA3cpTFvoxwqBZGnrjsgZA5HzbyKRUYi\naigbkyzc701sJaS8gcjIKDy2s8L8MfqaJkMu+N52e5tXoj4oQT9wPzxOou+GpYM/\n4QIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQDDrOrN+asQjkOwjPcNLkycy4TJ/6QE\nraNDVZ1N5h+70vIQwmmCS+hBN7SSM0f0OxgEggvK0etNQb6LXWXAIa7pMuzhqmHR\n9Q/NBizj+GOIvH7EoCTVKYUkRLxEq5i63cm0ZvFu9qwr8v7IGM4HkLo3A0F6+Vcp\nGNuOBNcGqAtCXNhgcpzu/6zWT2kAj1M82IC4aCIiTGovDidnp2ZO4bV5PTCy7ecd\naeJxt9LIlt/FVk29sjdtutPMZgtQwKKp2gWyY9D7/x8Dxpf2DCkjAtqEdN3/GER6\nlybIrvAtYW7MNmu9MLkxionOak9CoZGsVg0kiXliHrhfxrDc8qLe8rqV\n-----END CERTIFICATE-----\n"
> file.bytesize
=> 956
> file.class
=> String

read method reads the entire file's content and assigns it to the variable as single String.

2. `File.new()` and its synonym `File.open()`:

> file = File.new("cert.pem")
=> #<File:cert.pem>
> lines = file.readlines
=> ["-----BEGIN CERTIFICATE-----\n",
 "MIICljCCAX4CCQD5x/0DnI1UazANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJQ\n",
 "TDAeFw0xOTA4MzExOTQ0NDdaFw0yOTA4MjgxOTQ0NDdaMA0xCzAJBgNVBAYTAlBM\n",
 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2qJrZayMFRE7zIeUL8CZ\n",
 "zqsOcwEv6flF41EjIvVf6h164i+NGkRu9E0wo1LHYsoF5tutYKKpRLJoY9xGq+Jr\n",
 "1SPOJYGBaFqKyQye+lnSzJdpnCAklXObfJpGtBmKCm4OTcb8eC4nm2q4x3mNkP5Z\n",
 "TgzdfIhALCwtD6wsHcyy5qmqGfPWAaGUDHqAQRu7QV/vu5VzJXgN0c6Zj+bOWw4H\n",
 "7Zu+FxtpUACQk4lnqt9CUzp6GX3dIETTfA3cpTFvoxwqBZGnrjsgZA5HzbyKRUYi\n",
 "aigbkyzc701sJaS8gcjIKDy2s8L8MfqaJkMu+N52e5tXoj4oQT9wPzxOou+GpYM/\n",
 "4QIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQDDrOrN+asQjkOwjPcNLkycy4TJ/6QE\n",
 "raNDVZ1N5h+70vIQwmmCS+hBN7SSM0f0OxgEggvK0etNQb6LXWXAIa7pMuzhqmHR\n",
 "9Q/NBizj+GOIvH7EoCTVKYUkRLxEq5i63cm0ZvFu9qwr8v7IGM4HkLo3A0F6+Vcp\n",
 "GNuOBNcGqAtCXNhgcpzu/6zWT2kAj1M82IC4aCIiTGovDidnp2ZO4bV5PTCy7ecd\n",
 "aeJxt9LIlt/FVk29sjdtutPMZgtQwKKp2gWyY9D7/x8Dxpf2DCkjAtqEdN3/GER6\n",
 "lybIrvAtYW7MNmu9MLkxionOak9CoZGsVg0kiXliHrhfxrDc8qLe8rqV\n",
 "-----END CERTIFICATE-----\n"]
> lines.class
=> Array

new or open methods returns an instance of the File class on which we can call readlines method which reads the entire file's content, splits it line by line and returns an Array of Strings where one element is one line from the file.

3. `File.readlines()` which is actually `IO.readlines()`:

> lines = File.readlines("cert.pem")
=> ["-----BEGIN CERTIFICATE-----\n",
 "MIICljCCAX4CCQD5x/0DnI1UazANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJQ\n",
 "TDAeFw0xOTA4MzExOTQ0NDdaFw0yOTA4MjgxOTQ0NDdaMA0xCzAJBgNVBAYTAlBM\n",
 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2qJrZayMFRE7zIeUL8CZ\n",
 "zqsOcwEv6flF41EjIvVf6h164i+NGkRu9E0wo1LHYsoF5tutYKKpRLJoY9xGq+Jr\n",
 "1SPOJYGBaFqKyQye+lnSzJdpnCAklXObfJpGtBmKCm4OTcb8eC4nm2q4x3mNkP5Z\n",
 "TgzdfIhALCwtD6wsHcyy5qmqGfPWAaGUDHqAQRu7QV/vu5VzJXgN0c6Zj+bOWw4H\n",
 "7Zu+FxtpUACQk4lnqt9CUzp6GX3dIETTfA3cpTFvoxwqBZGnrjsgZA5HzbyKRUYi\n",
 "aigbkyzc701sJaS8gcjIKDy2s8L8MfqaJkMu+N52e5tXoj4oQT9wPzxOou+GpYM/\n",
 "4QIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQDDrOrN+asQjkOwjPcNLkycy4TJ/6QE\n",
 "raNDVZ1N5h+70vIQwmmCS+hBN7SSM0f0OxgEggvK0etNQb6LXWXAIa7pMuzhqmHR\n",
 "9Q/NBizj+GOIvH7EoCTVKYUkRLxEq5i63cm0ZvFu9qwr8v7IGM4HkLo3A0F6+Vcp\n",
 "GNuOBNcGqAtCXNhgcpzu/6zWT2kAj1M82IC4aCIiTGovDidnp2ZO4bV5PTCy7ecd\n",
 "aeJxt9LIlt/FVk29sjdtutPMZgtQwKKp2gWyY9D7/x8Dxpf2DCkjAtqEdN3/GER6\n",
 "lybIrvAtYW7MNmu9MLkxionOak9CoZGsVg0kiXliHrhfxrDc8qLe8rqV\n",
 "-----END CERTIFICATE-----\n"]
> lines.class
=> Array

Here, we have the same output as in the previous example by calling just class method readlines on File class.

4. `File.foreach()` which is actually `IO.foreach()`:

> file = File.foreach("./cert.pem")
=> #<Enumerator: ...>
> file.entries
=> ["-----BEGIN CERTIFICATE-----\n",
 "MIICljCCAX4CCQD5x/0DnI1UazANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJQ\n",
 "TDAeFw0xOTA4MzExOTQ0NDdaFw0yOTA4MjgxOTQ0NDdaMA0xCzAJBgNVBAYTAlBM\n",
 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2qJrZayMFRE7zIeUL8CZ\n",
 "zqsOcwEv6flF41EjIvVf6h164i+NGkRu9E0wo1LHYsoF5tutYKKpRLJoY9xGq+Jr\n",
 "1SPOJYGBaFqKyQye+lnSzJdpnCAklXObfJpGtBmKCm4OTcb8eC4nm2q4x3mNkP5Z\n",
 "TgzdfIhALCwtD6wsHcyy5qmqGfPWAaGUDHqAQRu7QV/vu5VzJXgN0c6Zj+bOWw4H\n",
 "7Zu+FxtpUACQk4lnqt9CUzp6GX3dIETTfA3cpTFvoxwqBZGnrjsgZA5HzbyKRUYi\n",
 "aigbkyzc701sJaS8gcjIKDy2s8L8MfqaJkMu+N52e5tXoj4oQT9wPzxOou+GpYM/\n",
 "4QIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQDDrOrN+asQjkOwjPcNLkycy4TJ/6QE\n",
 "raNDVZ1N5h+70vIQwmmCS+hBN7SSM0f0OxgEggvK0etNQb6LXWXAIa7pMuzhqmHR\n",
 "9Q/NBizj+GOIvH7EoCTVKYUkRLxEq5i63cm0ZvFu9qwr8v7IGM4HkLo3A0F6+Vcp\n",
 "GNuOBNcGqAtCXNhgcpzu/6zWT2kAj1M82IC4aCIiTGovDidnp2ZO4bV5PTCy7ecd\n",
 "aeJxt9LIlt/FVk29sjdtutPMZgtQwKKp2gWyY9D7/x8Dxpf2DCkjAtqEdN3/GER6\n",
 "lybIrvAtYW7MNmu9MLkxionOak9CoZGsVg0kiXliHrhfxrDc8qLe8rqV\n",
 "-----END CERTIFICATE-----\n"]
> lines.class
=> Array

foreach method returns an Enumerator instance on which we call entries which returns an Array of String, again each element is a line from the file.

As we can see above there are many methods that allow us to read the file. However which one should we use and why? Let's create a large file and check those methods again!

Which methods should we use to read large files?

Generating our test file

At first, let's generate a large file with randomized data inside:

require 'securerandom'
one_megabyte = 1024 * 1024

name = "large_1G"
size = 1000

File.open("./#{name}.txt", 'wb') do |file|
  size.times do
    file.write(SecureRandom.random_bytes(one_megabyte))
  end
end

w - Write-only, truncates existing file to zero length or creates a new file for writing.
b - Binary file mode. Suppresses EOL <-> CRLF conversion on Windows. And sets external encoding to ASCII-BIT unless explicitly specified.

As the result we generated 1GB file:

❯ ls -lah
...
-rw-r--r--   1 user  user   1.0G Aug 31 22:10 large_1G.txt

Defining our metrics and profilers

There are probably 2 the most important metrics that we would like to track in our experiment:

Time - How long does it take to open and read the file?
Memory - How much memory does it take to open and read the file?

Also there will be one additional metric describing how many objects were freed by Garbage Collector.

We can prepare simple profiling methods:

# ./helpers.rb
require 'benchmark'

def profile_memory
  memory_usage_before = `ps -o rss= -p #{Process.pid}`.to_i
  yield
  memory_usage_after = `ps -o rss= -p #{Process.pid}`.to_i

  used_memory = ((memory_usage_after - memory_usage_before) / 1024.0).round(2)
  puts "Memory usage: #{used_memory} MB"
end

def profile_time
  time_elapsed = Benchmark.realtime do
    yield
  end

  puts "Time: #{time_elapsed.round(2)} seconds"
end

def profile_gc
  GC.start
  before = GC.stat(:total_freed_objects)
  yield
  GC.start
  after = GC.stat(:total_freed_objects)

  puts "Objects Freed: #{after - before}"
end

def profile
  profile_memory do 
    profile_time do 
      profile_gc do
        yield
      end
    end 
  end 
end

Testing our methods for reading files

.read

file = nil
profile do
  file = File.read("large_1G.txt")
end

Objects Freed: 39
Time: 0.52 seconds
Memory usage: 1000.05 MB

.new + #readlines

file = nil
profile do
  file = File.new("large_1G.txt").readlines
end

Objects Freed: 39
Time: 4.19 seconds
Memory usage: 1298.4 MB

.readlines

file = nil
profile do
  file = File.readlines("large_1G.txt")
end

Objects Freed: 39
Time: 4.24 seconds
Memory usage: 1284.61 MB

.foreach

file = nil
profile do
  file = File.foreach("large_1G.txt").to_a
end

Objects Freed: 40
Time: 4.42 seconds
Memory usage: 1284.31 MB

The examples we can see above allowed us to read the whole file and store it in local memory as one String or as an Array of Strings (each line from the file as one element in the Array).

As we can see, it requires at least as much memory as the size of the file:

one String - 1GB file requires 1GB of memory.
an Array of Strings - 1GB memory for file's content + additional memory for an Array (+- 300MB here). This approach has one advantage, we can access whichever line of the file we want as long as we know which line is it.

At this point we can see that the methods that we tested are not really efficient. The bigger the file, the more memory we need. In longer term this approach might lead to some serious consequences, even killing the application.

Now, we need to us ourselves a question. Can we process our files line by line? If so, then we can read our files in a different way:

.new + #each

file = nil

profile do
  file = File.new("large_1G.txt")
  file.each { |line| line }
end

Objects Freed: 4100808
Time: 2.08 seconds
Memory usage: 57.68 MB

.new + #advise + #each

file = nil

profile do
  file = File.new("large_1G.txt")
  file.advise(:sequential)
  file.each { |line| line }
end

Objects Freed: 4100808
Time: 2.22 seconds
Memory usage: 55.71 MB

Calling #advise method announces an intention to access data from the current file in a specific pattern. No major improvement here with using #advise method.

.new + #read - reading chunk by chunk

file = nil
chunk_size = 4096
buf = ""

profile do
  file = File.new("large_1G.txt")
  while buf = file.read(chunk_size)
    buf.tap { |buf| buf }
  end
end

Objects Freed: 256037
Time: 1.27 seconds
Memory usage: 131.64 MB

We defined the chunk as 4096 bytes and we read our file chunk by chunk. Depending on the structure of your file this approach might be useful.

.foreach + #each_entry

file = nil

profile do
  file = File.foreach("large_1G.txt")
  file.each_entry { |line| line }
end

Objects Freed: 4100809
Time: 2.22 seconds
Memory usage: 53.02 MB

Creating an Enumerator instance as file and reading file line by line using each_entry method.

First thing we can notice is that memory usage is way lower. Main reason for that is that we read the file line by line and when the line is processed then it's garbage collected. We can see that by the size of the Objects Freed, it's quite high.

We also tried to use here an #advise method which we can tell how we want to process our file. More about IO#advise can be found in the documentation. Unfortunately, it didn't help us out here.

Except IO#each method we have also similar methods like IO#each_byte (reading byte by byte),IO#each_char (reading char by char) and IO#each_codepoint.

In the example with reading by chunks (IO#read) the memory usage will vary depending on the chunk size. If you find this way useful you can experiment with the chunk size.

When using IO.foreach we operate on Enumerator which gives us a few more methods like: IO#each_entry, IO#each_slice, IO#each_cons. There is also lazy method which returns a Enumerator::Lazy. Lazy Enumerator has a few additional methods which enumerate values only on an as-needed basis. If you don't need to read the entire file but, for example, looking for a particular line containing given expression then it might be worth to check it out.

I could finish the article at this point, but what if before we even start reading the file we need to decrypt it? Let's move further to the example.

Decrypting large file and processing it line by line

Prerequisites

Before we decrypt the file we need to encrypt our generated large file. We are going to use AES with 256 bits key length with Cipher Block Chaining (CBC) as mode.

cipher = OpenSSL::Cipher::AES256.new(:CBC)
cipher.encrypt
KEY = cipher.random_key
IV = cipher.random_iv

Now, let's encrypt out file:

cipher = OpenSSL::Cipher::AES256.new(:CBC)
cipher.encrypt
cipher.key = KEY
cipher.iv = IV

file = nil
enc_file = nil

profile do
  file = File.read("large_1G.txt")
  enc_file = File.open("large_1G.txt.enc", "wb")
  enc_file << cipher.update(file)
  enc_file << cipher.final
end

file.close
enc_file.close

Objects Freed: 12
Time: 3.6 seconds
Memory usage: 1000.02 MB

Seems like encrypting is also a quite memory consuming task. Let's adjust the algorithm a little bit:

cipher = OpenSSL::Cipher::AES256.new(:CBC)
cipher.encrypt
cipher.key = KEY
cipher.iv = IV

file = nil
enc_file = nil

profile do 
  buf = ""
  file = File.open("large_1G.txt", "rb")
  enc_file = File.open("large_1G.txt.enc", "wb")
  while buf = file.read(4096)
    enc_file << cipher.update(buf)
  end
  enc_file << cipher.final
end

file.close
enc_file.close

Objects Freed: 768048
Time: 5.05 seconds
Memory usage: 145.93 MB

By changing the algorithm to read and cipher the file by chunks made the task much less memory consuming.

Decrypt

All right, let's try to decrypt it now:

decipher = OpenSSL::Cipher::AES256.new(:CBC)
decipher.decrypt
decipher.key = KEY
decipher.iv = IV

dec_file = nil
enc_file = nil

profile do 
  buf = ""
  enc_file = File.open("large_1G.txt.enc", "rb")
  dec_file = File.open("large_1G.txt.dec", "wb")
  while buf = enc_file.read(4096)
    dec_file << decipher.update(buf)
  end
  dec_file << decipher.final
end

dec_file.close
enc_file.close

Objects Freed: 768050
Time: 3.5 seconds
Memory usage: 152.12 MB

Now, let's compare our files whether we properly encrypted and decrypted it:

❯ diff large_1G.txt large_1G.txt.dec

No differences were found. We are good here!

We managed to lower the memory usage quite significantly. That's great!

Treat this article as a toolset that you can use in your specific case.

This article was originally posted on my personal dev blog: https://tjay.dev/

Photo by Erwan Hesry on Unsplash

DEV Community: Thomas Jaskiewicz

Question - Should I write about it?

Looking for a new terminal setup? I have something for you! ZSH + Starship + Hyper!

Revised and updated article can be found here:

HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥

Thomas Jaskiewicz for Netguru ・ Sep 7 '19 ・ 20 min read

HowTo: My Terminal & Shell setup - Hyper.js + ZSH + starship ☄🔥

1. Terminal - Hyper.js

1.1 Download and install Hyper.

1.2 Basic configuration

1.2.1 Font

1.2.2 Theme

1.2.3 Search Plugin

1.2.4 Pane Navigation Plugin

1.2.5 Open new tabs with the same directory

1.2.6 Mark active tab by adding a symbol to it

1.2.7 Showing CPU, RAM, battery stats

1.2.8 Bonus: feel this power!

2. Shell - ZSH + starship prompt

2.1 Installing ZSH

2.2 Installing starship prompt

2.2.1 Install

2.2.2 Syntax Highlighting

2.2.3 Setting completion plugin

HowTo: Working with large files in Ruby efficiently.

How can we read files in Ruby?

* Testing file generated by running a following command:

1. File.read() which is actually IO.read():

2. File.new() and its synonym File.open():

3. File.readlines() which is actually IO.readlines():

4. File.foreach() which is actually IO.foreach():

Which methods should we use to read large files?

Generating our test file

Defining our metrics and profilers

Testing our methods for reading files

Decrypting large file and processing it line by line

Prerequisites

Decrypt

1. `File.read()` which is actually `IO.read()`:

2. `File.new()` and its synonym `File.open()`:

3. `File.readlines()` which is actually `IO.readlines()`:

4. `File.foreach()` which is actually `IO.foreach()`: