Perhaps I’ll make this a series of posts which widen the discussion to consumer-centric agency and protection in the current technological landscape, such as copyright, right to repair, ownership, centralization, self-hosting, and personal projects concerning the aforementioned. Perhaps I won’t.

For now, let’s focus on something that most people are familiar with to some extent — Privacy Policies and Terms of Service.

Privacy Policies and Terms of Service

A privacy policy is a statement or legal document (in privacy law) that discloses some or all of the ways a party gathers, uses, discloses, and manages a customer or client's data, while a privacy notice tells clients or data subjects what data is held by an organisation and how that data will be handled.

- https://en.wikipedia.org/wiki/Privacy_policy

Terms of Service, also known as Terms of Use and Terms and Conditions, are the legal agreements between service providers and the service consumers. The person must agree to abide by the terms of service in order to use the offered service. Terms of service can also be merely a disclaimer, especially regarding the use of websites.

- https://en.wikipedia.org/wiki/Terms_of_service

You’ve been there. I’ve been there. We’re both guilty of it. You sign up for an account, see a wall of text and a green button moving you forward in the process. We could have just agreed to some ridiculous stipulations for using the service, or your data could be handled in such as a way that would make George Orwell sick to his stomach.

We’ve normalized scrolling to the bottom and clicking “Accept” without understanding how our privacy and service experience are impacted, and it’s no surprise. These documents are almost always verbose and overly comprehensive. At the end of the day, they are meant to minimize legal liability and fulfill regulations for companies, rather than be helpful notices to the consumer. It’s difficulty to argue that consumers are the ones at fault when these documents employ “legalese” along with a shotgun approach of trying to cover every edge case.

We’re left with a bleak, and almost hysterical, state of technological affairs where nearly every service requires signing away on documents that really should necessitate a lawyer to be at your beck-and-call. While we can hope for a day where services are required to provide “human-readable” versions of these documents, I’m tired of our current circumstances and want to look into what can be done now. While there’s still plenty more learning and research to be done on my end, I want to briefly discuss two suggestions on how we could mitigate the issue as consumers — GenAI and ToS;DR (no that’s not a typo).

Potential Application of GenAI

Considering the foremost trend in technology (and many other facets of life to a lesser extent) is generative artificial intelligence (GenAI), the first idea I had was to leverage general-purpose large-language models (LLMs).

Given the plain-text-only nature of privacy policies and terms of services, integrating GenAI might be as simple as having a template prompt and uploading copy-pasted snippet(s) of the documents. Retrieval-augmented generation (RAG), chunking, and likely a slew of other AI techniques that have been/are being developed probably can make the process more efficient in terms of context window limitations and ingesting the content of said documents.

If I were to take a stab at this (which might be something I do and cover in the future) this could be a browser extension that parses the contents of the webpage, perhaps does some sort of more efficient chunking or stream processing of the contents, sends requests to a self-hosted open-source LLM, and displays the returned brief summary in the browser extension modal.

As an aside, if it was not clear yet, I claim no expertise in AI engineering and advanced techniques, and my approach might pose numerous inefficiencies or naive design decisions. Moreover, the irony is not lost on me that this approach hinges on open-source LLMs, which are often trained on data that was scraped, processed, and/or used in ways that violate and infringe upon other services’ advertised privacy policies and terms of service. Not to mention, they are typically developed by companies often at the center of these issues in the first place.

Getting back on track, the idea seems like it has promise, and it may also be a rare example of how GenAI could meaningfully be helpful to consumers. However, before reinventing the wheel and/or throwing AI at the problem, I want to begin looking for existing, mature tools and approaches that can help out with this issue. Let’s talk about the most promising option that I came across, so far.

ToS;DR (Terms of Service; Didn’t Read)

“Terms of Service; Didn’t Read” is a play on the phrase “Too Long; Didn’t Read” (TLDR), often used in context of requesting/providing a summary of a lengthy text. Similarly, ToS;DR provides a summary of the Terms of Service and Privacy Policy for numerous services. It relies on human contributors akin to Wikipedia, and provides various browser/operating system integrations to make leveraging the existing summaries seamless.

I haven’t use ToS;DR to a great extent yet so, while this is not a comprehensive review, here are some initial thoughts I have on the service.

Pros

• ToS;DR can help alleviate the pain that comes with scrolling through verbose text blocks by providing human-verified key points

• Each listed service also is given a cumulative letter grade, based on how consumer-friendly the policies/terms are

• Anyone can become a contributor, and contributions go through a review process

• Chrome, Firefox, and Safari browser extensions are available, along with Android and iOS apps

Cons

• Due to ToS:DR relying on human contributions, not every service will have an entry, and entries may be outdated or have inaccuracies

Conclusion

My eyes hurt typing this, so I’m going to stop now. Perhaps my retinas will allow for a slick conclusion next time. Please share this post with someone you love, hate, or know, particularly if they’d be interested in any of the potential future topics mentioned in the introduction.

Tune in for next time, where I will write about something, trying to pass off ideas from the depths of my stream of consciousness as an article that shows a semblance of polish, a hint of jest, and a handful of grammatical errors.

