DEV Community: Jeisson Florez

Best books I've read in 2022 📚

Jeisson Florez — Fri, 16 Dec 2022 15:55:15 +0000

One of my goals this year was to read more than in previous years and I wanted to share with you some of the best books I read in 2022, some of them are recommendations from other people and others were simply in the long Wanted to read list. These books covered a wide range of topics and all provided valuable insights and information.

"Thinking, Fast and Slow" by Daniel Kahneman. This book goes in-depth into the psychology of decision making and how the brain processes information. It is a fascinating read that help to better understand the thought processes and make more effective decisions. The book contains many examples from different scientific experiments about how our brain acts in different conditions.
"Time Smart" by Ashley Whillans. This book explores the importance of time and how to use it more effectively. The author covers topics like time management, work-life balance, and the benefits of taking breaks. Like the previous one, this book shows some examples of everyday life where we think that something is very important and we can not postpone it and the reality is that it is not so. This book is a must-read for people looking to optimize their time and increase productivity.
"Why We Sleep" by Matthew Walker. In this book, Walker discusses the science behind sleep and the numerous benefits it has on our physical and mental health. He also offers practical tips for improving sleep quality and getting a good night's rest.
"A Short History of Nearly Everything" by Bill Bryson. For those interested in science this book covers a wide range of scientific topics, from the origins of the universe to the evolution of life on Earth and humans. It is a thorough and entertaining read that leaves us with a greater appreciation for the world around us and how fortunate we are to be in an age where even a minimal understanding of it is possible.
"Little Book of Common Sense Investing" by John C. Bogle. Bogle, the founder of Vanguard and a pioneer of index fund investing, offers practical advice for avoiding the most common mistakes that can set even the best-intentioned investors up for failure. He advocates for a low-cost, passive approach to investing that focuses on diversification and long-term growth rather than trying to beat the market. It's a great resource for anyone looking to build a solid investment portfolio.

Overall, these five books offer a wealth of knowledge and insights, and I highly recommend them to anyone whose reading desires fall between these topics.

Any recommendations for the coming year?

Happy reading!

If you like this post you can find more in https://jeisson.dev/blog/ and can follow me in twitter @jeissonflorez29 👋

How to deploy apps from GitHub to Heroku

Jeisson Florez — Thu, 12 May 2022 15:58:09 +0000

Some weeks ago, the Heroku’s GitHub integration was deactivated due to an issue where some tokens of private repositories in GitHub were compromised and attackers were potentially able to download and access source code of those repositories. More info regarding the issue in a blog post from Heroku.

There are many posts, threads on Twitter and videos about alternatives to Heroku, however, for those who want to keep using it as platform provider with a similar behaviour as the official integration, there are some alternatives without put too much effort on it like using GitHub actions.

GitHub Action - Deploy to Heroku

Deploy to Heroku is a GitHub action that allow to deploy to Heroku by using NodeJS commands under the hoods. The official documentation is pretty clear and complete, so to use this action (as any other action 😛) we just need to follow some basic steps.

In this case we are going to use The Procfile | Heroku Dev Center but there are also options to application using docker configurations.

Make sure the folder named .github/workflows/ exists.
Create or modify the YAML file that contains the GitHub action we want to use to deploy.
Add the akhileshns/heroku-deploy@v3.12.12 to your job.

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      .... other steps 

      - name: Deploy to stage
        uses: akhileshns/heroku-deploy@v3.12.12
        with:
          heroku_api_key: ${{secrets.HEROKU_API_KEY}}
          heroku_app_name: ${{secrets.HEROKU_APP}}
          heroku_email: ${{secrets.HEROKU_EMAIL}}

Set the environment variables in the repository using the action. Go to Settings -> Security -> Secrets -> Actions.

Execute the job and check that it is able to finish the deployment successfully.

I have tried other options to make a deployment to Heroku from GitHub like using the Heroku CLI commands directly but in terms of simplicity and easiness I believe this is one of the easiest way to get close to how it was working before with the official integration.

If you like this post you can find more in https://jeisson.dev/blog/ and follow me in twitter @jeissonflorez29 👋

Off-heap memory in Java

Jeisson Florez — Thu, 08 Apr 2021 12:50:22 +0000

The heap area is one of the most important parts in the JVM architecture since it stores all the objects created in a JVM instance, however, there are some cases when it is convenient to put them outside of it. In this post we will see how this can be achieved and some implementations in this regard.

Introduction

