Al Idian

Keeping Your Place with Git Worktrees

Al Idian — Fri, 03 Apr 2026 00:00:00 GMT

The context-switching problem

It happens often enough: you are in the middle of a feature branch, files scattered in various states of half-done work, and something urgent comes up. A bug needs a hotfix. A colleague asks you to review their branch. You need to run the app on a different branch to compare behaviour.

The usual answer is git stash — push your work onto a temporary stack, switch branches, do what needs to be done, switch back, pop the stash. This works fine for small interruptions. But for longer context switches, stashing starts to feel clumsy. You lose the mental picture of where you were, and there is always a small risk of forgetting you left something on the stash.

Git worktrees offer a cleaner solution.

What is a worktree?

When you clone a repository, Git creates a single working tree — the directory where you see and edit files. A worktree is simply an additional working tree linked to the same repository. Each worktree can be checked out to a different branch simultaneously, and they all share the same underlying .git data.

The result is that instead of switching branches within a single directory, you can navigate between branches the same way you navigate between directories.

Basic usage

To add a worktree, run the following from inside your existing repository:

$ git worktree add ../personal-site-hotfix hotfix/my-fix

This creates a new directory at ../personal-site-hotfix (relative to your current position) and checks out the branch hotfix/my-fix there. If the branch does not exist yet, you can add the -b option:

$ git worktree add -b hotfix/my-fix ../personal-site-hotfix main

This creates the branch hotfix/my-fix from main and checks it out in the new directory.

From this point, you have two independent working trees:

Your original directory, still on your feature branch, untouched.
A new directory at ../personal-site-hotfix, on the hotfix branch, ready to go.

You can open a second terminal, cd into the new directory, make your changes, and commit — all without disturbing your original working tree.

To see all active worktrees, run:

$ git worktree list

Once you are done with the worktree, remove it:

$ git worktree remove ../personal-site-hotfix

Practical scenarios

Hotfixes without losing your place

This is the scenario I use worktrees for most often. Rather than stashing half-done work, I add a worktree for the hotfix branch, make the fix, and remove the worktree when done. My feature branch remains exactly as I left it.
Reviewing a pull request

Reviewing code that requires actually running the application used to mean stashing or committing before switching branches. With a worktree, I can check out the branch under review into a separate directory, run the app there, and keep my own work running in the original directory at the same time.
Running parallel builds

If you maintain builds across multiple branches at once — say, a stable release branch and a development branch — worktrees let you keep them both ready without any branch switching overhead.

A few things to keep in mind

You cannot check out the same branch in two worktrees at the same time. Git will prevent this and return an error.
Worktree directories persist on disk until you explicitly remove them. It is a good habit to clean them up once you are done to avoid accumulating stale directories.
Since all worktrees share the same .git directory, any commits you make in a worktree are immediately visible from other worktrees and from the main repository.

TL/DR

Git worktrees let you work on multiple branches simultaneously without stashing or committing incomplete work. For quick context switches — hotfixes, PR reviews, parallel builds — they are a notably cleaner alternative to the usual branch-switching workflow.

Things That Made Me Happy in 2025

Al Idian — Wed, 31 Dec 2025 00:00:00 GMT

At the end of each year, I plan to compile a list of my favourite things, i.e. books, films, shows, and games. This is inspired by Barack Obama's famous lists and by the delightful What's Making Us Happy segment of NPR's Pop Culture Happy Hour podcast.

Here is this year's list...

Books

Babel by R.F. Kuang
Children of Time by Adrian Tchaikovsky
Ender’s Game by Orson Scott Card
Harry Potter and the Philosopher’s Stone by J.K. Rowling
Piranesi by Susanna Clarke

Film/TV

A Real Pain (2025)
Encanto (2021)
Karate Kid: Legends (2025)
Left-Handed Girl (2025)
My Old Ass (2024)
One Battle After Another (2025)
Severance, Season Two
Warfare (2025)

iPhone Settings to Improve Focus

Al Idian — Tue, 20 Sep 2022 00:00:00 GMT