Sent from my Web3-based, IoT, always-listening, AI-assisted, smart Generic Air Purifier X,

The Algomist

Ch1. Humble Beginnings

Once upon a time, there existed a software engineer who resided continuously hunched within a dreary cubicle - adorned with demotivating motivational posters and speckled with horrendous fluorescent light from above. The day was coming to an end and they were just about ready to clock out.

Their eyes - gleaming with some sign of life, particularly boredom - glazed across their MacBook's fingerprint-smudged screen. The employee had realized that they needed to complete one last operational task before ending their remarkably unremarkable day. "Let's get this over with," they say with a rapturous murmur.

"Okay, simple enough, let's download a Docker image from the registry that this project uses for containerized builds. I'm sure the command is in my terminal history."

Ch2. The White (Docker) Whale

"Damn."

They don't see the command that they are looking for even after quickly tapping the up arrows roughly twenty times.

"No worries, you've done this enough that you can do type it out in no time!"

. . .

"Shit."

They forgot a dash in the internal Docker registry name.

"Alright no worries, up arrow once more and add the dash and enter."

They forgot to supply the registry API token.

"Oh yeah, this again. Let me pull up the secret, I'm sure I have it saved somewhere on my desktop," they say, unfazed. They attempt the command once again.

Ch3. UnaBASHed

"Sweet, the image is downloading. This task is turning out to be no biggie."

Now, it's time to build the project. Lucky for them, it's only a poorly documented Bash command that is incomprehensible because there are twenty pipes (|) and seven ANDs (&&) littered throughout. They start praying that it's in their terminal history.

A bead of sweat drips down their forehead.

After a few minutes of terminal history-hunting, accompanied by a orchestra of shallow breathing and stressed-out grunts, they realize that instead of scouring through their terminal history, they could just search Slack to find the command posted in the past by their teammate.

"Brilliant, let's search Slack and just copy-and-paste it!"

Ch4. Pesky Platforms

"Bingo," they say with a smirk, as if they have finally hacked into the metaphorical mainframe everybody seems to mention. The job doesn't permit them to be cool often, or really at all. Thus, the employee has to milk any opportunity they get to feel cool.

They've found it. After a simple copy-and-paste into the terminal session, they hit enter and...

"Fuck. Why is glibc for node-rdkafka throwing errors when compiling? What the hell is this shit!?"

. . .

"Calm down... It's just because you're using an ARM64 processor. Easy, all you have to do is redownload that image from the beginning for ARM64 - instead of X86 - and then pass in the platform as an argument in half of the commands. Wait, what were the commands, again?"

Ch5. Subjectively, a Matter Expert

The employee left nearly two hours after everyone else. With one final "win" under their belt, they packed their sleek black laptop bag and swaggered to the elevators.

"This is the work of a hero - a champion. Somebody's got to do it, and just seems like the world has chosen me to be the paragon of excellence," they somehow convinced themselves.

. . .

Legends say that, to this day, the employee does not realize they were the cause of the complete production datacenter outage that cost their company at least a few million dollars.

Epilogue

"Drat," their tech lead says in the customer incident report. "They must have used an old version of the build scripts that didn't run the unit tests. Will make an action item to prevent this for next time!"

. . .

The action item remains in that team's evergrowing backlog of operational burdens tasks.

Moral of the Story?

Wouldn't it be nice if you didn't have to type out the same thing over and over again? Save yourself the time scouring for it in your terminal history, on the web, and in your team chats. Just create your own dotfiles and maintain them!

Dotfiles 101

What are "dotfiles"? Let's start with examples you are likely familiar with. Developers often encounter one of the following "dotfiles" relatively frequently:

• .bash_profile

• .bashrc

• .zshrc

• .vimrc

• .gitconfig

• .gitignore

• .npmrc

• .yarnrc

• .env

If any of these look familiar, then congrats, you have experience with a dotfile! Dotfiles are plaintext files prefixed with a dot. Pretty straightforward right?

Dotfiles are typically used to define configurations for programs, such as shells (Bash, Zsh), text editors (Vim), version control systems (Git), and package managers (NPM, Yarn). In the case of .env, a dotfile can also be used to store static data such as environment variables.

They can be used in conjunction a special dotfile - your shell profile dotfile (e.g. .bashrc if your terminal uses Bash or .zshrc if it uses Zsh) - in order to significantly augment your terminal's "smartness"!

Abstracting Responsibilities

While you can add directly to your shell profile dotfile, I find that this can get unruly really quickly. Instead, I prefer adding to "external" dotfiles and importing them into my shell profile dotfile by using source to essentially import their contents. This way, I can create dotfiles with distinct responsibilities.

Other than the shell profile name (and other protected dotfile names like those listed above), the names of the following dotfiles are arbitrary. You can use whatever system of grouping works best for you.

Secrets and Exports

One example is a .secrets or .exports dotfile, which could export persistent global variables like API access tokens. Bonus points for this one, since it makes it easier for you to share your screen with a colleague or collaborator. This way, debugging sessions - which can often require editing shell profile dotfiles - won't result in you exposing sensitive secrets that you need to have stored locally.