First, let's take a quick look at the JVM architecture.

As we can see the heap is into the Runtime Data Area which contains the areas that are used during the execution of a program, some of them are per thread and others are unique by JVM instance such as the heap. The garbage collector must be taken into account because it is key to understand how memory is managed in the heap.

A formal definition of the heap area is:

The Java Virtual Machine has a heap that is shared among all Java Virtual Machine threads. The heap is the run-time data area from which memory for all class instances and arrays is allocated. The heap is created on virtual machine start-up. Heap storage for objects is reclaimed by an automatic storage management system (known as a garbage collector); objects are never explicitly deallocated. The Java Virtual Machine assumes no particular type of automatic storage management system, and the storage management technique may be chosen according to the implementor’s system requirements. The heap may be of a fixed size or may be expanded as required by the computation and may be contracted if a larger heap becomes unnecessary. The memory for the heap does not need to be contiguous. JVM Specification

Knowing that all the data stored in the heap is subject to the garbage collector, if the data stored in the heap becomes huge, the time consumed by the garbage collector will be proportionally higher, and here we may be wondering why this may affect us? Well, each garbage collector has a different method to do the heap cleanup but they all have something in common, the Stop-The-World mechanism, which means that at some point all the application threads will be suspended until the garbage collector processes all the objects in the heap.

That said, while the garbage collector algorithms do a great job of cleaning up in super fast time, when we are dealing with near real-time applications we don't have the option of having these pauses, or when the available physical memory is less than needed then that is when dumping that data off the heap is an option.

Off-heap memory

Off-heap memory refers to the memory allocated directly to the operative system, it can be part of the same physical memory or/and disk access based such as memory mapped-files. As putting data out of the JVM, serialization is needed to write and read that data, and the performance will depend on the buffer, serialization process and disk speed (if applicable).

Benefits

Reduction of garbage collection pressure.
Large memory size, depending on the implementation.
Memory shared among all JVMs present in the OS.

Considerations

Serialization process impact on the performance
Manual memory management is hard and error-prone (ask to C devs 😅).

Usage

The way to use off-heap memory depends on the developers and the business case, either creating an own implementation using Java NIO API that allow us to allocate memory manually or using any of the implementations already in the market.

In this post we will see in a general overview a library that implements some of the most common data structures used in java.

Chronicle-Map: Chronicle Map is an in-memory, key-value store, designed for low-latency, and/or multi-process applications.

Let's do a simple test in which the scenario is an application that processes a few million numbers and put them in a Set data structure to sum them up afterwards.

Project repo: GitHub - off-heap-tests
Max Heap size: 2Gb
JDK: OpenJDK 64-Bit Server VM Microsoft-18724
Physical memory: 16Gb



long sumNumbers(Set<Long> numbers) throws InterruptedException {
    for (int i = 0; i < 30_000_000; i++) {
        numbers.add(random.nextLong());
        if (i % 1_000_000 == 0) Thread.sleep(1000); // To have time to check jconsole
    }
    return numbers.stream().reduce(0L, Long::sum);
}



public static void main(String[] args) throws InterruptedException {
    var start = Instant.now();
    new Main(). executeTest();
    var end = Instant.now();
    var timeMilli = end.toEpochMilli() - start.toEpochMilli();
    System.out.println("Time to get finished in ms: " + timeMilli);
}

HashSet Java implementation

The first test will be using a simple HashSet implementation



void executeTest() throws InterruptedException {
    final Set<Long> set = new HashSet<>();
    System.out.println(sumNumbers(set));
}

We can say It took about 58K ~ 59K milliseconds to get finished.

ChronicleSet implementation

ChronicleSet provides a builder that needs the type and the max amount of entries to allocate the memory based on them.



void executeTest() throws InterruptedException {
    final var set = ChronicleSetBuilder.of(Long.class)
        .entries(30_000_000)
        .create();
      return sumNumbers(set);
}

We can say It took about 52K ~ 53K milliseconds to get finished and also notice about change in the heap memory used and the reduction of GC impact.

Conclusions

Off-heap memory is a good option when the data stored in the heap is huge and we need to reduce the time consumed by the garbage collector, also when an application uses more memory than the available physical and using disk space is an option. However, it is worthy to remind that working directly to memory allocation is not an easy task and it can bring difficult issues to deal with.

In what other cases do you think off-heap memory can be used ?

If you like this post you can find more in https://jeisson.dev/blog/ and follow me in twitter @jeissonflorez29 👋