Our attention is constantly under attack. Most news and media organizations, ad-slinging tech companies, and internet influencers and personalities ultimately seek to convert our attention into profit. In Stolen Focus (2022), Johann Hari writes, “The sensation of being alive in the early twenty-first century consisted of the sense that our ability to pay attention — to focus — was cracking and breaking.”

The ability to pay attention for extended periods is important for creativity, self-reflection and satisfaction, and productivity. And curing our current environment of attention-deprivation will likely require great political change. Until then, we can do what we can to preserve and improve our own ability to focus.

In my case, I find that my iPhone has the potential to be the largest attack vector to my attention. I suppose the same is true for most people I know. Fortunately, the iPhone can be configured to minimize distractions and encourage improved focus.

Here below, I describe iPhone settings that have helped me personally. These are, of course, opinionated recommendations that will not work for everyone.

Use the Focus Modes feature

Focus Modes was introduced in iOS 15. At its most basic form, it is an enhanced Do Not Disturb feature. Beyond a conventional Do Not Disturb, Focus Modes are highly-configurable and well-integrated with the rest of iOS. For example, users can create a Focus Mode for driving that switches on automatically if the phone detects that the user might be driving a vehicle and disables all calls. Another Focus Mode might be for bedtime which will hide apps that are too stimulating or distracting.

I like to have the following Focus Modes:
- Do Not Disturb
  
  This is your typical Do Not Disturb feature. It disables all calls, messages, and notifications. Typically, I use this setting when walking, running, working out, or reading.
- Work
  
  I use this at the start of focused work sessions when I am doing either paid or personal work. Unlike the more generic Do Not Disturb setting above, it allows notifications from my authentication app, something I use heavily to interface with remote systems. All other notifications, calls, and messages are disabled.
- Sleep
  
  This Focus Mode is toggled on automatically at 930pm, which is when I should be getting ready for bed. It hides apps that might keep me from falling asleep. Effectively, this Focus Mode turns my iPhone into a great little ebook reader. All calls, messages, and notifications are disabled.
- Driving
  
  I use this when I am driving or biking. Currently, the settings are identical to the Do Not Disturb one above, but I still prefer to keep a dedicated Focus Mode for this activity.
Drastically reduce notifications

Notifications are dangerous. If left unchecked, they can very quickly sap away one’s attention and focus.

My advice here has three parts:
- Notifications for most apps on your iPhone should be completely disabled. Some of your apps will continually bug you to turn notifications back on but you must resist. Like with the KonMari method, try to put as many apps as you can in this bucket. When in doubt, lean towards disabling notifications.
- Enable notifications for only a select few apps. Ones that come to mind are Messages, Phone, and FaceTime. Note that you can easily disable these at certain times only using the Focus Modes features described in item 1 above.
- Use the least distracting type of notification that you can get away with. For the Mail app, do you really need a notification on your lock screen or a banner to dynamically appear whenever you get mail? For me, a badge notification on the Mail app icon is sufficient.
Disable all Siri features

In Apple products, Siri pertains not only to the voice-activated smart assistant but also to a slew of “intelligence features” that includes suggestions. These suggestions are driven by user behaviour and data. For example, if a user habitually uses their Books app before bed, Siri might suggest this app to the user every evening.

I personally dislike features like these, ones that try to learn user behaviour and make suggestions. I prefer to to interact with my devices with intent and agency. And so, I feel strongly about keeping this feature disabled. Unfortunately, iOS does not make this convenient: disabling Siri suggestions involves going into each app’s individual settings.

In the future, I hope to see Apple implement easy ways to opt out of software design paradigms that corrode user focus and attention. I think this is a genuine possibility given the positive action Apple has already taken in other important areas like privacy and repairability. For now, the settings described above help me maintain a healthy relationship with my iPhone.

Course Review: Software Development Process

Al Idian — Sat, 20 Aug 2022 00:00:00 GMT

