DEV Community: Guy Bianco IV

s/Netbook/Chromebook/

Guy Bianco IV — Sat, 04 Dec 2021 18:44:26 +0000

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.

Controlling photoanalysisd

Guy Bianco IV — Tue, 14 Aug 2018 12:01:48 +0000

Background

I recently bought a new MacBook. This article gets better, I promise.

I decided to set it up fresh instead of restoring from a backup. I like to take the time to try and simplify what I've got on my machine.

Naturally, I expect most applications to take a little bit to sync down settings, files, etc. All of Apple's stuff in particular has a lot to do and I'm fine with that. However, the one I am not so fine with is Photos.

Specifically, a process called photoanalysisd.

This is a background service that, as the name implies, is responsible for analyzing your photos. For the most part, it seems like it is trying to recognize people. This service is directly tied to the "People" tab in Photos (more on this in a moment).

The fact that this happens on your machine and each of your machines is a good thing! There may be some things that get sent off to Apple, but the majority of the work seems to be happening on your hardware.

What is not so good is the level of control you have around if/when/how this service is controlled. Or, in this case, how it seems to control your machine.

If you go into the People tab of Photos before it is done analyzing, you will see its progress. Even if you have a fairly beefy machine, this process takes a long time. Weeks kind of long time. The only exception seems to be if you have a photo library barely into or lower than quadruple digits.

On the surface, this shouldn't be an issue. The sorts of analysis its doing is probably computationally intense. It uses a good amount of resources, but doesn't try to fully harness the machine since it is meant to be a background process that occurs over the course of days.

The main issue seems to be that you have no control over this process. I never plan to use the People tab, yet my machine still has to painstakingly go through my entire library. I have a medium size photo library (~10k) and after a few hours on the 12" i5 MacBook, it has managed to go through almost 300 of them. Many people complain about their way more powerful iMacs taking weeks to go through libraries of similar size.

During this process, the machine is still usable, but it doesn't go unnoticed. It does use about 25% of the CPUs constantly. This causes the fanless machine to constantly stay pretty warm and chug on some things. Usually not enough to notice, but seems like it might cause someone to be less than impressed with their brand new device if they didn't know this was going on.

On top of that, it is almost impossible for a normal user to learn this is going on. The only mention of "photoanalysisd" is in Activity Monitor. This should not be the only location to learn about something that is using days of CPU time. For a feature I imagine a lot of people either don't want or don't care about having on every device with Photos.

Yet it gets worse.

There are seemingly very few ways to actually get it to stop or even pause. Supposedly, it only runs when a) the machine is plugged in and b) Photos isn't running. This means that people that want it to pause so they can get CPU cycles back resort to running off battery unnecessarily or leaving Photos open for no reason. Even leaving Photos minimized makes it start up again. However, mine still runs even with Photos focused, so I guess it doesn't really matter.

You can also just let it finish, but this takes quite a long time (well after their 14 day return policy is up). It also seems like it gets stuck for some people, never finishing.

You can use launchctl to disable and kill the service. However, you have to make sure to disable all the appropriate services, otherwise this is only a temporary reprieve.

Per user Gordan Aspin (https://dev.to/gordonaspin):

you do disable it but only in the gui context which is created every time the user logs in and why it keeps be “re-enabled”. Your disable is only for the current GUI login.

You also should be able to (re)move the service file, but that may or may not affect system stability. Not something I really want to try, personally. YMMV.

How to actually do it

To do this, you'll need to open up Terminal and run a couple of commands. Any time you're asked to copy and paste commands into your terminal, it's a good idea to at least have at least a basic understanding of what the commands are actually doing to your system.

The following commands are really 4 command. The && basically means "run the first one (on the left) and if that's successful, run the second one (on the right). launchctl is the command that is used to control system services in macOS.

First, you'll disable and kill the GUI instance:

launchctl disable gui/$UID/com.apple.photoanalysisd && launchctl kill -TERM gui/$UID/com.apple.photoanalysisd

As well as the actual service:

launchctl disable user/$UID/com.apple.photoanalysisd && launchctl kill -TERM user/$UID/com.apple.photoanalysisd

Closing Thoughts

First off, if anybody from the Photos team somehow ends up reading this, I'm begging you to give us an off switch for the People tab. I don't use it, I don't plan to use it, and it is a huge waste of resources.