Project Loom & Virtual Threads in Java

Jeisson Florez — Mon, 22 Mar 2021 22:58:41 +0000

Disclaimer: This post will mention some terms such as concurrency, threads, multitasking, and others that will be not explained in a detailed way, but will try to add references to other posts or pages about them.

Concurrency in Java is natively managed by using threads (java.lang.Thread) which basically is a wrapper/mapper for a native OS thread. This model fits well in a system that does not need too many threads, however it brings some drawbacks when we want to use them in a large scale, let’s say hundreds or thousands threads.

Why ?

Native OS threads must support all programming languages, they are not optimised for a specific one (maybe C 🤔).
Expensive context switching.
High memory resource usage (stack size).

These items bring issues to escalate java applications using the thread approach to do concurrent jobs using many threads.

E.g. A web server application processing 500 req / sec -> 500 threads -> 500 Mb. Thinking about only threads created for each request, for sure a web server use other threads and memory.

Here is where Project Loom comes as a solution, so first of all let’s define what Project Loom is and what it brings to the Java world.

Note Project Loom is still an ongoing project and all the information, names and definitions about it could change and there is not any official JDK released to work with.

Project Loom is to intended to explore, incubate and deliver Java VM features and APIs built on top of them for the purpose of supporting easy-to-use, high-throughput lightweight concurrency and new programming models on the Java platform - Project Loom Wiki

Project Loom is a platform based solution introducing the concept of Virtual Thread (a.k.a Fiber) that is a lightweight thread managed by the Java Virtual Machine rather than the operating system and it fits with the existing Java APIs allowing synchronous (blocking) code.

Using Project Loom in a Java application

Note This post wants to show a general overview and some notions about how project loom and virtual threads perform rather than showing any kind of micro benchmark or something deeper.

We will use jconsole to monitor the performance and then check how many threads are created, how much memory is used and how the CPU is behaving.

For these tests a MacBook Pro 15” 2018 will be used:

16Gb
2,2 GHz 6-Core Intel Core i7
Mac OS Catalina

Since there is not any official release of the JDK including Project Loom, we must use the early-access binaries provided by the project.

We can download them from the official page of the project, these binaries are based on JDK 17 and there are options for Linux, MacOS and Windows binaries.
Project Loom Early-Access Builds

Once the binaries are downloaded and set in the PATH we can use the JDK Project Loom:

❯ java --version
openjdk 17-loom 2021-09-14
OpenJDK Runtime Environment (build 17-loom+2-42)
OpenJDK 64-Bit Server VM (build 17-loom+2-42, mixed mode, sharing)

Threads

Let’s do a naive test creating an app that creates 1000 threads and each thread run some random math operations between two numbers during a couple of minutes, and then compare the performance using the usual native threads vs virtual threads.

static class RandomNumbers implements Runnable {

    Random random = new Random();

