DEV Community: Bruno Zani

WSL2, Docker, GUI - Manual Installation

Bruno Zani — Sun, 11 Apr 2021 20:45:11 +0000

WSL and WSL2

Make sure that

You have Windows 10 version 1903 or higher, with Build 18362 or higher. If not, update it.
- Check it by using Win+R, command winver
Virtualization is enabled inside of your computer's BIOS

Enable WSL on Windows 10

Run the commands below, using PowerShell on Admin mode:

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Open your PowerShell once again and try typing wsl, and if doesn't work, restart your machine

Upgrade to WSL2

Download and install the WSL2 kernel to update
Set the WSL default version to 2, via Powershell:

wsl --set-default-version 2

(in case of error, ignore it this time)

Linux Distro

Install the Ubuntu distro (or any other you like)

Open your Microsoft Store, search for the Ubuntu App, select the Ubuntu app (which is the latest) and install it
After installed, configure your root user and password

Upgrade WSL version for Ubuntu

List your distro using wsl --list, via Powershell
Set your distro to WSL version 2

wsl --set-version <distro_name> 2

Tips

Access your WSL "machine" through the wsl command (via Powershell or cmd), which stands for:

C:\Windows\System32\wsl.exe

Access your WSL "space" on Windows through: (Win+R or explorer):

\\wsl$

Find your Windows "space" on Linux:

/mnt/c/

You can also run Windows programs from WSL (try explorer.exe, or code . for VS Code, for example), however it doesn't mean all of them will work alright
Have in mind that WSL performance is strictly related to Linux usage, i.e., using WSL to manage and work with your files in /mnt/c won't help
Find your WSL "disk" on Windows:
- in the case of Ubuntu, we have something like this:

C:\Users\<User>\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu...\LocalState

Backup your WSL state:

wsl --export <distro> <output_file>                        # export
wsl --import <distro> <installation_location> <input_file> # import

or even, create a backup of the WSL "disk" file (previous item)

WSL2 uses almost all your machines resources, by default:
- Disk and CPU
- 80% of your available RAM
- 25% of your available memory for Swap
You can set up limits, by creating a config file (example):
- C:\Users\<User>\.wslconfig >

[wsl2] 
options=metadata,umask=22,fmask=11 
memory=8GB 
processors=4 
swap=2GB

Your custom configs are applied after a WSL restart:

wsl --shutdown

Windows Terminal

Windows Terminal is a new feature from Microsoft, improving your experience with terminals in Windows.

Install via Microsoft Store, by searching for Windows Terminal

With Windows Terminal you can:

have multiple terminals opened in separate tabs (instances)
different terminals running along (Ubuntu, git bash, Powershell, etc)
customize it by applying themes, configuring colors and shortcuts, etc
- change file settings.json by hitting Ctrl+, on Windows Terminal
- OR, open file from default dir:

C:\Users\<User>\AppData\Local\Packages\Microsoft.WindowsTerminal...\LocalState\settings.json

you can change e.g. your Linux starting directory and default shell, when opening Windows Terminal:

"defaultProfile": "{xxxxx-xxxx-xxxx-xxxx}",
...
{ 
    "guid": "{xxxxx-xxxx-xxxx-xxxx}",
    "name": "Ubuntu-18.04", 
    "startingDirectory" : "//wsl$/Ubuntu/home/<ubuntu_user>", 
}

Docker

3 ways to use Docker on Windows

Docker Toolbox - bad
- Uses Oracle VirtualBox
- Very bad performance
- Difficult setup and usage
Docker Desktop com Hyper-V - better
- Uses Microsoft Hyper-V instead of VirtualBox
- Requires Windows 10 PRO
- Better performance but a heavy consumer of host resources
- Docker will drop support in the future, as announced
Docker Desktop com WSL2 - recommended *
- Uses Microsoft Virtual Machine Platform
- Integrates with WSL2 and its distros
- Better performance and consumes less resources
- Usage as running on Linux natively

*Download and install Docker Desktop
https://hub.docker.com/editions/community/docker-ce-desktop-windows

Enable Docker on WSL2 distro
- Docker Desktop > Settings > Resources > WSL Integration
> Enable integration with additional distros > Check distro

Play with docker on WSL
- Open WSL and hit docker ps or try out docker run hello-world

WSL Linux GUI

Optional

A way to run Linux apps using WSL "builtin GUIs" is on the way, as one of the WSL improvements of Microsoft's roadmap.

While it still unavailable, we can still install a GUI and use RDP (Remote desktop), to access the Linux VM.

First of all, update and upgrade your Linux:

sudo apt update && sudo apt -y upgrade

Install (or overwrite) X-RDP:

sudo apt-get purge xrdp
sudo apt install -y xrdp

Install a GUI:

sudo apt install -y xfce4 # check 'gdm3' option
sudo apt install -y xfce4-goodies

XFCE is a lightweight GUI for testing purposes

Configure access, create a backup, improve RDP session quality and define session:

sudo cp /etc/xrdp/xrdp.ini /etc/xrdp/xrdp.ini.bak
sudo sed -i 's/3389/3390/g' /etc/xrdp/xrdp.ini
sudo sed -i 's/max_bpp=32/#max_bpp=32\nmax_bpp=128/g' /etc/xrdp/xrdp.ini
sudo sed -i 's/xserverbpp=24/#xserverbpp=24\nxserverbpp=128/g' /etc/xrdp/xrdp.ini
echo xfce4-session > ~/.xsession

Edit XRDP startup script:

sudo nano /etc/xrdp/startwm.sh

Comment these last lines:

# test -x /etc/X11/Xsession && exec /etc/X11/Xsession 
# exec /bin/sh /etc/X11/Xsession

