ElijahLynn.net

A note about Merge/Pull Request titles and commit messages

Wed, 21 Aug 2024 00:00:00 GMT

Merge Request (GitLab) and Pull Request (GitHub) titles are commit messages when using a squash and merge strategy on GitHub or GitLab. Write your titles like they are going to be a commit message, because they are.

examples of not great commit messages:

Fixed stuff (fixed what?)
add initial config (for what?)
WIP
lol forgot this

examples of better commit messages:

Fix null pointer exception in UserService when user data is null
Improve load times by optimizing image assets
Remove deprecated API usage from OrderService
Update dependencies to latest versions to fix security vulnerabilities

Arch Linux is the best distribution for beginners

Thu, 03 Dec 2020 18:02:36 GMT

This a stub/draft for now, public though.

AUR is the best for beginners
yay pacman wrapper is amazing, it gets from official Arch repo AND AUR.
Install 99% of packages this if doesn’t exist can make your own AUR, but most of the time someone has already done this.
AUR downfalls:
- Most are not public repos to submit merge/pull requests against. I think they should all be on an AUR GitLab for collaboration
- Only way to communicate is to in comments on the AUR package page
Other distros are a nightmare for installing things

Writing just to write

Fri, 19 Jun 2020 17:20:44 GMT

Writing just to write. Writing is a habit that I want to create in my life. Something about the loop of outputting, then reading it back and inputting it back into my brain and the cycle of that all that really helps me think better.

Part of the habit is just writing, and I haven’t yet written here since I got the Netlify CMS functionality added to this site therefore I haven’t actually gotten to use this feature, which I am doing right now to write this post.

I love the real-time preview that happens on the right side pane!

And another thing I really like is that Netlify CMS is 100% open source (as opposed to Medium, which is closed source). This means that I can actually tweak and modify the functionality as I like and when I find a bug I can file an upstream issue here https://github.com/netlify/netlify-cms.

Okay, time to publish, all about the momentum!