Georgia Tech Online Master of Science in Computer Science (OMSCS) is an innovative, award-winning graduate program offered by the College of Computing at Georgia Tech. (Wikipedia)

As I make my way through this program, I intend to write short, opinionated reviews of the courses I complete. My intended audience for this is the current or prospective OMSCS student who is considering taking these courses.

Overview

CS6300 is an introductory course on the software development process. It emphasizes skills and knowledge essential to anyone joining a modern software team and is probably one of the least challenging courses in the OMSCS program. If you have experience working in a software development team, expect to already know many of the things covered in this course.

Topics covered include the software development life cycle, version control systems, the fundamentals of system architecture and design, and software testing. Before taking this, make sure you are comfortable with Java and object-oriented programming.

Projects

This past semester, there were six assignments and two projects composed of several deliverables. All assignments and projects can be completed on any reasonably-modern machine, regardless of processor or operating system.

Each assignment was relatively short, meant to be completed in a week. Some could be as trivial as completing a survey or doing basic-to-intermediate operations in git and GitHub. The most time-intensive assignments involved designing and writing unit tests for a small Java app. Each assignment was weighted differently, ranging between 2 and 18 percent of the final grade.

The two projects were more intensive. One was completed as part of a group and the other was individual:

The group project (28% of the final grade) was the most rewarding part of the course (and potentially the most troublesome). It involved designing and writing an Android application that allows a user to input and compare job offers. Just as important as the programming (done in Java or Kotlin) are ancillary tasks like project management, requirements engineering, software design, and testing.
The individual project (25% of the final grade) involved systematically defining the necessary unit tests for a console app written in Java and then implementing those unit tests. The ideal number of tests were between 50 and 90. Surprisingly, I found this exercise interesting and novel but, using the wrong approach, I can see how it can quickly become tedious.

Learning materials

Lectures were all pre-recorded and are of better quality than any other course I’ve seen so far in the OMSCS program. Much credit here goes to the instructor, Dr. Alessandro Orso, who succeeds at communicating his passion for the topics at hand.

There is no course textbook but two readings cited near the end of the semester are well worth reading for any software development professional: The Cathedral and the Bazaar by Eric Raymonds and No Silver Bullet by Frederick Brooks.

Exams

There are no graded exams in this course. Simple end-of-module (mini-) quizzes are provided to help gauge student engagement and understanding.

Teaching staff

Unlike all other courses I have taken so far in OMSCS, the professor is heavily involved in the day-to-day of CS6300. He holds weekly office hours and is responsive (as much as can be expected) in the course discussion board.

In general, the course is managed impeccably by the professor and his TAs. TA Justin Durkin stands out as an absolute rockstar in the way he engages with students in the discussion board.

Project and assignment results were provided within an acceptable timeframe, and students are always apprised of any changes in schedule.

Difficulty

CS6300 is the easiest course I have taken so far in the OMSCS program. Having had significant work experience as a software developer, this was something I expected. I was unsure of how the group project would go but I was fortunately teamed up with some great performers who wanted to succeed in the course just as much as I did.

On average, I spent less than ten hours per week on this course.

Conclusion

CS6300 is well-run but does not really seem to be a graduate-level course. It is a great one to take for those with little-to-no work experience in a software development team. Taking CS6300 in the summer allowed me to ease off and recharge in preparation for a heavy semester ahead in the fall.

Writing an App Uninstaller for macOS

Al Idian — Tue, 16 Aug 2022 00:00:00 GMT

What did I make?

The process of uninstalling apps on macOS can be disorienting for new users. While on Windows, users typically use an uninstaller or the Add or Remove Programs utility, uninstalling apps on macOS simply means dragging the .app file to trash. For many, this minimalistic process triggers distrust and disbelief. What about preference files and other gunk written by the application that presumably remain in the system?

I recently wrote an app uninstaller called zap that deals with this problem. It is command-line only and is packaged as a script that can be downloaded from GitHub and run without installation.

zap is similar to other uninstaller applications on macOS like AppCleaner in that it tries to accomplish the same task. Unlike AppCleaner, zap is free and open source. Users can be confident that zap does only what it says it does.