Add these lines:

# xfce
startxfce4

Start RDP session:

sudo /etc/init.d/xrdp start

Access it from your Windows:

Run command mstsc (Win+R)

localhost:3390

Dev Projects

There are many softwares that already works integrated with WSL:

on VS Code for example, you can find add-ons to work "remotely" with your projects in WSL, as you can see here
IntelliJ also have its ways to deal with WSL integration and run along with your projects, as you can see here
on the other hand, there may be softwares that are more complex to integrate with WSL (or even don't)

If you have any further info, specially about dev workspaces with WSL, just drop me a line below and help everyone enjoy and experience the benefits of this tool.

See ya.

Source
https://docs.microsoft.com/en-us/windows/wsl/install-win10#manual-installation-steps
https://github.com/codeedu/wsl2-docker-quickstart (pt-br)
https://github.com/davidbombal/wsl2/blob/main/ubuntu_gui_youtube

Java streams and Fibonacci

Bruno Zani — Sat, 03 Apr 2021 21:20:12 +0000

So, you still struggling trying to understand expressions like this in Java 8+:

Stream.iterate(new long[]{ 0L, 1L }, p->new long[]{ p[1], p[0]+p[1] }).map(p -> p[0]).limit(10).map(p->p+" ").forEach(System.out::print);

Do you have a clue about what this line is about to do, when you hit Run? Yes, you're right, you'll have the Fibonacci sequence of 10 elements printed in your console, like this:

0 1 1 2 3 5 8 13 21 34

It's a tricky one, and if you didn't answer that correctly, I'll try something easier before digging into an explanation.

So, your second chance is right here:

Arrays.asList(1, 2, 2, 3, 4, 4, 4, 5, 6, 8).stream()
    .distinct()
    .filter(x -> x % 2 == 0)
    .map(x -> x * 10)
    .skip(1)
    .limit(2)
    .peek(System.out::println)
    .reduce(0, Integer::sum)

Don't need no math right now, because what I wanted to show you is how this works step by step.

So, first of all, what a STREAM is?

Must have in mind is that:

Streams are not a data structure
Streams doesn't store or modify data
It can be defined as a wrapper around a data source
Supports functional-style operations
Fast and convenient bulk processing over a data source
Iteration over elements are sequential and declarative
Parallel-friendly, immutable and thread-safe
Lazy evaluation
Single use
Don't confuse with Java I/O (ex. FileInputStream)

Besides that, we have:

Intermediate operations: stream chained operations that return new streams (pipeline)
Terminal operations: execute the stream and produces a non-stream object (result)

You can create a stream by invoking the methods stream() or parallelStream(), or even use Stream.of, Stream.ofNullable or Stream.iterate (like I did for Fibonacci).

Let's try to get back a little bit and "debug" the easy example up there:

Arrays.asList(1, 2, 2, 3, 4, 4, 4, 5, 6, 8)

Creates a new Collection, so we can iterate through its elements via stream

.stream()

Starts a new stream

.distinct()

Retain distinct elements, returning: [1, 2, 3, 4, 5, 6, 8]

.filter(x -> x % 2 == 0)

Filter pair elements by applying mod 2, returning: [2, 4, 6, 8]

.map(x -> x * 10)

Multiplicates each filtered element by 10, returning: [20, 40, 60, 80]

.skip(1)

Skips the first element of the sequence, returning: [40, 60, 80]

.limit(2)

Returns the first 2 elements of the sequence: [40, 60]
This is a "short-circuit" command, i.e., it'll interrupt the stream processing when the condition is match - in this case, when we reach the second element

.peek(System.out::println)

Some kind of "debug" mode of stream, in this case it'll println each remaining element of the stream operation: 40 and 60

.reduce(0, Integer::sum)

In this case, we're gonna effectively consume the stream and get a Integer result from it: the sum of all elements, where 0 is the starting value, and Integer::sum invokes the Integer.sum(int a, int b) function from the Integer class, that will be performed over each remaining element from the stream operation, that is, 40 and 60, then resulting 100.

Now, what about the Fibonacci stuff up there? Right on, let's get back to it.

Stream.iterate

By definition, we have:

Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.

That said, all we have to do is to provide a seed (i.e., the starting point, or, the initial element) and then a function to be applied to the previous element to produce a new element.

new long[]{ 0L, 1L } // as the 1st parameter

For the Fibonacci "kickstart" we need two elements: 0 and 1. Then, the sum of both will provide the next element and so on. That said, this array will represent a pair of the first values of the Fibonacci sequence, as the first element of the stream.

p->new long[]{ p[1], p[0]+p[1] }) // as the 2nd parameter

So, this object p will create a new array containing two elements:

p[1]: which is the previous array in the position 1;
p[0] + p[1]: which is the previous array in the position 0 plus its position 1;

.map(p -> p[0])

The thing is, we have a stream of pair elements going on until now, however, our main goal is to print elements of this sequence. To get the "current" element of this operation, by "mapping" the current pair of values of this stream to a single element, in this case, the array in position 0.

.limit(10)

This is important, as said before, this will Return an infinite sequential ordered Stream by default. So, in order not to have this running forever, with your PC burning out, we define a "limit" to this operation, by processing the first 10 elements only.

.map(p->p+" ")

This is silly, as we want to just print the sequence, it would be nice if we have a separator for each element, so here it is.

.forEach(System.out::print)

The forEach is a terminal operation as well, and what it'll do is to iterate over the resulting collection of the Stream. So, here we're just printing the current element by using the well-known System.out.print.

If you're not familiar with expressions like this System.out::print yet, better check out about method reference, which is a special type of lambda expression, very useful to reduce boilerplate and improve readability. Next chapter suggested to write about is on Java functional programming.