Netlify CMS is setup (#ultraworking)

Sun, 24 May 2020 23:24:57 GMT

I am writing this from elijahlynn.net/admin which is using the Netlify CMS and easily lets me add images and just have a better UI to enter content. The idea here is that it reduces friction and then I can actually write more!

Testing a screenshot upload right here. Hrm, cannot paste images, need to upstream that. I did add the image below from the UI though, which is great.

I started this blog in the beginning of 2019 doing an Ultraworking marathon and didn’t really do much since then. Now I just did another Ultraworking session now that I signed up for 24/7 workcycles with The Work Gym and finally got this last step finished in a focused 5.5 hour work session! This is fantastic! Ultraworking is sooo effective.

Filesystem Commands & Notes

Fri, 25 Oct 2019 00:00:00 GMT

I’ve been digging into using AWS’ fairly new NVMe SSDs for some performance tests with the goal of tarring thousands of files and multiple gigabytes in under a second. Because these operations are fairly fast on my local laptop NVMe SSD, and it turns out the SSD EBS volumes, which are not local, are pretty slow compared to my local. Just documenting some commands here, like a cheat sheet that I can use later. Out of the box a c5d.2xlarge (‘d’ = enhanced (d)isk) EC2 instance has a locally attached 200GB NVMe SSD. This allows for the lowest possible latency, however, it does not come with a filesystem and therefore isn’t mounted on boot. The below commands are how to take a raw volume, put a filesytem on it and then mount it for testing.

First, let’s list out our filesystems, their size and mount path with df --human:

[root@ip-10-247-114-103 ~]# df -h                 
Filesystem      Size  Used Avail Use% Mounted on  
devtmpfs        7.6G   64K  7.6G   1% /dev        
tmpfs           7.6G     0  7.6G   0% /dev/shm    
/dev/nvme0n1p1  985G  8.9G  976G   1% /

We don’t see our superfast local SSD mounted above.

All gp2 and io1 EBS volumes are mounted as /dev/nvme* devices (some have pointers from /dev/sdb etc). Here we have our root gp2 general purpose SSD volume, /dev/nvme0n1p1 mounted at / for the entire system to run on. But, we don’t see our real NVMe SSD though, nor another io1 volume I attached for testing. These raw volumes both will need filesystems created before they can become useable. I will only be targeting nvme2 for these examples, the fast one.

Let’s list out our attached volumes with ls -l (-l = ‘long format/more info, no long-option):

[root@ip-10-247-114-103 ~]# ls -l /dev/nvme*
crw------- 1 root root 250, 0 Oct 24 23:45 /dev/nvme0 # This is the root gp2 volume. 
brw-rw---- 1 root disk 259, 2 Oct 24 23:46 /dev/nvme0n1
brw-rw---- 1 root disk 259, 5 Oct 24 23:46 /dev/nvme0n1p1
brw-rw---- 1 root disk 259, 6 Oct 24 23:45 /dev/nvme0n1p128
crw------- 1 root root 250, 1 Oct 24 23:45 /dev/nvme1 # A io1 volume I have attached for testing. 
brw-rw---- 1 root disk 259, 1 Oct 24 23:45 /dev/nvme1n1
crw------- 1 root root 250, 2 Oct 24 23:45 /dev/nvme2 # The _real_, local NVMe SSD. 
brw-rw---- 1 root disk 259, 0 Oct 26 00:48 /dev/nvme2n1

Next, blockdev --getsize64 dev/nvme2n1 to tell us how many blocks are on our attached volume, so we can verify that the 200GB volume that I provisioned is actually the nvme2 because of the 200000000000:

[root@ip-10-247-114-103 ~]# blockdev --getsize64 /dev/nvme2n1 
200000000000

lsblk appears to be a bit better for checking attached volume size as it lists human-readable form by default. It also lists partitions if they exist.

[root@ip-10-247-114-103 ~]# lsblk                  
NAME          MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT 
nvme0n1       259:2    0  1000G  0 disk            
├─nvme0n1p1   259:5    0  1000G  0 part /          
└─nvme0n1p128 259:6    0     1M  0 part            
nvme2n1       259:0    0 186.3G  0 disk            
nvme1n1       259:1    0    70G  0 disk

mount --show-labels - This is the infamous mount -l, which I always thought meant --list but it doesn’t, and is the reason why all documentation should always use “—long-options”, they are self-documenting. Sample output:

[root@ip-10-247-114-103 ~]# mount --show-labels
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,relatime)
devtmpfs on /dev type devtmpfs (rw,relatime,size=7908016k,nr_inodes=1977004,mode=755)
devpts on /dev/pts type devpts (rw,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /dev/shm type tmpfs (rw,relatime)
/dev/nvme0n1p1 on / type ext4 (rw,noatime,data=ordered) [/]
devpts on /dev/pts type devpts (rw,relatime,gid=5,mode=620,ptmxmode=000)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,relatime)

Next is the file --special-files /dev/nvme2n1 command that we use to tell us if there is a filesystem on the volume. Here is what it looks like if there is no filesystem.

[root@ip-10-247-114-103 ~]# file --special-files /dev/nvme2n1
/dev/nvme2n1: data

Here we make an XFS filesystem with mkfs --type xfs /dev/nvme2n1 (yum install xfsprogs --yes if the prior command throws an error):

[root@ip-10-247-114-103 ~]# mkfs --type xfs /dev/nvme2n1 
meta-data=/dev/nvme2n1           isize=512    agcount=4, agsize=12207032 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=1, sparse=0
data     =                       bsize=4096   blocks=48828125, imaxpct=25
         =                       sunit=0      swidth=0 blks 
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal log           bsize=4096   blocks=23841, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

Now we have a filesystem and we verify with file --special-files /dev/nvme2n1:

[root@ip-10-247-114-103 ~]# file --special-files /dev/nvme2n1 
/dev/nvme2n1: SGI XFS filesystem data (blksz 4096, inosz 512, v2 dirs)

lsblk shows that even though we have a filesystem, there still isn’t a partition on /dev/nvme2n1, and we don’t actually need one:

[root@ip-10-247-114-103 ~]# lsblk                  
NAME          MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT 
nvme0n1       259:2    0  1000G  0 disk            
├─nvme0n1p1   259:5    0  1000G  0 part /          
└─nvme0n1p128 259:6    0     1M  0 part            
nvme2n1       259:0    0 186.3G  0 disk            
nvme1n1       259:1    0    70G  0 disk