For a short usage guide, see the readme here.

Decisions, decisions…

To find files to remove, zap first checks inside the .app file. In macOS, .app files are directories that contain the binaries and ancillary files related to the application. zap expects to find a file called Info.plist, which contain identifiers for the application.

zap looks in some common directories for any files that contain the retrieved identifiers. Instead of deleting, it moves these files to trash.

In my testing, the approach used provides a good balance of reliability and protection. zap intentionally casts a wide net to gather files for deletion but it requires a manual review from the user to mitigate any false positives.

There are also obvious limitations:

To find files to delete, zap relies on identifiers in Info.plist. If an unrelated file’s name somehow contains one of the identifiers, it will be moved to trash.
Only a static list of directories are searched. Any files written to unconventional locations in the file system will be missed.
Manual intervention is required to completely delete any files found. This step is required to give the user a chance to restore any false matches.

The state of uninstallers

The process of uninstalling apps is imperfect and messy on macOS, and the situation isn’t much better on Windows and Linux. Mass-market operating systems generally allow apps the freedom to write to unconventional locations on the file system. As a result, app uninstallation often leaves behind unnecessary files. While these files are usually unobtrusive and insignificant, some users certainly prefer that these files be removed as part of the uninstallation process.

Recommendations

In my opinion, it is unlikely the situation will improve anytime soon for personal computers. I recommend the following multi-part approach:

Mostly follow the officially-supported way of uninstalling apps. On macOS, this typically means simply dragging the .app to the trash.
On a regular basis (perhaps once every 1-2 years), completely refresh your computer. This means removing files and directories and reinstalling the OS. To make this process easier, one can use a Time Machine image from a freshly-installed state.
In rare instances where you want to purge an app from your system without doing a complete refresh, use zap.

Course Review: Computer Networks

Al Idian — Sun, 24 Apr 2022 00:00:00 GMT

Georgia Tech Online Master of Science in Computer Science (OMSCS) is an innovative, award-winning graduate program offered by the College of Computing at Georgia Tech. (Wikipedia)

Overview

CS6250 is a broad exploration of modern and traditional internet architecture. It is light on prerequisites, making it an ideal first course to take in the OMSCS program. CS6250 deepens student knowledge on many internet-related technologies used in software development and computer science.

Topics covered in the course include internet history and architecture, protocols and technologies used, router design, software-defined networking, internet security, and internet applications.

Projects

There were five full projects in the course this past semester, along with an optional one for extra credit. A custom x86 VM image (running Ubuntu) was provided for all of the projects below. While some projects can be completed on any reasonable host OS or in a Docker container, others require the use of the VM provided. Apple Silicon machines may be a viable option for some projects — but not all!

In my opinion, the projects were by far the most interesting and challenging part of this course. They account for 66% of your grade. Each project uses Python, and an intermediate knowledge of Python is sufficient. It is helpful to know basic ways to keep Python performant (e.g. using the correct collection types and using nested loops with appropriate caution).

Project 1 tasks students with implementing the Spanning Tree algorithm in the context of preventing forwarding loops in the Data Link layer of the internet.
Project 2 involves implementing a distributed Bellman-Ford algorithm in the context of calculating routing paths in a computer network.
Project 3 involves implementing a configurable firewall using OpenFlow. Popular tools like Mininet and Wireshark are used to complete requirements and test your solution. Familiarity with using a shell and perhaps a command-line editor like vi is helpful here.
Project 4 tasks students with demonstrating the vulnerabilities of Border Gateway Protocol (BGP). Like project 3, this project uses Mininet and benefits from familiarity with using the command-line.
Project 5 uses BGPStream and its Python interface PyBGPStream to analyze and manipulate BGP data. The goal is to take useful measurements based on snapshots from an actual production network.
Project 6 is shorter and counts only for extra credit. It is also much more open-ended and involves using BGPStream and PyBGPStream to identify and examine real-world data involving a global event that has significantly affected the internet. Students are encouraged to use resources like IODA and Netblocks.org to identify candidates for study. Unlike the other projects, students are asked to use a Jupyter Notebook and the matplotlib library to present findings and methodology.

