s/Netbook/Chromebook/
Tags: chromebook, chromeos, linux, education
Published: 2021-12-04 18:44:26

---
title: s/Netbook/Chromebook/
description: How my view of Chromebooks did a 180.
published: true
tags: chromebook, chromeos, linux, education
cover_image: https://images.unsplash.com/photo-1526665814499-fbdb4394ef3e?auto=format&fit=crop&w=900
---

Cross-posted on my personal blog: https://guy.sh/posts/chromebook

## Background

I recently purchased the Lenovo Chromebook 3 for _very_ cheap -- just over $100 USD. The machine is small and lightweight at just shy of 2.5lbs. The keyboard is nothing superb, but quite good for the price. The display is probably the worst part about it, but perfectly fine for reading text -- even in _direct_ sunlight, due to the matte finish.

Specs-wise, it sports an AMD A6 A9220C processor, 4gb of RAM, and 32gb of eMMC storage. By today's standards, very measly specs, indeed!

So why did I want such a low-powered machine?

### An Old Netbook and a Dream

About a decade ago, my main university computer was an Acer netbook running Linux. Equipped with an Intel Atom CPU and 2gb of RAM (which I proudly upgraded to 4gb), it was a severely underpowered machine. On top of that, it had an odd display resolution (1024x700), the fans ran near-constant, and the 9-cell battery I bought for it weighed as much as the machine.

**I absolutely adored it.**

Besides extreme portability, the wonderful thing about that machine was having to consider every drop of resource usage. Much in the same way artistic restrictions spark creativity, I had to learn and understand how a lot of my system worked.

I couldn't just throw computing resources at the problem and call it a day... simply because that machine didn't have them.

For example, I became very comfortable with the CLI.
Even now, it's hard for me to use a system that doesn't offer those tools. A text editor *must* have decent Vim bindings for me to consider it as a primary editor (most of the time, I use Vim or Neovim, anyway).

Even on more powerful hardware, these are tools and skills that I still use every day. I even give a lot of credit to that netbook as to why I work at Red Hat.

### Netbooks are Extinct(?)

A product of their time, netbooks died a fairly quick death. I believe their time in the sun only lasted a span of 3-5 years, conveniently coinciding with my studies.

They were followed by shrinking full-sized laptops and more powerful mobile devices. The middle-ground that netbooks once filled is now a sea of overlapping options from both categories.

However, as traditional laptops have shrunk and mobile devices' capabilities skyrocketed, both have dramatically gone up in price. A "flagship" smartphone these days frequently toes the $1k USD mark. A modest-but-small laptop can run about the same. For reference, my beloved netbook cost less than $250 (in 2010).

Beyond price and creative restrictions, another goal of mine has been portability. Netbooks filled a portability void partly _because_ of their price. They were small and light, but being cheap made them easier to bring everywhere without worry.

For better or worse, the only permanent in life is impermanence. I received my degree and started my software development career. As much as I loved that netbook, it just couldn't handle the tasks I needed.

### My Other Machine is a Cloud

Although remote desktop solutions are nothing new, the past decade brought many new and wonderful tools and services into that space. With the rise of cloud-based VMs and Kubernetes clusters, many are trading full-blown applications on laptops for simply accessing them via SSH.
Within a few seconds, you can have a complete Linux machine running in a VPS for pennies a day.

With modest hardware and an internet connection, I have effectively-unlimited near-instant access to more computing power than even the bulkiest of laptops.

The always-on access to mountains of computing power *does* go against some of that hacker-gone-artist ethos. However, it brings it back into the realm of remotely-useable-for-work.

## Previous Attempts

Here are a few of the other setups I've tried. I still use some of these, but who says I have to pick just one? ;-)

### An iPad and Keyboard

What initially introduced me to the elegance of an SSH-focused setup was using an iPad Pro and keyboard cover to connect to a VPS. Even compared to this Chromebook, that setup is even smaller and lighter. Because the screen is so much better, it also made for a great media consumption device.

So why don't I use that?

Well, a lot of times I still do. It's often easier to carry an iPad than a laptop. Especially after switching from the iPad Pro to the almost-handheld iPad Mini.

However, using a tablet+keyboard just isn't quite the same as a laptop form-factor. Actual lap usage is uncomfortable, at best. Every keyboard I've tried is either unusable in a lap or missing _something_ (Escape key, strange layout, etc.).

For a touch-typist heavily focused on the CLI, tablet keyboards sit in the uncanny valley. They are perfectly fine for quick sessions on-the-go, but for me, a Chromebook still just feels closer to home.

### The Twelve-Inch MacBook

Circa 2015, I switched over to using a Mac for my professional and personal work. I won't get into details, but it made sense for me as someone who traveled a lot for work.

Trying to recapture that netbook form-factor, I bought one of the 12" MacBooks (no suffix). While I used that machine professionally for a few years, it just didn't feel quite the same. The hardware itself was great, the build quality immaculate, and it weighed right around two pounds.