[root@ip-10-247-114-103 ~]# fdisk -l

Disk /dev/nvme2n1: 200.0 GB, 200000000000 bytes, 390625000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes


Disk /dev/nvme1n1: 75.2 GB, 75161927680 bytes, 146800640 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

WARNING: fdisk GPT support is currently new, and therefore in an experimental phase. Use at your own discretion.

Disk /dev/nvme0n1: 1073.7 GB, 1073741824000 bytes, 2097152000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk label type: gpt


#         Start          End    Size  Type            Name
 1         4096   2097151966   1000G  Linux filesyste Linux
128         2048         4095      1M  BIOS boot parti BIOS Boot Partition

Below you can see that ebsnvme-id tells us if we have EBS devices or not:

[root@ip-10-247-114-103 ~]# /sbin/ebsnvme-id /dev/nvme2n1 
[ERROR] Not an EBS device: '/dev/nvme2n1'
[root@ip-10-247-114-103 ~]# /sbin/ebsnvme-id /dev/nvme1n1 
Volume ID: vol-03a0af9a8cad9be07
sdb                             
[root@ip-10-247-114-103 ~]# /sbin/ebsnvme-id /dev/nvme0n1 
Volume ID: vol-0350248eed34cb730
xvda

And, in the spirit of not publishing this without finishing it because if I don’t publish it right now then it may never get published because kids are begging me “how many minutes are you going to be done working” right this minute and taking my headphones off to ask it as this is the weekend coming up and it is Friday night I am going to publish this in its confusing imperfections and touch it up later.

@todo Fix it to be accurate
@todo Put cheatsheat at top

Ultra Working Plus Run Breaks

Tue, 08 Jan 2019 00:00:00 GMT

tldr; Ultra Working + Run Breaks resulted in me running nearly 2 miles in short 2-3 minute increments.

Over this past weekend I completed an Ultra Working ”Work Marathon” which was a great success. The result of it was that I built this blog and now have a place to publish this article, which is something I had put off for quite sometime, yay for progress here!

Yesterday was the first day back at my day job, where I doing DevOps and Drupal on VA.gov. Around noon, I decided to go ahead and apply the same format to yesterday which was a fantastic success. The work cycles are 30 minutes each with a 10 minute break in between. I was able to get 9 work cycles in from 12:40pm to 6:30pm.

Now, instead of just taking the 10 minute break I modified them with something I have been doing off and on for the past 1-2 years. Which is do short, fast “Run Breaks”. A Run Break is almost just like a cigarette break (yes, I used to smoke the nicotine when I was a teenager) but obviously leaves you in a better state. I love Run Breaks because they don’t require a large mental effort or even changing into running clothes. Before, if I had made a goal to run a mile, I might have easily put it off whereas with a Run Break, it is so short that is hard to fail.

The wear on my Altra running shoes of all my run breaks over the past 1-2 years

Before Ultra Working though, I was lucky to get 1-2 Run Breaks in per day, and some days and weeks I would skip them altogether. I always had a goal of getting to do 1 Run Break per hour, especially since I work at home and know there are health consequences to those who don’t exercise and remain sedentary. So us “work at homers” need to be proactive about activating our lymph system and moving some blood around from time to time. So, I had a vision of running more and then came this past weekends Work Marathon.

So back to yesterday, I applied the Work Marathon format and made a copy of the Google Sheet that was provided to us, this sheet is key to the program and gives the structure and sets the cadence. I also combined it with my lifetime subscription to Focus@Will (referral link, $20 credit for you, $20 gift card to me) and some Bose QC35 Noise Cancelling headphones which together are like a peanut butter and jelly sandwich, perfect pairing! Then for the breaks I decided to do combine my Run Breaks during the 10 minute break. I was amazed, it worked! Over the next 7-8 cycles, I ran around the block every break! Each run around the block is a little over .25 miles which meant I had run close to 2 miles! And the best thing about it is that not only was the Work Cycle format successful during my day job but I was able to incorporate my goal of running every hour into it.