Learning materials

Learning materials for the course is primarily provided in text form. Some modules have accompanying videos but many do not. Even when videos are present, they don’t offer more than the text. I found both text and video materials for this course to be decent but quite dry. Thankfully, the modules are relatively small and involve frequent ungraded quizzes to test understanding.

At the start of the term, a study guide is provided to students. The study guide is a detailed set of questions for each of the twelve modules. This resource was invaluable because it allowed me to systematically find the answers to the study guide questions as I completed the modules. In the process, I constructed a resource that helped me do well in the exams and quizzes.

There is no required textbook but Computer Networking by Kurose and Ross is frequently cited as an optional resource. Aside from this, each module has a collection of optional resources students can look into should they want to dig deeper.

Some projects direct students to read tooling documentation or journal articles to provide guidance and context. I found it was enough just to scan these external materials and to only read more if I got stuck.

Exams

There were two exams. Both were closed-notes and proctored through Honorlock. There were also end-of-module quizzes for each of the twelve modules, which were open-notes and unproctored. None of the exams or quizzes were difficult.

To do well on the exams and quizzes, I found it was enough to rely on the study guide provided at the start of the term. The study guide is a detailed set of questions for each of the twelve modules. It is easy to find answers to these questions as students are going through each module.

Teaching staff

For the most part, this course is run by TAs. The professor appears in the pre-recorded lectures and sometimes conducts office hours and responds in Ed, the course’s discussion platform. I did not mind this at all — I don’t think I would have taken away more from the course if the professor was more involved.

TAs were helpful and polite but I think they could have been more responsive to posts on the discussion board. Not only do the TAs conduct weekly office hours, they have daily timeslots where students can ask questions. Although I never made use of these daily timeslots, I believe this is going above and beyond and deserves a kudos! I can also point to specific instances in the course where TAs made reasonable adjustments on-the-fly to accommodate student requests.

Lastly, project and exam results were provided within an acceptable timeframe. When there were delays (always due to students getting approved extensions), the class was informed.

Difficulty

I found this course mostly engaging yet easy. At no time during this course was I stuck on a problem that required some sort of mental leap. The projects were interesting but I was always able to complete the projects with time to spare. The exams and quizzes were fair.

I spent around 10-15 hours per week on this course.

Conclusion

CS6250 delivered on its goal of deepening my knowledge of internet technologies and computer networking in general. The material covered is interesting, and I think every computer science professional should probably know the contents of this course. Although I don’t foresee myself working directly on the technologies discussed here, they are ubiquitous enough to be helpful no matter which area of computer science I end up in.

On Shorter Retry Loops in Elden Ring

Al Idian — Sun, 17 Apr 2022 00:00:00 GMT

Elden Ring is the newest game from acclaimed Dark Souls developer FromSoftware. It has released to near-universal praise and currently sits among the most highly-rated games of all time according to Metacritic. Elden Ring retains and refines many design patterns present in other FromSoftware games like Dark Souls, Bloodborne, and Sekiro. But unlike any other game from this developer, Elden Ring is situated in an expansive open-world setting, which has been compared to The Elder Scrolls V: Skyrim and The Legend of Zelda: Breath of the Wild.

In Elden Ring, FromSoftware has been able to expertly balance several complex game systems with jaw-dropping precision. In this post, I discuss how Elden Ring encourages learning from failure better than its predecessors and reflect on how this same pattern can be applied to writing software.

FromSoftware’s games are known to be “tough but fair”. By tradition, one of the first things each Souls game teaches its players is that death comes swiftly and often. This lesson is not taught through a conversation with an NPC or some pop-up text but through gameplay. Players are fully expected to have to fight important enemies many times to learn their attack patterns and weaknesses. However one aspect of Souls games that has been a cause of frustration for new and experienced players alike is the dreaded walk back to the boss after a defeat.