Our starry-eyed employee could have just exported their registry's API token as a shell environment variable here to save themselves the hassle of finding and manually inputting the secret.

Aliases and Functions

More examples are a .function or .alias dotfile that could hold all your custom shell functions or aliases. In the case above, the employee could create functions/aliases (depending on the complexity of the logic) that make often repeated tasks much less arduous.

In the story above, the employee could have created an alias to download that specific image and assign it to an easy-to-remember command like pull-my-img.

Meanwhile, for the build command sequence, which was different depending on the platform required (i.e. X86, ARM64, etc.), they could have turned it a function. This function could then take a parameter, representing the platform, which could easily be substituted into all the commands in the sequence where the platform needed to be specified. Instead of a bulky, hard-to-remember, and easy-to-mess-up sequence of commands, the employee could have just run build-my-project x86 or build-my-project arm64.

Portability

Last, but not least, dotfiles have the advantage of being hyper-portable. They are extremely lightweight, being plaintext files that are often small and can be made smaller by factoring them into separate files like mentioned above.

Store these on flash media like a thumb drive or SD card and you'll be quickly rolling with a souped-up terminal. Push them to a remote Git repository or cloud storage, and you'll be able to pull your favorite settings, custom functions, and time-saving aliases from nearly anywhere. This makes sharing your setup or setting up a new environment a breeze!

Introduction

What is a Keyboard Shortcut?

Keyboard shortcuts are, at their core, a series of key presses that map to specific actions, enabling you to perform tasks more swiftly and conveniently. Take, for example, the ubiquitous copy-and-paste operations. By using keyboard shortcuts, you can save valuable seconds that would otherwise be spent right-clicking and navigating through context menus.

Why should I care?

You might wonder why these saved seconds matter in the grand scheme of things. After all, a few seconds here and there may not seem like a game-changer. However, the true impact of keyboard shortcuts becomes apparent when you consider how often you switch between your keyboard and mouse during a typical workday.

Each switch, no matter how brief, accumulates into a substantial amount of time over the course of a day, week, or month. Time that could have been better spent on tasks that truly matter. When you realize that these moments of inefficiency are limiting your overall output, you'll start to grasp the significance of this small yet impactful change in your workflow.

The importance of adopting keyboard shortcuts extends beyond simply producing more work. It's about reclaiming your most precious resource: time. As the saying goes, "Time is money," and that holds true for every person on the planet. We are all constrained by the same finite hours in a day.

The goal here isn't to pile on more tasks or obligations. It's about accomplishing the same tasks more efficiently, thus freeing up time for the things you genuinely cherish. Keyboard shortcuts aren't just a productivity hack; they are a strategic investment in reclaiming your time and redirecting it towards pursuits that bring you joy.

While keyboard shortcuts might appear as a minor adjustment in your daily routine, they have the potential to revolutionize the way you work. By implementing these time-saving tools, you can streamline your workflow, boost productivity, and ultimately find more time for the things that truly matter in life. So, why not embark on this journey to turbocharge your workflow with keyboard shortcuts and experience the transformative power they offer?

Shortcuts

Text Manipulation

Navigation

Window Management

Code Editor

Visual Studio Code

JetBrains IntelliJ

Terminal Emulators

Conclusion

Hopefully, I have convinced you to take the time to learn these shortcuts, as well as to actively seek out other ways to improve your workflow. However, software engineering, web development, and work, in general, is not the end-all-be-all.

Remember, the goal of improving your workflow is not to cram more work into the same block of time. We should instead see it as a way to get the same amount of work done more efficiently, freeing up time to do what you want to do.

Cheers, and stay tuned for more productivity content!

Manipulating files within a WSL instance

Let's say we have a file named alice.txt located on a Windows drive with the file address of C:\Users\<WIN_USER_NAME>\Documents\. To move the file to a WSL instance to the present working directory, run the following in a WSL terminal instance:

mv /mnt/c/Users/<WIN_USER_NAME>/Documents/ .

Note how they are essentially the same file path with just two key differences! First, /mnt prepends any file address. Second, backslashes (\) are swapped for slashes (/). Now that we know this, we can easily leverage other file manipulation commands, such as ls, cp, cat, vi, file, and so on.

Manipulating files in a WSL instance from Windows

Let's say we have the same file as before, alice.txt, but we've moved it to the WSL instance and it now has the file path of /home/<WSL_USER_NAME>/. To manipulate this file from your Windows host machine, the most straightforward way is to simply use File Explorer and navigate to \\wsl$.

Here you'll see a folder for each of your WSL instances, where the folder names should map to the Linux distro that each instance uses (e.g. Ubuntu). Likely, you'll only have a single WSL instance so it should be simple to locate the correct folder. Navigate into the WSL instance folder, then home, and finally <WSL_USER_NAME>. Congrats, you'll find alice.txt in this folder and can manipulate it accordingly!

You can even leverage the knowledge of these file addresses for CMD or PowerShell commands. To quickly check the current file address, simply right-click on the File Explorer address bar at the top and click "Edit Address" to display the file address in place or "Copy Address as Text" to copy the file address to your clipboard.