Google Map distance measurement of my Run Break around the block

In closing, the Work Cycles format combined with the noise cancelling headphones and Focus@Will were already the perfect match, but adding in Run Breaks really tops it off!

Write It Out

Fri, 04 Jan 2019 00:00:00 GMT

I taught myself how to code when I was 30. I am 37 now and have had many days where I got my ass kicked. In the beginning, I got my ass kicked more days than I kicked ass. At some point the tide turned, and I started kicking ass more than I got my ass kicked. At some point you just absorb something called intuition and you can figure things out much quicker than you were able to before, like driving a car I suppose.

One tool I found along the way that I really, really value is a very simple technique for solving challenges that anyone in any profession can use. In the software industry this technique we use is called Rubber Duck Debugging. The concept is that you get yourself a cute rubber duck (or a BIG one), put it wherever you can make eye contact with it.

Rubber Duck Project 2009 by kazuma jp CC-BY 2.0 https://www.flickr.com/photos/kazuma_jp/3928192219

And you talk to the Rubber Duck. You talk to the Rubber Duck out loud. You tell the Rubber Duck about your challenge. You explain the challenge, step by step, in detail to the Rubber Duck. You explain your challenge to your new friend, Rubber Duck.

How many times has the act of explaining something led you to the answer mid-sentence?

me: Hey Person McPerson, do you know where I put my …
me: Oh, never-mind, I just remembered where I put it.

That was a pretty glorified example but it illustrates a point. The person didn’t even respond, but you now have an answer. This has happened to everyone on the planet at least once.

You explain to Rubber Duck just like you would explain to your highly paid colleague whom has two input devices (ears) attached to a high-speed, functioning logic unit (brain) attached to an audible output device (mouth + vocal cords). When you are successful with a one-way dialogue with either your Rubber Duck or your Highly Paid Colleague you now have the answer and there are two differences between the two, the first is obvious which is cost, the second is independence, yup INDEPENDENCE! You didn’t need to wait, you figured it out yourself, and you further strengthened your psyche that you can figure shit out, which is one of the better highs in this life.

The act of explaining your challenge out to Rubber Duck turns out to be extremely insightful and usually helpful and most importantly it is very effective. The Rubber Duck method has 100% of the time always produced progress for me. Sometimes challenges are hard and all challenges are solved with progress. Rubber Duck delivers progress, sometimes big gains, sometimes barely incremental progress, but it is progress.

I use Rubber Duck debugging daily but not how I explained earlier. I don’t actually have a Rubber Duck and I don’t talk actually talk out loud to my Rubber Duck. Instead… my Rubber Duck is a text document, a daily journal that I type my challenges into, the file isn’t even named Rubber Duck Diary or anything like that. I don’t care if it gets erased or saved past my current challenge. I just open a text document, I type my current challenge, then solutionize just below. I do not care about punctuation or grammar. I just start typing, listing out thoughts and action steps that usually lead to uncovering the next piece of the puzzle, continuously making progress. It is like a loose to-do list, just a flow of the mind, and I love that it produces progress, every time.

Rubber Duck = Progress.

=======================================
tl;dr

Oh Rubber Duck, Rubber Duck
Let me tell you
I’ve got this challenge
That I just need you to see
Please let me type
My thoughts into you
Then tell me what you think
Oh whats that
You have a next step
Why thank you kind fellow
We shall meet again soon
Rubber Duck, Rubber Duck…

(loop until challenge solved)

It's alive!

Wed, 02 Jan 2019 00:00:00 GMT

This is my first post on my new blog!

The site is built with Gatsby.js which is powered by React JS and GraphQL. It has offline support thanks to a Service Worker! And for a superfast first load it also is using HTTP/2 (H2), I thought it was interesting that when pulling from the Service Worker cache it uses HTTP/1.1 as the protocol, so to test I needed to flush the Service Worker cache!

I built this during day 1 of the Ultra Working Marathon!

The source code is at https://gitlab.com/elijahlynn/www.elijahlynn.net

I originally had it hosted on Surge but had issues with https and service worker registration and moved it to Netlify and setup autodeploy from GitLab!

More to come!