However, macOS just simply didn't let me tweak what I wanted in order to get the most out of the minimal hardware. This only got worse as time went on. I recognize the efforts to run Linux on Apple hardware, but that is not an adventure for me.

Once the little Mac started to show its age (made even more premature by a lack of fans), I gave it to a family member who has put it to good use.

As much as I enjoyed that laptop, I don't think I'd buy another one. It cost way too much for something I only managed to use as a daily driver for a couple of years.
Not that it matters anyway, as Apple discontinued the lineup.

### A Small-ish ThinkPad

About a year ago, I was in search of a small Linux laptop (much like how I got this Chromebook). I ended up buying a Lenovo L13 Yoga with a 10th-gen i5 and 8gb of RAM. It even has a TrackPoint and a Wacom stylus, which are nice options.

This machine runs Fedora like a dream. It's small for what it can do, and it can do quite a lot. Using Proton, I'm even able to play a surprising number of games on Steam. In fact, this machine got me back into gaming on Linux.

For longer trips away from home, this ThinkPad is my primary laptop these days. While not particularly beefy, I can expect to run _most_ things I need and even play a few games. Video conferencing tools work fine on it (something I haven't yet tried on the Chromebook).

There are just a lot of cases where I don't want to bring my ThinkPad with me, though. It's not particularly heavy, but not particularly lightweight, either. While it was not crazy expensive, it cost enough that I don't like taking it everywhere.

## I Underestimated ChromeOS

Chromebooks are also nothing new. Funny enough, the initial version of ChromeOS was available during the peak of my netbook usage!

While it took ChromeOS a while to get beyond _just_ providing a browser, I  looked my nose down at them for too long. I assumed that they were great for Google Docs, GMail, maybe some YouTube, and not much else. Basically, perfect for grade school children stuck using GSuite and browser-based assignment portals.

What I didn't realize was the group of enthusiasts and talented engineers working to make it quite a robust system. Side note: apparently CoreOS, now owned by Red Hat, was originally based off of ChromeOS. Small world.

While it is still heavily limited in many regards, you can do and install a surprising amount on a Chromebook these days. You're not going to replace your gaming laptop with one, but it's not just for email and Twitter, either.

*Especially* if you're comfortable with a Linux CLI.

## Linuxen-filled Linux

On a Chromebook, you currently have at least five different ways of running some common Linux tools. I'm not going to provide tutorials or explain the gritty details of how each works, but I'd like to give an overview of what each option provides and some of the drawbacks. Most of these are not mutually exclusive and you can swap between them, as needed.

I am still relatively new Chromebooks, so take this as your warning to do your own research before installing anything. Some of these options _do_ have potential security implications!

The options are roughly in ascending order of complexity and capability. You might not have all of these options if you are on a particularly old Chromebook. Anything from a major manufacturer within the past couple years should work, though.

NOTE: Keep in mind that enabling developer mode, without any other steps, laxes a lot of the security around ChromeOS. There are ways to re-enable boot kernel verification without losing developer mode and you can lock down passwords and sudo access for the `chronos` user. However, realize that you are taking physical machine security more into your own hands by enabling developer mode.

### Secure Shell Chrome Extension

Link: https://chrome.google.com/webstore/detail/secure-shell/iodihamcpbpeioajjeobimgagajmlibd

This extension is perfect if you just want to use your Chromebook to SSH into other machines. It also provides a number of _really_ nice features, such as clipboard integration and SFTP. Newer versions even include MoSH, which you should check out if you use SSH a lot.

While it can be opened without an internet connection, it is useless without one as it _only_ provides remote access. That is, it does not include any additional tools or CLI access to the Chromebook itself.

The performance/battery impact is less than opening another tab to your average news site, which is great for the provided flexibility. Because it doesn't need developer mode, this one of the most secure options. The extension is from Google, so it should be as trustworthy as the OS itself.

The main drawback is that it requires another machine to remote into (even just a cheap VPS). Things like UI development might need additional steps as the development server isn't running on the same machine as the browser.

Personally, this is my favorite option for "real work". It allows me to continue my existing tmux session away from my desktop and battery life should be the highest possible.

### Linux-y Android Apps

While based on Gentoo, ChromeOS has enough Android bits to run apps, including terminals and SSH apps. For example, Termux provides basic Linux tools and includes a package manager to install more.

Because these are just Android apps from the Play Store, you don't need developer mode. However, you are limited to whatever functionality and packages the app provides. Because you're running everything through the app, you're also trusting the app developer quite a bit.

I'm not sure about battery impact, but I expect it is slightly higher than the browser extension, but less than Crostini (below). It will likely depend heavily on the app and your usage.

Personally, I like keeping Termux installed as another option, but I don't use it much. The environment is too sandboxed for my needs, but that could be considered a benefit.

### crosh (Ctrl+Alt+t)

While it is largely uninteresting on its own, you can access a minimal terminal from the ChromeOS browser. The "Chrome OS developer shell", or crosh, is accessed from the browser with `Ctrl+Alt+t`.

The most interesting command it provides is `shell`, which drops you into something a bit more bash-like. In this shell, you get access to the file structure and some common tools like Vim, SSH, grep, etc.

The performance/battery impact should be similar to the Chrome extension. The `shell` command seems to require developer mode and the provided functionality is minimal.

Personally, I only use this option for quickly managing local files or setting system flags. The Chrome extension handles remote connections far better, while Crostini and Crouton provide way more functionality.

### Crostini

While called `Linux (Beta)` by ChromeOS, Crostini lets you run a full Linux VM. It's pretty easy to set up and comes directly from Google.

For a "beta", it seems really stable and implies it will only get better. While we all know how Google sheds projects like a snake sheds skin, I expect this to stick around. The tech this is based on has been stable for a long time and they've already done the hard integration work.

Without additional setup, it's limited in available packages. However, provided packages are impressively integrated with the rest of the system. Despite running in a VM (and perhaps a container under that?), many graphical Linux packages are available. Once installed, they appear in your app list and run just like any other app.

Because it is a VM, you will need to configure directories on the host to be shared inside the VM. Additionally, the VM will reserve an amount of system memory while it is running.
This means Crostini will likely impact device performance and battery life even when idle.

However, if you need to run something like the GIMP, this is a fair tradeoff. I've even seen some people set up VSCode, though I have yet to try that myself. Overall, it really is quite a feat to install graphical applications in a VM and access them from the host OS with no additional configuration. This adds a ton of functionality to even a really low-powered Chromebook (like this one).

Personally, this is my go-to option if I need to work locally. The VM starts up quick and doesn't have a tremendous impact on performance. However, it _does_ eat up a bit of memory, which is at a premium on this machine. So I don't like to leave the VM running when I'm not using it.

If your machine has more memory, you could likely leave the VM running without concern.

### Crouton

Within ChromeOS, this is the most extreme option for accessing the traditional Linux world. From the Crouton GitHub page (https://github.com/dnschneid/crouton):

> crouton is a set of scripts that bundle up into an easy-to-use, Chromium OS-centric chroot generator.

What that means is it allows you to install a "more complete" Linux system *alongside* ChromeOS.

You manage the chroot much like a VM, but using chroot means this is neither a VM nor emulation. With crouton, you don't need to dual-boot and you can switch between ChromeOS and your Linux chroot with a hotkey. You can get into an Xfce environment (among others) while still having quick access to your regular ChromeOS setup. Your chroot doesn't start up with ChromeOS and you can shutdown the chroot to regain computing resources.

Performance and package availability should be higher than Crostini. Currently, only Debian and Ubuntu are available officially and I'm not sure what all is possible in the chroot environments.

This is *by far* the least secure option as it requires developer mode _and_ running unofficial scripts as root. While it is a popular and generally-trusted open source project, you are nonetheless handing the "keys to kingdom" over to strangers on the internet. Understand the risks involved, account for your threat model, and proceed with caution.

Personally, I have Crouton installed on my machine. Mostly as a means to experiment with it and see what possibilities it unlocks. I plan to continue playing around with it, but if I were setting up a new Chromebook, I would probably avoid it. I would only consider it if I _really_ needed (or wanted) a traditional Linux desktop. In that case, however, I would probably avoid ChromeOS altogether.

### Bare Metal Linux

This is honestly the option I currently know the least about. When I bought the machine, I had the expectation that I could install Linux directly to the drive. That is, I could find a way to install Linux *instead* of ChromeOS.

Personally, while I still believe it's possible, I don't think I'll use this option. ChromeOS likely utilizes the miniscule hardware better than I could achieve with manual tweaking. If you really want a full-powered standalone Linux machine, then I'd say buy one of those and not a Chromebook.

## Thoughts on Education

I love small projects that grow into bigger learning paths.

My original experience with that netbook all those years ago became a watershed moment for me. That sort of spark is something that I hope more people can experience, especially children.

For better or worse, technology runs more and more of our everyday lives. Projects like Raspberry Pi and the Maker community help teach people about how some of that works. Knowledge is power, after all.

I now see how Chromebooks can contribute to expanding that, too. Especially with the addition of tools like Crostini, a kid with a Chromebook has access to many of the same tools behind very powerful systems.

## Final Thoughts

Personally, I'm expecting to learn a lot from this little $100 machine. Honestly, even if I lost it tomorrow, I'd say I already got my money's worth just from what I've learned thus far. At the very least, it opened my eyes to the truly interesting technical capabilities of ChromeOS these days.

In particular, I see how a Chromebook can continue the legacy of my beloved netbook.