In Souls games, the walk back to a boss is traditionally unnecessarily long and dangerous. As a result, retrying a boss encounter becomes a long, arduous process. For games where players are expected to die several times to the same boss, it is obvious to see how this loop can cause many to quit in frustration.

Elden Ring breaks out of the mold by shortening the retry loop for many of its important enemies. In Elden Ring, when a player dies to a boss, the walk back is usually short and relatively safe. This is a significant improvement because it minimizes frustration and encourages looking at defeat as a genuine opportunity for learning. In Elden Ring, instead of feeling dejection, I often found myself smiling even after losing by the smallest of margins. I even found that I was better able to stay in a flow state across boss attempts.

This truncated retry loop in Elden Ring contributes highly to my enjoyment of the game. While in the other games I would start to feel some frustration after the second or third attempt at a boss encounter, in Elden Ring my mind was fully engaged with thinking up and executing on a game plan.

When writing software, a similar loop can come, for example, in the following forms:

Finding and fixing a bug,
Calling an unfamiliar API, or
Analyzing an prorgam’s behaviour or performance.

Like bosses in Souls games, these programming tasks require cycling many times through compiling, running, debugging, and modifying code. Whenever a loop like this exists for a software development task, it is worth considering whether something can be done to shorten the retry loop. Doing so can save time and prevent frustration. It is also usually much more satisfying to solve the problem of shortening a retry loop than mindlessly repeating a set of tasks.

This practice of reducing dull repetition can also give developers opportunities to write small, focused programs to make their jobs easier. The following quote by Abraham Lincoln comes to mind: “Give me six hours to chop down a tree and I will spend the first four sharpening the axe.”

Course Review: Information Security

Al Idian — Mon, 29 Nov 2021 00:00:00 GMT

Georgia Tech Online Master of Science in Computer Science (OMSCS) is an innovative, award-winning graduate program offered by the College of Computing at Georgia Tech. (Wikipedia)

Overview

CS6035 is a true introductory graduate course. It assumes an undergraduate-level familiarity with the course material and tackles a breadth of topics across the Information Security field. CS6035 gives students the lay of the land in Information Security and aims to prepare them for more focused study in one or more of its subfields.

Topics covered in the course include software security, operating system security, authentication, database security, malware and malicious code, cryptography and encryption, and web security.

Projects

There were four full projects in the course this past semester, along with a short one for a little extra credit. A custom x86 VM image (either Debian or Kali) was provided for each of the projects below. This means Apple Silicon machines are not a viable option here.

In my opinion, the projects were by far the most interesting and challenging part of this course. They also account for at least 80% of your grade.

Project 1 tasks students with exploiting a buffer overflow exploit in C. The bulk of this project involved reading and understanding C, applying buffer overflow concepts, and using gdb for debugging in order to successfully complete a buffer overflow attack to invoke a new shell. Familiarity with c and gdb is helpful here, as well as being comfortable with using a shell and perhaps a command-line editor like vi. Some review of low-level OS concepts like registers and memory is recommended.
Project 2 applies machine learning concepts to categorize malware using a tool called malheur. There is no programming here — but general comfort with using a shell and introductory machine learning knowledge are helpful.
Project 3 uses python to complete some interesting cryptography-related exercises. For instance, it explores interesting ways the RSA protocol can be broken (due to its mathematical idiosyncrasies). This is the most programming-intensive project in this course — but it is mostly just filling out stub methods and writing helper functions. A basic-to-intermediate-level knowledge of python is sufficient. The ability and willingness to quickly grok mathematical relationships (e.g. modular math) is helpful here.
Project 4 is about web security and requires some ability to read and write JavaScript and PHP. While the programming component is easy to grasp even for beginners, the project more intensively tests for understanding of concepts like cross-site scripting (XSS), cross-site request forgery (CSRF), and SQL injection.
Project 5 is shorter and is done only for extra credit. It is a modified version of Project 1 which requires the insertion of shell code in a buffer to manipulate code execution into invoking a new shell. I believe there are plans to eventually turn this mini-project into a full one in the future.