    @Override
    public void run() {
        for (int i = 0; i < 120; i++) { // during 120 seconds aprox
            try {
                int a = random.nextInt();
                int b = random.nextInt();
                int c = a * b;
                System.out.println("c = " + c); // print to avoid compiler remove the operation
                Thread.sleep(1000); // each operation every second
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Then let’s create the threads.

public static void main(String[] args) throws InterruptedException {

      // Create 1000 native threads 
    for (int i = 0; i < 1000; i++) {
        Thread t = new Thread(new RandomNumbers());
        t.start();
    }

    Thread.sleep(120000);
}

Native threads results

Around 1000 threads.
CPU usage between 2 and 3 %.
Constant memory usage around 150 Mb.

Now let’s do the same operation using virtual threads

public static void main(String[] args) throws InterruptedException {

      // Create 1000 virtual threads 
    for (int i = 0; i < 1000; i++) {
        Thread.startVirtualThread(new RandomNumbers());
    }

    Thread.sleep(120000);
}

Virtual threads results

Around 30 threads
CPU usage under 2%
Incremental memory usage from 20Mb to 60 Mb.

Executor services

Now let’s do a test using something more elaborate using Executor service to schedule the threads .

CachedThreadPool Executor service

public static void main(String[] args) throws InterruptedException {

    ExecutorService executor = Executors.newCachedThreadPool();

    for (int i = 0; i < 1000; i++) {
        executor.submit(new RandomNumbers());
    }

    executor.shutdown();

    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
}

This implementation of executor service uses a new thread (native) per task scheduled unless there is a free thread to take it.

These results look pretty similar to the threads approach

Around 1000 threads.
CPU usage around 2 %.
Constant memory usage around 130 Mb.

VirtualThreadExecutor Executor service

public static void main(String[] args) throws InterruptedException {

    ExecutorService executor = Executors.newVirtualThreadExecutor();

    for (int i = 0; i < 1000; i++) {
        executor.submit(new RandomNumbers());
    }

    executor.shutdown();

    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
}

These results show a light decrease of memory and CPU usage.

Around 30 threads.
CPU usage between 1 and 2 %.
Incremental memory usage from 30Mb up to 40 Mb.

Conclusion

We can see how the use of virtual threads could help us when we need to use concurrency using thousands of threads without compromising performance and making optimal use of resources.

Project Loom is promising a good future to Java and its concurrency API to be at the level of other languages that already have lightweight concurrency models.

_If you like this post you can find more in https://jeisson.dev/blog/ and follow me in twitter @jeissonflorez29 👋

OpenJDK: Loom

MacOS Development workspace 2023

Jeisson Florez — Mon, 08 Mar 2021 17:31:33 +0000

It is a fact that there are many guides out there about how to set up a dev workspace, however, some of them are outdated or no longer fit my needs, I have collected a lot of information from some of them and created a new guide that I want to share.

As developers we need to install almost always the same set of tools for our daily basis, so this guide will go throught a list of apps, sdks, commands and many others tools that I found useful.

I have created a repository on GitHub to store the dotfiles and the installation script in case anyone wants to go straight to use it, I recommend to read the guide before though.

With this guide we will assume a clean installation of MacOs and go step by step through the installation process and a short description of each app/command/tool.

Let's open a new terminal and get started ...

Xcode

Xcode is a large suite of software development tools and libraries from Apple, even if we are not iOS/MacOs developers, this step is necessary to install Xcode command line tools which includes MacOs SDK, and many other common tools, compilers, and commands that we will need in the whole guide.

Input the following command in a Terminal

xcode-select --install

A system popup will appear to confirm the installation, click Install and agree the terms.

After the process is finished, the pop-up window will look like this.

Homebrew

Homebrew is in general words a package manager for MacOs that allow us to install software that does not come installed by default. It works as a command tool, although there are some apps to use it with a graphical user interface like Cakebrew.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Furthermore the default formulae, brew is able to track and use third parties repos, we need to add some repos and we can do it using the brew tap 'repo' command.

brew tap homebrew/cask
brew tap homebrew/cask-fonts

homebrew/cask brings simplicity, and speed to the installation and management of GUI macOS applications such as Atom and Google Chrome.
homebrew/cask-fonts As we can imagin it contains free distributed fonts

I recommend visiting and reading Hombew documentation page to solve any doubt about brew.

Let's move to install brew packages

Fonts

brew install font-meslo-lg-nerd-font

This font comes from the awesome fonts package Nerd fonts that includes developer targeted fonts such as Font Awesome, Powerline, and others. We will use this one to make our terminal pretty using icons.

By the way, we can search which fonts are included in this package by brew search nerd and then install any other we want just changing the name of the font in the command used before.

GNU Utilities

MacOs command line tools are based on FreeBSD instead of GNU, so this could be a challenge when we want to script something supported by both platforms or if we are used to gnu commands. brew can help us installing the GNU tools, however, they come with a prefixed g by default. We will install following tools coreutils, moreutils, findutils, gnu-sed, gawk, gnu-tar, grep, make, check their pages and decide if you want/need all of them.

brew install coreutils moreutils findutils gnu-sed gawk gnu-tar grep make

Other Command Utilities

In this section we will install other commands and utilities.

htop: A better option than top to monitor the system.
tree It's useful to list directories and files recursively.
exa: It's an alternative to the default listing command ls.
cowsay: Generates an ASCCI picture of a cow with a message passed by string.
bat: A cat clone with syntax highlighting and Git integration.
clementtsang/bottom/bottom: A graphical process/system monitor with a customizable interface and a multitude of features.
tldr: It's an option to get the the command options and practical examples.
jid: An utility to view and interact JSON content with a terminal.
hiperfine: A command-line benchmarking tool.
highlight: Converts sourcecode to HTML, XHTML, RTF, LaTeX, TeX, SVG, BBCode and terminal escape sequences with coloured syntax highlighting.
nvim: It's an alternative vim-based editor with lots of plugins and programming languages supported.
youtube-dl: A command-line program to download videos from YouTube and other sites.
autojump: A faster way to navigate your filesystem
httpie: It's a user-friendly command-line HTTP client, it comes with JSON support, syntax highlighting, persistent sessions, wget-like downloads, plugins, and more.
thefuck: It's an app able to correct errors in previous console commands.
golang, python, python3: Programming languages.
kap: It's an screen recorder built with web technology.

brew install htop tree exa cowsay bat clementtsang/bottom/bottom \
vim tldr jid hyperfine highlight nvim youtube-dl autojump \
httpie thefuck golang python python3 git kap

GUI Apps

Some of the applications that we will install do not need a description, we will explain those that are probably not common or deserve to be listed.

iterm2: An alternative to the default terminal app brings an amazing performance and customization.
expressvpn: It's the best vpn service I have tried with lot of servers around the world and good performance.
alfred: An app that allow to be more efficient with shortcuts, searches and own workflows.
bitwarden: Service of security for passwords, files, credit cards, it has a nice integration and synchronization in wide list of devices.
stats: A pretty macOS system monitor in the menu bar, includes CPU, Memory, disk, network, fans.
notion: The app to create boards, take notes, track tasks, get organized and many othe features.
ticktick: A To-do and habit tracker app.
authy: 2nd Factor authentication app, it's able to get syncronized in cloud.
dash: Useful to download and store api documentation sets.
insomnia: An alternative to postman for design and test apis.
kawa: A macOS input source switcher with user-defined shortcuts.
copyq: CopyQ is advanced clipboard manager with editing and scripting features.
calibre: It's an open source e-book manager.

brew install --cask firefox spotify iterm2 expressvpn \
alfred the-unarchiver visual-studio-code docker \
postman atom stats notion telegram ticktick zoom vlc \
intellij-idea whatsapp authy \
dash insomnia kawa copyq calibre \
microsoft-office brave-browser discord virtualbox skype

Iterm 2

Iterm2 provides a lot of features and customization is one of them, for people who have gotten used to dark mode like me, we have a lot of themes to choose from.

We will use dracula theme, for that we need to download the .itermcolors file either by cloning the repo or downloading the zip.

Once we have the file in our filesystem we need to open Iterm2 preferences -> profile -> colors

Import the Dracula.itermcolors downloaded before and then choose Dracula as theme

Now we will change the font to MesloLGS Nerd Font Mono the one installed in a previous step to make iterm able to show icons with powerline fonts.

P.S. Oh-my-zsh and powerlevel10k still need to be installed for Iterm to look like this.

Oh-My-Zsh

Since MacOs Catalina, zsh is the default shell on MacOs, zsh provides over 200 plugin integrations and is very similar to bash. There is a good comparison between the two here.

Oh-my-zsh is an open source and powerful community framework for managing zsh.

We can install oh-my-zsh with following command

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Or this one if we like wget

sh -c "$(wget https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh -O -)"

Plugins

Oh-my-zsh provides too many useful plugins, we are going to install a few of them.

zsh-autosuggestion: It suggests commands as you type based on history and completions.
zsh-syntax-highlighting: provides syntax highlighting for command type in the prompt of zsh terminal.
fzf: It's a powerful command line finder.
powerlevel10k: It's a theme for Zsh. It emphasizes speed, flexibility and out-of-the-box experience.

### Install zsh-autosuggestions
git clone --depth=1 https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
### Install zsh-syntax-highlighting
git clone --depth=1 https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
### Install fzf
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install
### Install powerlevel10k theme
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

Once the plugins are installed, we must activate them by modifying the ~/.zshrc file wich is the zsh configuration file.

....
plugins=(git zsh-syntax-highlighting zsh-autosuggestions fzf)
....

And this will activate powerlevel10k theme

ZSH_THEME="powerlevel10k/powerlevel10k"

Finally the .zshrc file should looks like this.

if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
  source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
fi

export ZSH="/Users/user/.oh-my-zsh"

ZSH_THEME="powerlevel10k/powerlevel10k"

plugins=(git zsh-syntax-highlighting zsh-autosuggestions fzf)

source $ZSH/oh-my-zsh.sh

# fzf plugin
[ -f ~/.fzf.zsh ] && source ~/.fzf.zsh

# To customize prompt, run `p10k configure` or edit ~/.p10k.zsh.
[[ ! -f ~/.p10k.zsh ]] || source ~/.p10k.zsh

We need to restart the terminal and then the powerlevel10k configuration wizard will start.

NVM

Nvm is a version manager for node js, it helps us to install different versions of node and change it easily.

We will install it by executing next command in the terminal

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.0/install.sh | bash

During the installation process it will try to add some exports to .zshrc file to be able to use it. the file should include some lines like this:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completio

Once we have verified that the lines are included, we should reload the session with source ~/.zshrc or open a new terminal window.

Now we can install any node version we want, in this case we will install the most recent lts version released

nvm install node lts

then we can check that node is installed properly

node --version

SDKMAN

SDKMAN is a tool for managing parallel versions of multiple Software Development Kits on most Unix based systems, It provides a convenient Command Line Interface (CLI) and API for installing, switching, removing and listing Candidates.

To install sdkman input the following command in a new terminal

P.S. In this case we don't want to let it modify our bash files because we will do it by ourself for that we add the query param rcupdate=false, we can remove it if we want update the files with the installation.

curl -s "https://get.sdkman.io?rcupdate=false" | bash

After the process is finished we need to add the following lines to our ~/.zshrc file and reload the shell by source ~/.zshrc to be able to use it.

export SDKMAN_DIR="$HOME/.sdkman"
[[ -s "$SDKMAN_DIR/bin/sdkman-init.sh" ]] && source "$SDKMAN_DIR/bin/sdkman-init.sh"

Now we can install any sdk availble into sdman. We will install JDK, to know which versions are available we can use the list option sdk list java

With the list obtained before we should use the column Identifier to indicare what version we want.

sdk install java 11.0.10.j9-adpt

Now we should be able to use java JDK.

There are many other sdks, we can check them here https://sdkman.io/sdks

dotfiles

These dotfiles consist of 7 files, each one with an specific purpose.

.aliases: All the shortcuts for most used commands.
.functions: A set of useful bash functions.
.exports: All the exports needed for the software installed in this guide.
.gitconfig: Git configuration
.gitignore: General git ignore configuration.
.p10k.zsh: powerlevel10k theme configuration, this is the file generated by the theme installation.
.zshrc: zsh file configuration, includes plugins declaration, theme, and imports of other dotfiles.

Defaults write commands

Commands for change default MacOs preferences

Finder

# Show file extensions 
defaults write NSGlobalDomain AppleShowAllExtensions -bool true
# Disable the warning before emptying the Trash
defaults write com.apple.finder WarnOnEmptyTrash -bool false
# Use list view in all Finder windows by default
# Four-letter codes for the other view modes: `icnv`, `clmv`, `Flwv`
defaults write com.apple.finder FXPreferredViewStyle -string "Nlsv"
# When performing a search, search the current folder by default
defaults write com.apple.finder FXDefaultSearchScope -string "SCcf"
# Disable the warning when changing a file extension
defaults write com.apple.finder FXEnableExtensionChangeWarning -bool false

Dock

# Set the icon size of Dock items to 48 pixels
defaults write com.apple.dock tilesize -int 48
# Show indicator lights for open applications in the Dock
defaults write com.apple.dock show-process-indicators -bool true
# Speed up Mission Control animations
defaults write com.apple.dock expose-animation-duration -float 0.1
# Remove the auto-hiding Dock delay
defaults write com.apple.dock autohide-delay -float 0
# Remove the animation when hiding/showing the Dock
defaults write com.apple.dock autohide-time-modifier -float 0.1
# Automatically hide and show the Dock
defaults write com.apple.dock autohide -bool true

Activity Monitor

# Show the main window when launching Activity Monitor
defaults write com.apple.ActivityMonitor OpenMainWindow -bool true
# Visualize CPU usage in the Activity Monitor Dock icon
defaults write com.apple.ActivityMonitor IconType -int 5
# Show all processes in Activity Monitor
defaults write com.apple.ActivityMonitor ShowCategory -int 0
# Sort Activity Monitor results by CPU usage
defaults write com.apple.ActivityMonitor SortColumn -string "CPUUsage"
defaults write com.apple.ActivityMonitor SortDirection -int 0

Others

# Disable the sound effects on boot
sudo nvram SystemAudioVolume=" "
# Don’t display the annoying prompt when quitting iTerm
defaults write com.googlecode.iterm2 PromptOnQuit -bool false

Other Apps

Total finder: Plugin for add tabs, tags and other features to finder.
Clean my mac: Cleaner app for MacOs.
Pocket: App to save content to check later.
Magnet: Window manager app.