
If you're planning on using your Raspberry Pi just to run software on it, or to control electronics, there is no need to set up a monitor, mouse and keyboard for it. You can simply connect it to your home network and use it from your main computer. Setting up a device like this is called headless setup.

The problem is that the Raspberry Pi's operating system which often comes preinstalled with it, or can be easily installed onto it, comes without any form of remote access enabled. Luckily for us, we can enable them with just a few simple additional steps in the setup process. Let's get into it!

## Table of Contents

- [Installing the Operating System](#installing-the-operating-system)
- [Connecting with SSH (terminal access)](#connecting-with-ssh-terminal-access)
- [Connecting with VNC (desktop access)](#connecting-with-vnc-desktop-access)
- [Debugging](#debugging)

## Installing the Operating System

Whether your Raspberry Pi came with a preinstalled OS or you're using a blank storage device, a headless setup requires a new install of the operating system:

1. Insert a microSD card into your computer.

2. [Download](https://www.raspberrypi.com/software/), install and run the official Raspberry Pi Imager

3. Click on the **Choose OS button**

<picture>
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/choose-os-400.webp" type="image/webp"  />
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/choose-os-400.jpg" type="image/jpeg" />
  <img src="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/choose-os-400.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

4. Choose your operating system

If you don't understand the difference between a 32 and 64-bit version of an operating system and just want to get on with the installation, I would recommend installing the 64-bit version of Raspberry Pi OS. You can find it by clicking **Raspberry Pi OS (other)**

<picture>
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/64-bit-578.webp" type="image/webp"  />
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/64-bit-578.jpg" type="image/jpeg" />
  <img src="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/64-bit-578.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

Whichever you choose, you probably won't notice a difference unless you're an experienced user. If you're curious, you can of course spend some time figuring out which option is the best for you by using your favourite search engine.

5. Click **Choose SD card** and select your card from the menu. **Do not click write yet**

If you wanted to set up your Pi with a monitor, keyboard and mouse, you could skip the next step. However, if you want to do a headless setup, the next step is essential. This is also the part that has changed after the April 2022 update and older tutorials won't mention this at all.

6. Click on the **settings icon** on the bottom right to open Advanced options

<picture>
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/settings-400.webp" type="image/webp"  />
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/settings-400.jpg" type="image/jpeg" />
  <img src="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/settings-400.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

Let's go through all the options here so you'll have a better understanding of what they mean.

**The image customazation options** This dropdown menu is quite straightforward. You can choose to apply these settings for only this setup or to save them for all Pi future setups.

**Set hostname** A hostname is a label that will allow you to identify your Raspberry Pi in your local network. If this is your only Raspberry Pi, I would leave this as default but you can also change it to whatever you like. We will use this hostname later.

**Enable SSH** SSH or Secure Shell is a network protocol which gives you a safe access from one computer's terminal/command line to that of another. This is what will allow you to communicate with your Pi. Enable it and select "Use password authentication".

**Set username and password** Here you can choose the login credentials for your Raspberry Pi. Feel free to choose credentials you like and be sure not to forget them.

**Configure wireless LAN** If you want to use WLAN to connect to the internet, you can type your home Wi-Fi's SSID and password here. If you want to use a wired connection, you can keep this option disabled.

**Set locale settings** This will allow you to set the time zone and keyboard layout for your Pi.

**Play sound when finished** If you enable this, your computer will play a sound when the Imager has written the OS onto the SD card

**Eject media when finished** If you enable this, the SD card will be automatically ejected and you won't need to "Remove it safely"

**Enable telemetry** Enabling this will tell the Raspberry Pi foundation which OS version you installed so that they can measure which ones are the most popular options.

7. Click **write**. This can take several minutes.

8. When the Imager has finished writing the OS, install the SD card into the slot on the back of your Raspberry Pi:

<picture>
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/sd-slot-350.webp" type="image/webp"  />
  <source srcset="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/sd-slot-350.jpg" type="image/jpeg" />
  <img src="/images/posts/how-setup-raspberry-pi-without-monitor-april-2022-update/sd-slot-350.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

## Connecting with SSH (terminal access)

After you've inserted the SD card, connect the power plug and, unless you set up Wi-Fi on step 6, also connect an ethernet cable.

Open the terminal or command line on your computer and try the command below. Be sure to use the username and hostname you set up on step 6.

```bash
ssh username@hostname.local
```

When you first connect to your Pi, it will probably ask you about a fingerprint. Just type 'yes' and press Enter.

After this, you're prompted to write a password. Enter the password you set up on step 6 and press Enter. Note: The characters of your password won't appear in the terminal as you type them. This is a normal privacy precaution.

That's it. You're now logged in to the terminal of your Raspberry Pi. If you encountered an error, see the debugging section on the bottom of this blogpost.

## Connecting with VNC (desktop access)

Having access is often all we need. However, sometimes we want to use our Pis as if it was connected to a monitor. We can do this from an another computer using VNC. Let's set it up.

1. Connect to your Pi with SSH and run the following command:

```bash
sudo raspi-config
```

A blue-white configuration interface should appear.

2. Use up/down arrow keys and Enter to select **Interface Options**

3. Select the line that says **VNC** and hit Enter again to enable VNC.

4. Use left/right arrow keys to select **Finish** and hit Enter

#### Setting up a VNC client on your computer

1. Download, install and run [VNC Viewer](https://www.realvnc.com/en/connect/download/viewer/)

2. Select **New connection** from the File menu

3. In the VNC Server field, write the hostname of your Pi, e.g. raspberry.local

4. Click OK and double click on the connection icon with the hostname of your Pi on it

5. When prompted, enter the username and password of your Pi.

After a few seconds, you should see the desktop environment of your Pi.

## Debugging

If something didn't work, here are some possible solutions.

**'ssh' is not recognized as an internal or external command`** Your computer doesn't have SSH installed to it. If you know how to install it, feel free to do so. Otherwise, I'd strongly recommend installing a free SSH client called Putty. You can [download and install it from here](https://www.putty.org/).

When you open Putty 1) enter the hostname of your Pi 2) make sure Connection type is "SSH" 3) Click "Open" This will connect you to your Pi.

**ssh: connect to host hostname.local port 22: Connection timed out** It seems like your Pi is not connected to your home network. Try waiting a few minutes. Your Pi might still be waking up. If waiting doesn't help and you're using Wi-Fi, try writing the OS to your SD card again and be extra careful writing the SSID and password of your router.

**Permission denied, please try again** Make sure you used the exact same username and password here that you configured on step 6. If you still can't login, it's possible you made a typo during the configuration process. Try writing the OS to your SD card again and be extra careful writing the username and password.


How to set up a Raspberry Pi headlessly after April 2022 update. No monitor required


The Raspberry Pi foundation recently launched an update to the Raspberry Pi OS which changes how you need to setup your Pi for the first time. Until now, the Raspberry Pi OS has had a default user called "pi", which is no longer the case for fresh OS installs. Having a default username and password has caused some worry about potential brute-force attacks and some countries are introducing legislation to forbid any Internet-connected device from having default login credentials.

## Table of Contents

- [The New Setup](#the-new-setup)
  - [Raspberry Pi OS Lite](#using-raspberry-pi-os-lite)
- [Headless Setup](#headless-setup)
  - [Using the Official Imager](#using-the-official-imager)
  - [Using Third Party Imagers](#using-third-party-imagers)
- Updating to the Latest Version of Raspberry Pi OS

## The New Setup

Many people familiar with Raspberry Pis are also familiar with the setup wizard, which runs when you turn on your Pi for the first time. It helps you to configure localization settings, connect to Wi-Fi and install latest software updates. However, using the setup wizard has always been optional since it used to be possible to just press "Cancel" on the first page.

<picture>
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/setup-wizard.webp" type="image/webp"  />
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/setup-wizard.jpg" type="image/jpeg" />
  <img src="/images/posts/raspberry-pi-default-password-not-working-after-update/setup-wizard.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

From now on the wizard is no longer optional. This is because the default user "pi" no longer exists and a user must be created before the OS can be used. Once you've gone through the new setup wizard, everything will work just like before.

#### Using Raspberry Pi OS Lite

If you're using the Raspberry Pi OS Lite which doesn't come with a desktop environment. You will not see the setup wizard but you will still need to create a new user account. Thankfully, this is just as easy. During the setup process, you will be prompted to create a new account. The only difference is that the creation wizard looks more crude.

<picture>
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/lite-setup-400.webp" type="image/webp"  />
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/lite-setup-400.jpg" type="image/jpeg" />
  <img src="/images/posts/raspberry-pi-default-password-not-working-after-update/lite-setup-400.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

## Headless Setup

If you prefer to setup your Raspberry Pi headlessly, i.e without using a monitor, the above instructions won't work. You have two options to create a user headlessly: 1) Using the Raspberry Pi Imager 2) Adding a userconf.txt file to the boot partition of your SD card

#### Using the Official Imager

If you're using the official Raspberry Pi Imager, update to its latest version. After selecting a source image and your SD card, you can click on a new "Settings" button which has a familiar gear icon on it. This allows you to preconfigure a user to the OS image you're about to write onto your SD card. Once you've done this, the headless setup process works just like before.

<picture>
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/new-imager-400.webp" type="image/webp"  />
  <source srcset="/images/posts/raspberry-pi-default-password-not-working-after-update/new-imager-400.jpg" type="image/jpeg" />
  <img src="/images/posts/raspberry-pi-default-password-not-working-after-update/new-imager-400.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

#### Using Third Party Imagers

If you prefer to use a third party imager, like Balena Etcher, you will have to create a user by adding a configuration file to the boot partition of your SD card.

After writing the image to your SD card, open the SD card with your favourite file explorer and create a file called **userconf.txt**. This file should only have one line of text consisting of the username you want, followed by a colon, followed by your password in an encrypted form: **username:encrypted-password**

The easiest way to encrypt your password is to use OpenSSL which comes with any Raspberry Pi. You can also install it on any Windows, MacOS or Linux computer.

```bash
echo 'somepassword' | openssl passwd -6 -stdin
```

This will give you a string of what seems like random characters but it's actually an encrypted version of your password:

```bash
$6$3W.W.SfEPF3Q9O06$5ehg8sV1pon6rXcwYxUxhD4hrRicFYhruOc1iDEEa0VabH6QndYakRakZRXt.8c3KUyIutfaPCVMtbjyTlAsw1
```

Copy this string of text to the file you created like so:

```
myusername:$6$3W.W.SfEPF3Q9O06$5ehg8sV1pon6rXcwYxUxhD4hrRicFYhruOc1iDEEa0VabH6QndYakRakZRXt.8c3KUyIutfaPCVMtbjyTlAsw1
```

After this, all you need to do is to put your SD card into your Pi and you'll be up and running.

## Updating to the Latest Version of Raspberry Pi OS

For new installs using the official Imager, the app will automatically get the latest version and write it to your SD card.

For third party imagers, you can download the latest version from Raspberry Pi foundation's [download page](https://www.raspberrypi.com/software/)

If you want to update an existing image, run the following commands:

```bash
sudo apt update
sudo apt full-upgrade
```

That's it. I hope I saved you from some headache with setting up your Pi after most of the online tutorials have become outdated.


Raspberry Pi default username/password no longer automatically work with the a fresh install of the latest OS. Here's how to set up your Pi with the latest OS


There were no accurate universal time until quite recently and everybody had to figure out how they set their clocks. Many people considered clock towers or the timing of church bells ringing to tell the "real time" and set their clocks based on that time.

Of course, this wasn't very accurate but it didn't have to be. There was no reason to synchronize time accurately across long distances and it didn't really make a difference if your friend's clock was set 5 minutes ahead of yours.

This served adequately until the introduction of rail travel in Britain, which made it possible to travel fast enough over long distances to require continuous re-setting of timepieces as a train progressed in its daily run through several towns.

When the telegraph was invented in the mid 1800s, it now became possible to synchronize clocks across large distances by broadcasting the time over the telegraph. Greenwich Mean Time was developed and all clocks in Britain were set to this time baded on telegraph time broadcasts regardless of local solar noon.

Standard time was originally proposed by Scottish-Canadian Sir Sandford Fleming at a meeting of the Canadian Institute in Toronto on 8 February 1879. He suggested that 24 standard time zones could be used locally, but they were subordinate to his single world time, which he called Cosmic Time. This eventually became UTC time and time zones.

Later in the 1900s, we developed radio broadcast clock transmissions and finally in the 1980s, we developed NTP (network time protocol) which allowed computers to synchronize their times over the internet.


How did people synchronize time before modern technologies?


There is no universally agreed way that could be called the correct one for everyone. People come from different backgrounds and different learning methods work for different people.

If you're an experienced programmer who wants to pick up JavaScript, I'd just recommend taking a look at [Learn javascript in Y Minutes](https://learnxinyminutes.com/docs/javascript) which provides a quick look at the basic syntax. You should also know about [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web) since it's a great source for looking up how JavaScript things work.

Now, if you've never written a single line of code, your learning process should include understanding programming logic and not just the JavaScript way of doing things. In this case, I'd recommend first picking any source to learn HTML, CSS and JavaScript fundamentals. You can find bunch of free and cheap courses online on sites like Youtube, Udemy, Coursera, the Odin Project, freeCodeCamp, and W3Schools among many others (TIP: Udemy courses are practically ALWAYS on sale. If the course you're after is not on sale, wait a few days and it will be)

Once you're familiar with the basics, it's a good idea to avoid courses where you follow along someone else coding because this won't teach you how to think. Instead, it's better to learn how to figure things out yourself.

I recommend you to make you first simple website. Once your website works, learn to make it responsive. If you don't know what this means, figure it out using Google. A major part of programming is knowing how to figure things out and even very experienced programmers often need to use Google when they write code.

After making a responsive website, you'll have to make a decision on what you want to focus on first. With JavaScript, you can make websites, servers, desktop apps and mobile apps or a combination of them and your learning methods depend on what you want to make:

- If you want to make websites, learn a frontend framework like React, Vue, Angular or Svelte.
- If you want to make servers, learn about things like Node.js, Express, networks, REST and databases.
- If you want to make mobile apps, learn e.g. React Native
- If you want to make desktop apps, learn about Electron for example.

Now, the way I'd recommend you to learn is by working on a practice project. Decide what you want to be able to make, make a list of all the different things you need to learn to be able to do it and start learning them one by one.

After some time, you'll have a finished project. It will be written so poorly you'll barely understand the code yourself after you're done, and it will probably work only when you use it and someone else will be able to break it because of some mistake you didn't notice.

This is okay, though. You made a bad app but you learned a lot in the process. The next app you'll make will be better and by the time you're done with a few apps, you'll be able to make decent apps and it will take you significantly less time to do so and you will gain confidence. This is when programming becomes fun.

If you get stuck and really can't figure out how to make something work, send me a message and I'll try to help. I don't have time to teach anyone to code but I'd be glad to nudge you in the right direction if you need it.

Lastly, I'll give you little extra tip for planning projects which I learned the hard way: Plan your app in advance. Figure out what are the most important features the app needs to have so that it contains the necessary parts and nothing extra. Once the app is up and running, you can add more features to it but you will already have a usable app by that point. I have given up on a lot of projects after wasting a lot of time on them just because I kept adding more and more things to them and eventually felt like they were never going to be done.

Say you're making Reddit. Make an app that allows people to make text posts and comment them. Forget pictures, videos, upvotes, subreddits, user-to-user messaging, premium subscription models and all the other extras. Finish the app first and add the nice to have features later.


What is the correct way of learning JavaScript? How and where can I learn the fundamentals of JS?


70 000 years ago our ancestors were insignificant animals minding their own business in the Eastern parts of Africa. Today we rule the world. When we think about it, it's common to wonder what is so different between us and other animals as individuals. We want to believe that there's something special about us, that something in our bodies or brain makes us more advanced than other animals. In reality, as individuals, we really not that far from chimpanzees.

If we took a human and a chimpanzee in to a desert island, the chimpanzee would have a much better chance to survive. The difference between humans and other animals is not on the individual level but on a collective level. We rule the world because we are the only species of animals that can work together flexibly and in large groups.

Bees and ants can work together in large groups but their cooperation is not very flexible. The beehive can only work in a certain way. The worker bees can't decide to execute the queen and turn the hive into a democracy. Chimpanzees, wolves and dolphins can cooperate flexibly but only in small groups because their cooperation is based on knowing their companions. A chimp won't work together with an another chimp if he doesn't know the other one is a good and trustworthy chimp.

Humans are the only species that can combine the two. A human loses a fight to a chimp but 1000 chimps don't have a chance against 1000 humans because that many chimps can't work together. All major human achievements have always been the result of flexible cooperation of large groups of people.

Let's think about this blogpost you're reading. I don't personally know any of the people who invented and built the computer I'm using to write this text. I am publishing this text on my website which is hosted on a server maintained by people I have never met. I likely won't know many of the people who will read this text. I don't know Yuval Noah Harar, the Israeli historian whose book this answer is heavily based on. Even though I don't know any of these people, I can work together with them and make things happen on a global scale.

We can work together flexibly in large groups because we can create imaginary stories and believe in them. For example, almost all laws are based on the belief that humans have rights. Yet, all our rights are just a invented by people. If we do a biopsy to a human, we'll find a lot of things but none of them will be human rights. This is because our rights only exist in the stories we have made up from thin air.

To earn a living, we go to work and get salary. However, money doesn't have objective value. We can't eat or drink it wear ir when we get cold. The value of money is based on nothing but the peoples' beliefs but thay belief works. I can grab a bank note, go to a store and give the note to a stranger and they will give me food I can actually eat to keep myself alive.

People rule the world because we're the only species that can work together in large groups and create imaginary stories that we collectively believe in.

Source: Harari, Yuval N. 2015. Sapiens: a brief history of humankind. New York: Harper


Why do humans rule the world?


Physicists don't actually learn equations by heart. They understand how things are related to each other and the equations can be deducted from these relationships.

Most physics education puts too much emphasis on learning equations and laws by heart. I remember how some of my classmates in high school frantically looked for an example in the book that looked like the problem they were trying to solve without even trying to understand what the problem was all about. As a preparation for exams, they meticuloysly tried to memorize the examples so that they could use the same methods in the exam.

Physics is not about memorizing examples, laws or equations. How on earth would we find example solutions for physics problems that are yet to be solved?

Instead of memorizing everything, Physics education should focus on concepts. When you understand the concepts and how they are related to each other, the equations no longer look like complicated combinations of letters and, when you look at them, you will start to recognize patterns and how things affect each other. The solution of a physics problem can even usually be roughly estimated without writing a single equation.

Physics is all about problem solving and that’s also the most important and difficult part. Once you understand a problem, the solution is usually relatively easy to find.

Here’s an example of a chain of thoughts that could be part of solving a high school physics problem:

What area of Physics is the problem about? Mechanics. Is is about forces or movement? Forces as well as the movement they cause. Which forces affect it? Gravity and buoyancy. Are the forces equal? No, gravity is stronger. What does that mean? The object is steadily accelerating to the direction of gravity. Now we know what the problem is about and the solution can be found with a simple calculation.


How do great physicists remember all the equations and formuals?


## Learn to Eat the Frog

The frog here is related to a time management technique described in Brian Tracy's book _Eat the Frog! Get more important things done today._

I tried the technique in the beginning of my studies and it made my life signigicantly better. The basic idea behind the technique is that, when you have something you need to do, you do it immediately, and when you have multiple things to do, you start with the one you're dreading the most.

So, whenever I got an assignment from school, I finished it by the end of the same day, even if the deadline was a week away. I did't allow myself to browse the internet or do anything else I like to do before I had finished what I needed to do.

Using the technique felt very frustrating at first since it would have been so much nicer to just procrastinate and worry about the assignments later. However, I soon noticed that the technique wiped away all stress about deadlines. It also increased the quality of my work which showed in my grades. Even further, I actually had more free time than I did before and I was able to enjoy it more because I didn't feel guilty about procrastinating.

## Invest Your Time Learning the Fundamentals

Regardless of what you're studying, the beginning of your studies will most likely consist of theoretical studies about the fundamentals of your field of study. This may feel boring and frustrating if you're the type of person who likes more hands on learning. However, investing your time really learning the fundamentals is crucial, as they are very important and often absolutely essential things to know when you start practical training. Learning the fundamentals properly will make your own life a lot easier.

## Teach Other People

If you decide to start eating the frog, you’ll likely find that you’ve had time to learn all the things related to the assignments even before your classmates start learning them. If you notice a classmate having trouble understanding, help them. When you teach something to other people, you need to think of ways to first simplify the topic or come up with parables that could help them understand it. So you have to think about the topic more deeply which will improve your understanding. Teaching is one of the best ways to learn for yourself.


My best advice for people starting their university studies


We all need sleep and our bodies will surely show that to us if we stay awake for too long, but what is it that actually makes us feel sleepy? Well, I recently read an amazing book about sleep and discovered the answer to this question.

The level of a one's sleepiness depends on the time of day in relation to the their internal clock and sleep pressure.

The internal clock controls our physiological circadian rhythm in many ways. For example, it controls how much melatonin and orexin are released into our bodies. Melatonin is a chemical that helps us fall asleep and orexin is a chemical that helps us wake up.

The circadian rhythm is naturally synchronized, based on the amount of ambient light, in such a way that the middle point of sleep usually takes place at around 4 am. Although the rhythm can adapt to changes when we travel to different time zones, it can only adapt about 15 minutes per day which is why we experience jet lag.

Even more than the circadian rhythm, sleepiness is based on the so called sleep pressure. When we're awake, our bodies produce a chemical called adenosine. The longer we stay awake and the more time our bodies have to keep producing more adenosine, the more it slowly builds up in our bodies. The more adenosine we have in our bodies, the sleepier we feel.

The effect of caffeine is actually based on removing or dampening the effect of adenosine. Caffeine prevents adenosine receptors in our body from detecting adenosine and thus alleviates sleep pressure. However, caffeine does not remove adenosine from our body which leads to a strong sleep pressure once caffeine is no longer affecting us.

#### Source

Walker, Matthew P. Why we sleep. New York: Scribner, 2017. [Why We Sleep - Wikipedia](https://en.wikipedia.org/wiki/Why_We_Sleep).

_Walker is the professor of neuroscience and psychology and a sleep researcher in the university of Berkeley in California, USA._

#### Learn more about sleep

[Sleep is your superpower - Matt Walker](https://youtu.be/5MuIMqhT8DM) (TED talk, 20min)

[Matthew Walker on the Joe Rogan Experience](https://youtu.be/pwaWilO_Pig) (Podcast, 2h)


Why do we feel sleepy?


## Analog Networks and Phone Calls (0G-1G)

The first cellular network (MTA, Mobiltelefonisystem A) was introduces in Sweden in 1956. In practice, the phones were so large that they were really only installed into cars but the cell towers still communicated wirelessly with these car phones. Although it was possible to move around within the range of the cell tower, the connection was lost if the phone needed to connect to a different tower. The network had approximately 125 users in Stockholm and Gothenburg.

The so called first generation cellular networks (1G) transferred sound as an analogue signal using a modulated carry wave. For example, if we wanted to send a simple 100 Hz wave, we could combine it with a considerably higher frequency 850 MHz carry wave. Combining the waves was done with amplitude modulation (AM) or frequency modulation (FM).

When using amplitude modulation, the amplitude of the carry wave is changed based on the transferred data. Frequency modulation is similar but we change the frequency of the carry wave instead.

<img src="/images/posts/how-cellular-networks-like-5g-4g-are-different/AM_FM.gif" alt="Animation of modulation types" />

Connecting phone calls with this technology required a specific frequency band which is defined by the lowest and highest used frequencies. If someone is on the phone on some frequency band, everyone else has to use a different band or the the signals could interfere with each other. The more frequencies a cell tower uses, the more people can make phone calls simultaneously. This is called bandwidth.

As the amount of users rose, the network was constantly put under a test. One option to fix the issue could be introducing more frequency bands to widen the bandwidth but this approach is problematic. All radio and TV stations, military systems, GPS and other systems utilizing electromagnetic waves need their own frequency bands which makes it extremely expensive for network providers to reserve new frequency bands for cell towers. Yet, network providers have used this approach at every stage of the development of the network

However, over the years, a lot of work has also been done to ensure that as much data as possible can be transmitted in each frequency band. The simples approach is to build more cell towers. Instead of using a single powerful tower to cover entire cities, multiple less powerful towers can be used. This makes it possible to use the same frequency bands for different users because the signal of these lower powered cell towers won’t reach far enough to interfere with each other.

This made it possible to increase the amount of users but the speed of data transfer still remained low. The best 1G networks were able to transmit data at the speed of 2,4 kbps.

## Digital Networks and Text Messaging (2G)

The 2G network was eventually developed and it took full advantage of the digital system and ushered in the actual era of mobile phones, replacing the era of car phones. If you’re my age or older, the 2G era is likely when you got your first mobile phone. My first phone was the magnificent Nokia 5110. It sure allowed me to make phone calls but it also came with a completely new way of communication, text messaging.

<img src="/images/posts/how-cellular-networks-like-5g-4g-are-different/nokia_5110.jpg" alt="Nokia 5110 mobile phone" />

When 2G was introduced, it was able to transmit data at the speed of 9.6 kbps and text messaging worked smoothly. Before 3G, the speed of 2G was already 200 kbps, thanks to a new technology called GPRS (General Packet Radio Switching) which is sometimes referred to as 2.5G.

## Wireless internet (3G)

The next generation of mobile networks, 3G, further utilized new frequency bands. It’s been estimated that European network providers spent more than 100 billion euros during this time period to reserve new frequencies for their networks.

Additionally, 3G made very efficient use of packet switching technology that GPRS had previously utilized. It allowed thousands of people use the same frequency bands more efficiently by splitting the data into small data packets that could be sent via different frequency bands as small chunks. Instead of having to wait for a frequency band to become completely vacant, it was now possible to send small chunks of data whenever a frequency band had any space on it. This made data transfer speeds much larger and allowed more concurrent users to use the network.

In 2005, yet another new technology, HSPA (High Speed Packet Access) was introduced. You may have seen H+ text on your phone, indicating that using this technology HSPA. This technology is sometimes called 3.5G and it already allowed a speed of 42 Mbps (42 000 kbps).

## High Definition Streaming (4G)

The next generation brought along yet another new technology, LTE (Long Term Evolution), which utilized new 700 MHz frequency bands that were previously used by analog TV broadcasts. In addition, a new technology, OFDM (Orthogonal Frequency Division Multiplexing), was introduced to transmit even more data in a single frequency range using some sort of black magic (math that goes way beyond my engineering degree).

When you really think about it, isn’t it absolutely amazing that we can stream HD videos with our phones without a single cable. Yet, the quality of these videos keeps getting better while simultaneously more and more devices from televisions to industrial robots are connected into the wireless internet. Even the current technologies don’t seem to be able to transmit enough data and network providers are forced to start using frequency bands nobody wants to use: high frequency millimeter waves.

## Internet of Things (5G)

Nobody has previously wanted to use high frequency millimeter waves on the cellphone networks because they are very poor at penetrating pretty much anything including things like rain. This is why network providers have to build and install a large number of new cell towers which seems scary to many consumers.

Adding more towers helps with congestion of frequency bands but 5G also utilizes a new technology called massive MIMO (multiple-input, multiple-output). It allows sending signals directly towards the receiver a bit like a light beam instead of sending it everywhere. 5G will allow us to reach speeds of up to 1000 Mbps (1 000 000 kbps).

5G will increase the speed of data transfer and minimize congestion on the networks. This is essential for new technologies like self driving cars and internet of things.

### Finally: 5G is not dangerous

At the extreme end of electromagnetic radiation is gamma radiation, which has a huge frequency. Larger frequency means more energy and gamma radiation is known for causing cancer. Even a bit lower frequency radiation can cause radiation if it’s ionizing meaning it has enough energy to rip electrons off of our cells.

However, the frequencies 5G utilizes are nowhere near ionizing. In fact, the frequencies are lower than the frequency of normal visible light. So, before you start worrying about 5G radiation, you should probably worry about ceiling lamps that are everywhere around us because they are emitting radiation with an even higher frequency than that of 5G networks!


What's the difference between different cellular networks like 4G and 5G?


Many things we've been taught at school are simplified to make them easier to understand. In reality, electrons don't orbit the nucleus like planets orbit the sun:

<picture>
  <source srcset="/images/posts/atoms-empty-space-why-things-look-feel-solid/atom.webp" type="image/webp"  />
  <source srcset="/images/posts/atoms-empty-space-why-things-look-feel-solid/atom.jpg" type="image/jpeg" />
  <img src="/images/posts/atoms-empty-space-why-things-look-feel-solid/atom.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy"/>
</picture>

It's better to think of electrons as a flock of insects where you can't distinguish a single insect but you can see the entire flock.

<picture>
  <source srcset="/images/posts/atoms-empty-space-why-things-look-feel-solid/electronCloud.webp" type="image/webp"  />
  <source srcset="/images/posts/atoms-empty-space-why-things-look-feel-solid/electronCloud.jpg" type="image/jpeg" />
  <img src="/images/posts/atoms-empty-space-why-things-look-feel-solid/electronCloud.jpg" alt="Portrait" style="max-width: calc(100vw - 4em)" loading="lazy" />
</picture>

The paths of different electrons vary. Some move faster and some slower. The path of each electron remains mostly the same but can sometimes change as long as no electron moves on the same path as an another one. According to [Pauli exclusion principle](https://en.wikipedia.org/wiki/Pauli_exclusion_principle), two or more identical fermions cannot occupy the same quantum state within a quantum system simultaneously or, simplified in layman's terms, electrons can't "move on the same path".

Even though electrons move indefinitely, they need energy to move to a higher energy path. Respectively, an electron releases energy when it moves to a lower energy path. For example, when an electron is hit with light, it might move to a higher energy path.

Now, if we shine light on a table, the light won't reach very far because the electrons "like" to take their part of the light's energy. This energy is almost instantly released and we see this as light reflecting from the table. This is why things look solid.

If you decide to touch the table with your hand, the electrons on your hand move very close to the electrons of the table. When the electrons of an atom move close to an another atom, the electrons' paths change. This is because the electrons can't move on the same path next to each other. Thus, the electrons of the atoms must move to a higher energy path. This requires energy which doesn't come from light but the force used to move the atoms closer.

Moving two atoms close to each other requires energy since the electrons need to "make space" by moving to higher energy paths. In the case of a hand and a table, there is a massive amount of atoms and pushing them close to each other requires enough energy to stop our hand. This is why things feel solid.


If atoms are mostly empty space, why do things look and feel solid?


We all know that the electricity in the regular outlets of our homes easily enough to be fatal. Yet, birds have no problem sitting on power lines that carry electricity at a 1000 times higher voltages. How is this possible?

Firstly, this is difficult topic to explain. Personally, I only really understood it two years into my electrical automation engineering studies, so if you don't have a solid understanding of how electricity works, try not to rush through this post and take your time instead. I'll do my best to explain everything in layman's terms.

Electric current describes the amount of electrons flowing through a point in space. If you compare electricity to a river, electric current is like the water current or, in other words, the speed of the flowing water.

When we want to move electrons, we need a path from high potential to low potential. This potential difference is called voltage. If we use the river analogy again, voltage is like the height difference between an upper and lower reach of the river. The higher the upper reach is compared to the lower reach, the more water flows. Similarly, a higher voltage, will cause a higher electric current.

Now, it's important to realize that high potential alone doesn't make electrons move. If there's a dam in a river, water won't flow no matter how high the water level is. Just like water in a river, electricity needs a path to flow through.

When a bird sits on a power line, its entire body is in the same, very high potential as the power line. However, since the bird doesn't touch anything else, the electricity doesn't have a path to a lower potential through the bird, so the bird is fine. If the bird were able to connect two separate lines, or a line and the ground, with its body, the electricity would flow through its body which would probably instantly vaporize.

That's why birds can safely sit on power lines. If I failed to explain this topic clear enough, don't hesitate to send me a follow up question on social media.


How can birds safely sit on power lines?


If you have a static Next.js website, you might think there's no way for you to create a notification system for new content since you don't have your own backend server. Luckily, this is not true. Creating an RSS feed for your content allows your users to use any of the free RSS subscription services to subscribe to your content and get notifications for each new post by email or even push notifications.

In this tutorial, I'm going to explain how you can set up your static Next.js website to automatically generate an RSS feed after each build.

## What we need to do

Here are the steps we need to take to generate an RSS feed with Next.js:

1. **Get all the data for the content.** Whether you store your content in a database, text files in your git repository or some other place, we need to have access to them with our post build script.
2. **Convert the content into XML.** Your content most likely is not stored as RSS-valid XML, so we need to process it.
3. **Write the RSS feed into an XML file.** After you have processed your content into XML, you need to write it into a file which will ship with your code.
4. **Make the script run after each build.** To do all the above steps automatically, we need to make our code run automatically whenever we build our website.

## Getting the data

Let's create a new file for the script. I decided to put my code to `<root>/utils/generateRss.js` when I added an RSS feed for this website.

The exact way to get your content depends on where you store it. Wherever your content is, the goal here is to get the title, URL, date and description for each item you plan to add into your RSS script. In my case, I write blog posts in markdown files in a `/posts` directory and here's how I get all the necessary data for my posts:

```javascript
const fs = require('fs');
const path = require('path');
const matter = require('gray-matter');

const getAllPosts = () => {
  // Read the posts directory and get blog posts' filenames
  const filenames = fs.readdirSync(path.join('posts'));

  // Go through all filenames
  const posts = filenames.map((filename) => {
    // Full path to the file from project root
    const filepath = path.join('posts', filename);
    // Read the content of the file
    const markdownWithMeta = fs.readFileSync(filepath, 'utf-8');
    // Get all data from the frontmatter
    const { data } = matter(markdownWithMeta);
    // Return everything we need for the RSS feed
    return {
      title: data.title,
      date: data.date,
      excerpt: data.excerpt,
      link: 'https://joonasjokinen.fi/blog/' + filename.replace('.md', ''),
    };
  });
  // Sort the blogposts by date
  return posts.sort((a, b) => new Date(b.date) - new Date(a.date));
};
```

Since your code will probably look a lot different, I won't be going through the above code in detail but I commented everything hoping it's easy to understand.

## Converting to XML

Once we've got the data, it's time to start processing it into XML for the RSS feed. I created a function which receives the blog posts as a parameter and maps each of them into an XML item.

```javascript
const getXmlItems = (blogPosts) => {
  return blogPosts
    .map((post) => {
      return `<item>
            <title>${post.title}</title>
            <link>${post.link}</link>
            <guid>${post.link}</guid>
            <pubDate>${new Date(post.date).toUTCString()}</pubDate>
            <description>${post.excerpt}</description>
            <dc:creator>Joonas Jokinen</dc:creator>
        </item>
        `;
    })
    .join(''); // Join the array of items into a single long string
};
```

The above code should be quite straightforward. We take the `blogPosts` array and map each post to a string containing an XML item about the post. If the XML syntax is completely new to you, the w3 schools [documentation](https://www.w3schools.com/xml/xml_rss.asp) is my favorite resource for understanding it. In short, here's a summary about the tags I used:

- **item:** A piece of content like a blog post, podcast episode or a video
- **title:** The title of the item.
- **link:** The URL leading to the item.
- **guid:** A unique identifier for the item. I used the URL for the post here but you can also use some other kind of identifier.
- **pubDate:** The publication date of the item. Should be in RFC 822 compliant format, which can be achieved with the `.toUTCString()` method of JavaScript dates.
- **description:** A phrase or sentence that describes the item.
- **dc:creator:** The author of the item. I hard coded my name here because I'm the only person writing for my blog.

We're now able to get the XML for all the pieces of content but we still need to write some "global" XML which describes the entire feed:

```javascript
const getRssXml = (xmlItems, latestPostDate) => {
  return `<?xml version="1.0" ?>
  <rss
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:content="http://purl.org/rss/1.0/modules/content/"
    xmlns:atom="http://www.w3.org/2005/Atom"
    version="2.0"
  >
    <channel>
        <title>Joonas Jokinen's blog</title>
        <link>https://joonasjokinen.fi</link>
        <description>The blog of an engineer with a childlike curiosity focusing mostly on web development and occasionally random interesting facts></description>
        <language>en</language>
        <lastBuildDate>${new Date(latestPostDate).toUTCString()}</lastBuildDate>
        ${xmlItems}
    </channel>
  </rss>`;
};
```

Here, I just hard coded most of the XML since I know it's unlikely to change any time soon. I got the `latestPostDate` by grabbing the `date` parameter of first element of `postData` (which is sorted by date).

I also placed the previously processed `xmlItems` after all the other tags.

The names of the XML tags here are also mostly self evident but here's a brief summary of what they mean:

- **title:** The title of the entire RSS feed
- **link:** The URL of the main page of the content
- **description:** A phrase or sentence that describes the feed.
- **language:** The language code, e.g. en, es, or fi
- **lastBuildDate** The last time there changes happened to the feed, e.g. a new blog post was published

## Writing the file

We've now made three functions that 1) Get all the data for each post 2) process the blog post data into XML items and 3) combine the items into a complete XML string. It's now time to call those functions and write the resulting XML into a file:

```javascript
const postData = getAllPosts();
const xmlItems = getXmlItems(postData);
const rssXml = getRssXml(xmlItems, postData[0].date);

fs.writeFile(path.join('public', 'rss.xml'), rssXml, (err) => {
  if (err) {
    console.log(err);
  } else {
    console.log('RSS feed written successfully');
  }
});
```

Here's I use the `fs` module to write a `rss.xml` file to `<root>/public/` which will then be shipped together with our app. It's time to test it. Let's add a post build script to our website's `package.json`:

```json
...
"postbuild": "node ./utils/generateRss.js",
...
```

Calling a script "postbuild" will make it automatically run after "build" has ran. So let's try it:

```bash
npm run build
```

It seemed to work since we got "RSS feed written succesfully" and a file called `rss.xml` appeared in `/public`. Now, to make sure the file is a valid RSS feed, we can copy and paste its contents to [W3 Schools Feed Validation Service](https://validator.w3.org/feed/#validate_by_input).

If everything worked as expected, the validator should congratulate you for having a valid RSS feed.

There you have it. Next time you publish your code, the RSS feed should now become accessible at `yourdomain.com/rss.xml`.


How to generate an RSS feed for static Next.js website?


If you have done any web development, you have probably used a ton of npm packages. In this tutorial, I will teach how you can create one of your own and publish it for other people to use. I will explain everything you need to do to publish your first package.

## Table of Contents

1. [Writing the Code](#writing-the-code)
2. [Handling Errors](#handling-errors)
3. [Local Testing](#local-testing)
4. [Preparing for publishing](#preparing-for-publishing)

## Writing the Code

There's no way for me to know what the package you're going to publish will do, so I won't be talking about what the code inside the package does. I will only be going through the requirements.

There are really two main types of npm packages; Those that allow users to import something they can use in their project and those that are used from the command line (or the script tag in `package.json`)

Make a directory for your project and run `npm init` to set it up for npm. The `main` parameter in `package.json` defines the entry point file in your app (`index.js` by default). This is where you will write your code. You can create other files too, of course, but all the code you plan to ship to the end users needs to be exported or executed in the entry point file. In a complex project, you can write all your code in other files and simply import them into the entry point file.

Let's look at a simplified example of how the entry point file could look like:

```javascript
const { someFunction, otherFunction } = require('./utils');

const defaultFunction = (params) => {
  const value = someFunction(params.someParam);
  return otherFunction(value);
};

const namedFunction1 = (params) => {
  // some code here
};

const namedFunction2 = (params) => {
  // some code here
};

const myModule = (module.exports = defaultFunction);
myModule.namedFunction1 = namedFunction1;
myModule.namedFunction2 = namedFunction2;
```

Now, the end user could import our functions like so:

```javascript
import defaultFunction from 'my-module';
import { namedFunction1, namedFunction2 } from 'my-module';
```

If we're making a package that should be used from the command line, we don't have to export anything:

```javascript
#!/usr/bin/env node

const { handleutilityFunction, someAsyncFunction } = require('./utils');

(async () => {
  const config = handleCMDArguments();
  const someValue = utilityFunction(config);
  const asyncResult = await someAsyncFunction(someValue);
})();
```

The first line in the example is very important. It's called a [shebang line](<https://en.wikipedia.org/wiki/Shebang_(Unix)>) and it tells Unix-like platforms that this file should be executed with node. Windows ignores this line and uses the filename extension instead.

If you find the use of parentheses in the example confusing, look into _immediately invoked functions in JavaScript_. They are not required for many CLI packages to work but it's a handy way to use async/await without having to write a named function only to immediately call it like so:

```javascript
#!/usr/bin/env node

const { handleutilityFunction, someAsyncFunction } = require('./utils');

const mainFunction = async () => {
  const config = handleCMDArguments();
  const someValue = utilityFunction(config);
  const asyncResult = await someAsyncFunction(someValue);
};
mainFunction();
```

Now, for our end user to be able to run our code from the command line, we need to add a "bin" parameter into our `package.json`.

```json
"bin": {
    "my-module": "index.js",
  },
```

This would allow the end user to run our index.js file from the command line like so:

```bash
myModule
```

Or by adding the following script in their `package.json`

```json
"scripts": {
    "some-command": "my-module"
  },
```

## Handling Errors

If you're going to put your code online for other people to use, you should aim to make it unbreakable and add descriptive error messages that help users understand what they are doing wrong. For example, if your function expects a certain parameter to be a `string`, check for it's type and handle situations when the user provides a non-string parameter:

```javascript
const getFirstAndLastCharacters = (str) => {
  if (typeof str !== 'string') {
    console.error(
      `[myModule]: myFunction expected a string but it got "${typeof str}"`
    );
    return;
  }
  const first = str.charAt(0);
  const last = str.charAt(str.length - 1);
  return { first, last };
};
```

It's a lot easier for the end user to understand what they did wrong if they get an error message like this:

```bash
[myModule]: myFunction expected a string but it got "number"
```

Instead of something like this:

```bash
TypeError: str.charAt is not a function
```

## Local Testing

To test how our package behaves as it's installed and used by a user, we can package our code locally using `npm pack` which will create a tarball in the root of your project directory. It should have a filename similar to `my-module-1.0.0.tgz`

Now we need to create a test project. The type of project you need for testing depends highly on the type of package you're creating, so I won't be going into a lot of detail. Whatever your test project may look like, you need to reference the tarball you just created in package.json:

```json
"dependencies": {
    "my-module": "../my-module/my-module-1.0.0.tgz"
  }
```

And then install it like a normal npm package:

```bash
npm install
```

If your package doesn't work as you expect, fix the error in your code, run `npm pack` again, and reinstall the package to your test project. You may need to delete the directory from node_modules:

```bash
rm -rf ./node_modules/my-module
```

Once you've tested your package and found that it works as expected and properly handles all possible user errors, it's time to prepare the package for publishing.

## Preparing for publishing

Every good project needs proper documentation, so be sure to write a good README file. You can take a look at some popular packages for reference. Usually a README file includes at least an introduction, installation and usage instructions, contributing instructions and a license. [Yes, you really should license your code!](https://choosealicense.com/no-permission/)

Next, you need to [create an npm account](https://www.npmjs.com/signup) if you don't have one already and login:

```bash
npm login
```

Follow the prompts and until you get a message similar to this:

```bash
Logged in as yourUsername on https://registry.npmjs.org/.
```

We're almost ready to publish but we still need to modify our `package.json` with some useful information. You can take a look at the [npm documentation](https://docs.npmjs.com/cli/v7/configuring-npm/package-json) for more fields but here are the most important ones I believe every package should have:

```json
{
  "name": "my-awesome-package",
  "version": "0.0.1",
  "description": "Does awesome things",
  "license": "MIT",
  "repository": "username/name-of-repository",
  "main": "index.js",
  "keywords": ["awesomeness", "otherkeyword"]
}
```

- name: The official name of your package.
- version: Version number. I like to keep it as 0.0.1 until I publish the first version.
- description: A short but informative description of your package.
- license: Abbreviation of your license. See npm documentation for more information.
- repository: The URL of your git repository, can also be provided as username/repository for GitHub repositories.
- main: The entry point file to your package
- keywords: A list of keywords that will help your package be discovered in npm search.

When you're ready to publish, run the following command to set the version number to `1.0.0`, the first major release of your package.

```bash
npm version major

Output: v1.0.0
```

You can then publish your package with the following command:

```bash
npm publish

Output: + my-awesome-package@1.0.0
```

That's it! Your package is now on the npm registry and it's available for anyone to use!


How to make and publish your own npm package?


While React apps are nice and snappy, their initial page load time is usually not good. This negatively impacts user experience, especially for users who use a slower internet connection. Slower page loading increases the chance of the user leaving your app. Website performance is also among the top factors search engines use to decide which websites they show in their search results.

In this tutorial, we will be using [compress-create-react-app](https://www.npmjs.com/package/compress-create-react-app) to significantly reduce the size of our website. This tutorial works for apps built with [create-react-app](https://reactjs.org/docs/create-a-new-react-app.html). The examples will use a Node/Express backend.

## Prerequisites

1. This is not a programming tutorial. I will only be focusing on the compression and **you need to know how to make the React app yourself.**
2. To use compression, you need to tell your server to serve the compressed files to the visitors. **If you can't access the server, you can't use compression.**

## What is Compression?

Compression algorithms condense make the website files a server sends to the client smaller. There are many different compression algorithms but they all work by finding repeating text within a document and replacing them with temporary strings with the same placeholder. The most efficient algorithm at the time of writing this tutorial is called **Brotli**. However, it is not supported by all browsers so we will be using an another algorithm called **gzip** as well as Brotli. We will then set up our server to send files compressed with Brotli when the client's browser supports it and gzip when Brotli is not supported.

## Using post-build compression

Due to the way create-react-apps work, the easiest way to set up compression is by using post-build compression which will automatically compress our build files after we build our app. Fortunately, an npm package called compress-create-react-app makes this easy.

Let's first install the package as a developer dependency:

```bash
npm install compress-create-react-app --save-dev
```

All we need to do to use the package is to modify our build script in `package.json`:

```diff
  "scripts": {
    "start": "react-scripts start",
-   "build": "react-scripts build",
+   "build": "react-scripts build && compress-cra",
    "test": "react-scripts test",
    "eject": "react-scripts eject"
  }
```

Now we can build our app just like we normally would:

```bash
npm run build
```

This will compress your build and create .br and .gz files into your build folder.

## Serving compressed files

The exact way our server needs to be set up to serve the compressed files depends on how you've configured your server. For Express servers, there's a nice package called [express-static-gzip](https://www.npmjs.com/package/express-static-gzip) which will do all the difficult parts for us.

Install the package

```bash
npm i express-static-gzip
```

Edit your main server file:

```javascript
const express = require('express');
const path = require('path');
const app = express();
const PORT = process.env.PORT || 5000;
const expressStaticGzip = require('express-static-gzip'); // Require the package

app.use(express.json({ extended: false }));

// Normal API paths
app.use('/api/example1', require('./routes/example1'));
app.use('/api/example2', require('./routes/example2'));

// Serve the build files
const buildPath = path.join(__dirname, '..', 'build');
app.use(
  '/',
  expressStaticGzip(buildPath, {
    enableBrotli: true, // Tell express-static-gzip to use brotli when the client supports it
    orderPreference: ['br', 'gz'],
  })
);

// Fallback to index.html when something that doesn't exist is requested
app.get('/*', (req, res) => {
  res.sendFile(path.join(__dirname, '..', 'build', 'index.html'), (err) => {
    if (err) {
      res.status(500).send(err);
    }
  });
});

app.listen(PORT, () => console.log(`Server started on port ${PORT}`));
```

That's it. Your app is now serving compressed files. Let me know if you have trouble making compression work for your app or if this tutorial helped you by contacting me through the social links on the bottom of the page.


Latest posts

How to set up a Raspberry Pi headlessly after April 2022 update. No monitor required

Read more

Raspberry Pi default username/password no longer automatically work with the a fresh install of the latest OS. Here's how to set up your Pi with the latest OS

Read more

How did people synchronize time before modern technologies?

Read more

What is the correct way of learning JavaScript? How and where can I learn the fundamentals of JS?

Read more

Why do humans rule the world?

Read more

How do great physicists remember all the equations and formuals?

Read more

My best advice for people starting their university studies

Read more

Why do we feel sleepy?

Read more