Learning materials

The lectures were all pre-recorded and are of generally good quality. I found them to be a good first pass at the material, before diving into the textbook readings.

The textbook Computer Security by Stallings is comprehensive (if a little dry). In my opinion, anyone taking this course should get it. Since the quizzes are all open-book and many questions are derived from the textbook, it helps to have a digital version handy so you can ctrl + f. I found that as I naturally progressed in the course, I read almost the entire book.

Several times in CS6035, students are required to read from other provided sources which include journal articles and technical blogs. I found many of these interesting and almost always helpful towards completing the projects.

Exams

There were two exams. Both were closed-notes and proctored through Honorlock. There were also four quizzes, and they were open-notes and unproctored. Neither the exams or the quizzes were very difficult. I found them fair especially since they don’t count for very much in the final grade.

Teaching staff

The course feels like it is run solely by the TAs. The professor (along with a colleague) appeared mostly only in the pre-recorded lectures. This might be a deliberate strategy on the part of the teaching staff. I found I did not mind this at all — I don’t think I would have taken away more from the course if the professor was more involved in office hours or in the discussion boards.

The TAs were usually patient, helpful, and responsive. In general, they will not spoon-feed information to students (which is to be expected in a graduate-level course). Interestingly, the TAs can also be quite stingy in giving out solutions to projects even after the due date. Students would need to find the answers by researching the material themselves.

Difficulty

This course was mostly easy. There were certainly components of the projects that I had to wrestle with for many hours but I was always able to complete the projects with time to spare. The exams and quizzes were fair, and ample time was provided to complete each component of the course.

I spent around 10-15 hours per week on this course. If you don’t meet some of the prerequisites, expect to spend a little extra time to get yourself up to speed.

Conclusion

CS6035 was an excellent first course in OMSCS. The material covered is mostly interesting and not overly challenging. Although some aspects of security is exciting to me (e.g. operating system security, cryptography, etc.), I was not as keen on the organizational security topics in the course. CS6035 did for me exactly what an introductory graduate course should do: tell me which parts of the Information Security field I might want to study more deeply.

Remap Caps Lock to Control

Al Idian — Sat, 30 Oct 2021 00:00:00 GMT

Displace the Caps Lock key

The Caps Lock key occupies a prominent position on modern keyboards. This placement was inherited from the Shift Lock key on mechanical typewriters where pressing the key physically shifted the mechanism allowing consecutive typing of uppercase letters. The key was relatively large and prominently placed because it required more force to press compared to other keys, which often meant that typists preferred to push it down with two fingers. (Stack Overflow)

Today, the Caps Lock key has a much less important role. For most typists, typing in all caps is rare. In internet-based communication, like email, instant messaging, or social media, typing in all caps is generally frowned upon as it is associated with yelling (Wikipedia). Even when a few consecutive uppercase words are required, it is usually easy enough for a capable typist to use the shift key/s instead. This makes the Caps Lock key an excellent candidate to remap to a more useful key instead.

Promote the Control key

As a software developer and an avid user of Vim and Vim-style keybindings, my preference is to remap Caps Lock to Control. Not only is the Control key heavily-used within a typical software development workflow, the Control key on most keyboards is usually relatively difficult to reach.

Here are some examples of keyboard shortcuts involving the Control key that I use frequently:

Vim
- Control + [ - Escape
- Control + f - Move down a page
- Control + b - Move up a page
- Control + d - Move down a half page
- Control + u - Move up a half page
- Control + r - Redo changes
Terminal
- Control + a - Move to the beginning
- Control + e - Move to the end
- Control + f - Move forward one character
- Control + b - Move backwards one character
- Control + w - Delete all prior characters until the next space
- Control + u - Delete all characters
- Control + c - Send interrupt signal (SIGINT) to the current process
Visual Studio Code
- Control + Shift + p - Launch Command Palette (Windows and Linux)
- Control + ` - Launch Terminal
- Control + / - Toggle line comment (Windows and Linux)
Other
- Control + x - Cut (Windows and Linux)
- Control + c - Copy (Windows and Linux)
- Control + v - Paste (Windows and Linux)
- Control + z - Undo changes (Windows and Linux)
- Control + y - Redo changes (Windows and Linux)
- Control + t - Open new tab (Windows and Linux)
- Control + w - Close current tab (Windows and Linux)

If you use an IDE or another type of technical program, chances are that keyboard shortcuts in that program also make heavy use of the Control key. Clearly, the Control key deserves a prominent position on many software developers’ keyboards.

How to Remap Caps Lock to Control

The most convenient way to replace Caps Lock with Control is not to remap at all. An excellent line of keyboards called the Happy Hacking Keyboard (HHKB) is set up by default to have the Control key in the recommended position. Alternatively, any programmable keyboard (with onboard memory) can also be easily configured to have this feature. With one of these solutions, your operating system needs no further configuration; you can connect your keyboard to any computer and keep the same mapping you are used to.

Remapping Caps Lock to Control is most simple on macOS. All that is needed is to change the Modifier Keys configuration in the Keyboard settings. This performs the remapping on the OS-level. A similar setting exists on iPadOS.

On Windows, I recommend installing the PowerToys utility from Microsoft. PowerToys is an excellent open-source project that give power users more ways to configure Windows. Note that you probably want to set PowerToys to run on startup and to run as administrator. The latter allows your PowerToys keymappings to take effect even when running an application as administrator.

Per usual, there are myriad ways to remap keys on Linux. The way you might want to do it would depend on your preference, your distro, and your desktop environment. On Pop!_OS 20.04 LTS (GNOME), my favourite way is to run this in the command line:

gsettings set org.gnome.desktop.input-sources xkb-options "['ctrl:nocaps']"

In my experience, this method is simple, reliable, and requires no additional installation.

TL/DR

The Caps Lock key has limited use but occupies a prominent position in modern keyboards. On the other hand, the Control key is much more useful but is more difficult to reach. In this post, I recommend remapping Caps Lock to Control and provide ways to do this in popular operating systems. As an alternative, I suggest using a keyboard that either has this layout by default or can be programmed with this layout.

Why Use Analogies in Software Teams?

Al Idian — Sun, 15 Aug 2021 00:00:00 GMT

Software developers and technologists are often afforded the time to learn niche and complex material through study and deep interaction. Many times, it is simply part of the job to wrestle with obtuse concepts and systems in the process of delivering something of value to the company or organization. This learning can come from deliberate study or merely from doing regular work duties, such as creating or maintaining a computer program or system.

Colleagues in other roles, like managers, directors, and analysts, might not be provided the same opportunities to gain the specific knowledge developers pick up as part of the job. As a result, developers often become the natural subject matter experts on the things they work on.

As the technical experts, software developers are counted on to provide insight into the behaviour and effects of software systems. This is often not an easy task. Understanding how an application or a system works internally may require specialized knowledge that non-developers cannot be expected to pick up within a short conversation or meeting.

The question then is: How can developers provide stakeholders just enough information to minimize complexity and yet allow them to understand important details and make informed decisions?

Fortunately, as a matter of necessity, any good programmer is already intimately familiar with managing complexity. A pervasive Computer Science concept that comes to mind is abstraction, which involves “filtering out — essentially, ignoring — the characteristics that we don’t need in order to concentrate on those that we do.” (BBC).

In programming, constructs like functions, classes, libraries, and APIs are all created as a means to reduce complexity while allowing informed interaction. In conversation and writing, analogies take a similar role. Analogies convey the rough shape of an idea by comparing it to something already familiar to the recipient. The good use of analogy is a tool developers can use to communicate the important bits of information to stakeholders in a way that is easy to understand and reason about.

Of course, all analogies break down — and so they are not meant to take the place of technical descriptions or documentation. But in situations where time and energy is constrained such that people cannot be expected to pour swathes of time into reading documentation, good analogies are often sufficient.